Spring AOP几种方式的使用

骑猪看日落 2022-06-05 06:17 266阅读 0赞

### 引入依赖 ###

<spring-version>4.2.3.RELEASE</spring-version>
    
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring-version}</version>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring-version}</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring-version}</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring-version}</version>
    </dependency>
    
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.8</version>
    </dependency>
    
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.8</version>
    </dependency>

### Service ###

> HelloService.class

public interface HelloService {
    
        /**
         *  hello method
         */
        void hello(String words);
    }

> HelloServiceImpl .class

@Service("helloServiceImpl")
    public class HelloServiceImpl implements HelloService {
        @Override
        public void hello(String words) {
            System.out.println(words);
            int i = 1 / 0;
        }
    }

## 方式一：使用MethodInterceptor ##

> 切面类 LogInterceptor.class

import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    
    /**
     * @author yuyufeng
     * @date 2017/11/14
     */
    public class LogInterceptor implements MethodInterceptor {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            System.out.println("#before");
            Object ret = invocation.proceed();
            System.out.println("#after");
            return ret;
        }
    }

### XML配置 ###

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
        <context:component-scan base-package="learn.service.impl"/>
    
        <bean id="logInterceptor" class="learn.interceptor.LogInterceptor"></bean>
    
        <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
            <property name="beanNames">
                <value>*ServiceImpl</value>
            </property>
            
            <property name="proxyTargetClass" value="true"/>
            <property name="interceptorNames">
                <list>
                    <value>logInterceptor</value>
                </list>
            </property>
        </bean>
    </beans>

### 测试 ###

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration({"classpath:spring/spring-service.xml"})
    public class Demo1 {
        @Autowired
        private HelloService helloService;
    
        @Test
        public void test() {
            System.out.println("Demo1.test");
        }
    
        @Test
        public void testHelloService() {
            try{
                helloService.hello("hello 你好~");
            }catch (Exception e){
                System.out.println("出现异常");
            }
        }
    
    }

### 执行结果 ###

#before
    hello 你好~
    出现异常

## 方式二：使用@Aspect方式 ##

### 配置Aspect类 ###

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    
    /**
     * @author yuyufeng
     * @date 2017/11/14
     */
    @Aspect
    public class LogAspect {
    
        /**
         * 方法前执行
         * @param point
         */
        @Before("execution(* learn.service.impl.*.*(..))")
        public void methodBefore(JoinPoint point) {
            handleMethod(point);
            System.out.println("LogAspect.methodBefore");
        }
    
        /**
         * 无论方法以何种方式结束，都会执行（类似于finally）
         * @param point
         */
        @After("execution(* learn.service.impl.*.*(..))")
        public void methodAfter(JoinPoint point) {
            System.out.println("LogAspect.methodAfter");
        }
    
    
        /**
         * 环绕执行
         * @param proceedingJoinPoint
         * @return
         * @throws Throwable
         */
        @Around(value = "execution(* learn.service.impl.*.*(..))")
        public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            handleMethod(proceedingJoinPoint);
            //调用核心逻辑
            System.out.println("-----Start of aroundAdvice()-----");
            Object retVal = proceedingJoinPoint.proceed();
            System.out.println("-----End of aroundAdvice()------");
            return retVal;
        }
    
    
        /**
         * Throw后执行
         * @param point
         * @param ex
         */
        @AfterThrowing(pointcut = "execution(* learn.service.impl.*.*(..))", throwing = "ex")
        public void doAfterThrowingTask(JoinPoint point,Exception ex) {
            System.out.println(ex.toString());
        }
    
    
        /**
         * 运行方法后执行
         * @param joinPoint
         * @param retVal
         */
        @AfterReturning(value = "execution(* learn.service.impl.*.*(..))",returning="retVal")
        public void doAfterReturning(JoinPoint joinPoint,Object retVal){
            System.out.println("LogAspect.doAfterReturning:"+retVal);
        }
    
    
        /**
         * 获取方法名称
         *
         * @param joinPoint
         * @return
         * @throws Exception
         */
        public static String handleMethod(JoinPoint joinPoint){
            Class<?> clazz = joinPoint.getTarget().getClass();
            String name = joinPoint.getSignature().getName();
            Object[] parameterTypes = joinPoint.getArgs();
            System.out.println(name);
            for (Object parameterType : parameterTypes) {
                System.out.println("# "+parameterType);
            }
            for (Method method : clazz.getDeclaredMethods()) {
                System.out.println("* "+method.getName());
            }
            return "";
        }
    }

### XML配置 ###

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context" 
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <context:component-scan base-package="learn.service.impl"/>
          
            <aop:aspectj-autoproxy />
            <bean id="logAspect" class="learn.aspect.LogAspect"></bean>
    </beans>

### 运行测试执行类Demo1.class，得到结果 ###

hello
    # hello 你好~
    * hello
    -----Start of aroundAdvice()-----
    hello
    # hello 你好~
    * hello
    LogAspect.methodBefore
    hello 你好~
    LogAspect.methodAfter
    java.lang.ArithmeticException: / by zero
    出现异常

## 备注 ##

> 切入点表达式 execution (\* com.sample.service.impl..*.*(..))  
> 整个表达式可以分为五个部分：  
> 1、execution(): 表达式主体。  
> 2、第一个*号：表示返回类型，*号表示所有的类型。  
> 3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。  
> 4、第二个*号：表示类名，*号表示所有的类。  
> 5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。