基于注解实现AOP

骑猪看日落 2024-03-24 12:49 66阅读 0赞

动态代理分为JDK动态代理和cglib动态代理，当目标类有接口的情况使用JDK动态代理和cglib动态代理，没有接口时只能使用cglib动态代理。

JDK动态代理动态生成的代理类会在com.sun.proxy包下，类名为$proxy1，和目标类实现相同的接口，cglib动态代理动态生成的代理类会和目标在在相同的包下，会继承目标类。

动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求**代理对象和目标对象实现同样的接口**（兄弟两个拜把子模式）。

cglib：通过**继承被代理的目标类**（认干爹模式）实现代理，所以不需要目标类实现接口。

AspectJ：是AOP思想的一种实现。本质上是静态代理，**将代理逻辑“织入”被代理的目标类编译得到的字节码文件**，所以最终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解。

--------------------

#### 准备工作 ####

被代理的目标资源接口：

package com.cj.spring6.annoaop;
    
    public interface Calculator {
    
        int add(int i, int j);
    
        int sub(int i, int j);
    
        int mul(int i, int j);
    
        int div(int i, int j);
    }

package com.cj.spring6.annoaop;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class CalculatorImpl implements Calculator {
        @Override
        public int add(int i, int j) {
    
            int result = i + j;
    
            System.out.println("方法内部 result = " + result);
    
            return result;
        }
    
        @Override
        public int sub(int i, int j) {
    
            int result = i - j;
    
            System.out.println("方法内部 result = " + result);
    
            return result;
        }
    
        @Override
        public int mul(int i, int j) {
    
            int result = i * j;
    
            System.out.println("方法内部 result = " + result);
    
            return result;
        }
    
        @Override
        public int div(int i, int j) {
    
            int result = i / j;
    
            System.out.println("方法内部 result = " + result);
    
            return result;
        }
    
    }

**添加依赖：**

<dependencies>
        
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.2</version>
        </dependency>
    
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>6.0.2</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>6.0.2</version>
        </dependency>
    
        
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
        </dependency>
    
        
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.19.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j2-impl</artifactId>
            <version>2.19.0</version>
        </dependency>
    </dependencies>

创建切面类并配置：

package com.cj.spring6.annoaop;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    import java.util.Arrays;
    
    /**
     * 切面类
     */
    @Aspect     // @Aspect表示这个类是一个切面类
    @Component  // @Component注解保证这个切面类能够放入IOC容器
    public class LogAspect {
    
        /**
         * 前置通知：使用@Before注解标识，在被代理的目标方法**前**执行
         * 返回通知：使用@AfterReturning注解标识，在被代理的目标方法**成功结束**后执行（**寿终正寝**）
         * 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法**异常结束**后执行（**死于非命**）
         * 后置通知：使用@After注解标识，在被代理的目标方法**最终结束**后执行（**盖棺定论**）
         * 环绕通知：使用@Around注解标识，使用try...catch...finally结构围绕**整个**被代理的目标方法，包括上面四种通知对应的所有位置
         */
    
    
        /**
         * 后置
         *
         * @param joinPoint
         */
        //  @After(value = "execution(public int com.cj.spring6.annoaop.CalculatorImpl.*(..)))")
        @After(value = "pointCut()")
        public void afterMethod(JoinPoint joinPoint) {
            String methodName = joinPoint.getSignature().getName();
            System.out.println("Logger-->后置通知，方法名称：" + methodName);
        }
    
        // 返回 @AfterReturning
        @AfterReturning(value = "execution(* com.cj.spring6.annoaop.CalculatorImpl.*(..))", returning = "result")
        public void afterReturningMethod(JoinPoint joinPoint, Object result) {
            String methodName = joinPoint.getSignature().getName();
            System.out.println("Logger-->返回通知，方法名称：" + methodName + "，返回结果：" + result);
        }
    
        // 异常 @AfterThrowing 获取到目标方法异常信息
        // 目标方法出现异常，这个通知执行
        @AfterThrowing(value = "execution(* com.cj.spring6.annoaop.CalculatorImpl.*(..))", throwing = "ex")
        public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex) {
            String methodName = joinPoint.getSignature().getName();
            System.out.println("Logger-->异常通知，方法名称：" + methodName + "，异常信息：" + ex);
        }
    
        // 环绕 @Around()
        @Around("execution(* com.cj.spring6.annoaop.CalculatorImpl.*(..))")
        public Object aroundMethod(ProceedingJoinPoint joinPoint) {
            String methodName = joinPoint.getSignature().getName();
            Object[] args = joinPoint.getArgs();
            String argString = Arrays.toString(args);
            Object result = null;
            try {
                System.out.println("环绕通知==目标方法之前执行");
    
                // 调用目标方法
                result = joinPoint.proceed();
    
                System.out.println("环绕通知==目标方法返回值之后");
            } catch (Throwable throwable) {
                throwable.printStackTrace();
                System.out.println("环绕通知==目标方法出现异常执行");
            } finally {
                System.out.println("环绕通知==目标方法执行完毕执行");
            }
            return result;
        }
    
        // 重用切入点表达式
        @Pointcut(value = "execution(* com.cj.spring6.annoaop.CalculatorImpl.*(..))")
        public void pointCut() {
        }
    
        /**
         * 前置
         *
         * @param joinPoint
         */
        // 切入点表达式: execution(访问修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))
        @Before(value = "execution(public int com.cj.spring6.annoaop.CalculatorImpl.*(..)))")
        public void beforeMethod(JoinPoint joinPoint) {
            String methodName = joinPoint.getSignature().getName();
            Object[] args = joinPoint.getArgs();
            System.out.println("Logger-->前置通知，方法名称：" + methodName + "，参数：" + Arrays.toString(args));
        }
    
    
    }

**ps：**切面的优先级

相同目标方法上同时存在多个切面时，切面的优先级控制切面的**内外嵌套**顺序。

*  优先级高的切面：外面
 *  优先级低的切面：里面

使用@Order注解可以控制切面的优先级：

*  @Order(较小的数)：优先级高
 *  @Order(较大的数)：优先级低

在Spring的配置文件中配置：

<?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.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <context:component-scan base-package="com.atguigu.aop.annotation"></context:component-scan>
    
        <aop:aspectj-autoproxy />
    </beans>

最后测试：

package com.cj.spring6.annoaop;
    
    import org.junit.jupiter.api.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class testLogAspect {
    
        @Test
        public void testAdd() {
            ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
            Calculator calculator = context.getBean(Calculator.class);
            calculator.add(2, 3);
        }
    
    }