【Spring】AOP底层原理(动态代理)-》 AOP概念及术语 -》 AOP实现

阳光穿透心脏的1/2处 2023-10-07 23:06 52阅读 0赞

![在这里插入图片描述][8d8e0d8a542946af858489a536162608.gif_pic_center]

> 个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~  
> 个人主页：[.29.的博客][.29.]  
> 学习社区：[进去逛一逛~][Link 1]

[![在这里插入图片描述][fd543646dabc428c98339174c5fbe018.png_pic_center]][fd543646dabc428c98339174c5fbe018.png_pic_center 1]

#### AOP - 面向切面编程 ####

*  一、简述AOP
 *  二、AOP底层原理
 *  三、实现动态代理（案例）
 *  四、AOP术语
 *  五、AOP的注解方式实现

## 一、简述AOP ##

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

AOP —— 面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的作用：

*  简化代码：把方法中固定位置的重复的代码**抽取**出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。
 *  代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被**套用**了切面逻辑的方法就被切面给增强了。

## 二、AOP底层原理 ##

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

AOP面向切面编程，在底层使用**动态代理**实现，其中分为两种情况：

*  **有接口**时，使用JDK动态代理
 *  **无接口**时，使用CGLIB动态代理

`JDK动态代理`：创建接口实现类代理对象，增强类的方法；  
`CGLIB动态代理`：创建子类的代理对象，增强类的方法；

## 三、实现动态代理（案例） ##

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

使用的相关Maven依赖：

<dependencies>
            
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.6.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.2.6.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>5.2.6.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-api</artifactId>
                <version>5.3.1</version>
            </dependency>
        </dependencies>

`① 声明计算器接口Calculator，包含加减乘除的抽象方法`：

/**
     * @author .29.
     * @create 2023-02-04 15:01
     */
    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);
    }

`② 创建接口实现类，实现加减乘除等方法`：

import org.springframework.stereotype.Component;
    
    /**
     * @author .29.
     * @create 2023-02-04 15:02
     */
    
    //简单功能的实现类
    @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;
        }
    }

`③ 编写被代理对象的工厂类`：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Arrays;
    
    /**
     * @author .29.
     * @create 2023-02-04 22:05
     */
    public class ProxyFactory {
        
        //目标对象
        private Object target;
    
        public ProxyFactory(Object target){
        
            this.target = target;
        }
    
        //返回代理对象
        public Object getProxy(){
        
            //动态代理返回对象
            //调用Proxy类中的newProxyInstance(),获取动态代理对象
            /*
            * newProxyInstance()中需要传入三个参数
            * ① ClassLoader：加载动态生成代理类的 类加载器
            * ② Class[] interfaces： 目标对象实现的所有接口
            * ③ InvocationHandler: 设置代理对象实现目标对象方法的过程
            * */
            ClassLoader classLoader = target.getClass().getClassLoader();
    
            Class<?>[] interfaces = target.getClass().getInterfaces();
    
            InvocationHandler invocationHandler = new InvocationHandler(){
        
                //参数一：代理对象
                //参数二：需要重写目标对象的方法
                //参数三：method方法（参数二）中的参数
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                    //方法调用前输出的日志
                    System.out.println("[动态代理][日志]"+method.getName()+",参数："+ Arrays.toString(args));
    
                    //调用目标方法
                    Object result = method.invoke(target, args);
    
                    //方法调用后输出的日志
                    System.out.println("[动态代理][日志]"+method.getName()+",结果："+ result);
                    return result;
                }
            };
            //调用Proxy类中的newProxyInstance(),获取动态代理对象
             return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
        }
    }

`④ 测试`：

/**
     * @author .29.
     * @create 2023-02-04 22:24
     */
    public class TestCalculator {
        
        public static void main(String[] args) {
        
            //创建代理对象
            ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
            //通过代理对象获取目标对象
            Calculator proxy = (Calculator) proxyFactory.getProxy();
            //调用目标对象方法
            proxy.add(1,1);
            System.out.println();
    
            proxy.div(1,1);
            System.out.println();
    
            proxy.mul(1,1);
            System.out.println();
    
            proxy.sub(1,1);
            System.out.println();
        }
    }

> ![在这里插入图片描述][27b086bf396c4c13ad8ce3368537c08e.png_pic_center]

## 四、AOP术语 ##

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

1.`横切关注点`：  
分散在每个各个模块中解决同一样的问题，如用户验证、日志管理、事务处理、数据缓存都属于横切关注点。

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

这个概念不是语法层面的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

2.`通知`：  
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

*  前置通知：使用@Before注解标识，在被代理的目标方法**前**执行
 *  返回通知：使用@AfterReturning注解标识，在被代理的目标方法**成功结束**后执行（**寿终正寝**）
 *  异常通知：使用@AfterThrowing注解标识，在被代理的目标方法**异常结束**后执行（**死于非命**）
 *  后置通知：使用@After注解标识，在被代理的目标方法**最终结束**后执行（**盖棺定论**）
 *  环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕**整个**被代理的目标方法，包括上面四种通知对应的所有位置

> 各种通知的执行顺序：
> 
>  *  Spring版本5.3.x以前：
>     
>      *  前置通知
>      *  目标操作
>      *  后置通知
>      *  返回通知或异常通知
>  *  Spring版本5.3.x以后：
>     
>      *  前置通知
>      *  目标操作
>      *  返回通知或异常通知
>      *  后置通知  
>           
>

3.`切面`：  
即：封装通知方法的类。

4.`目标`：  
即：被代理的目标对象。

5.`代理`：  
向目标对象应用通知之后创建的代理对象。

6.`连接点`：  
这也是一个纯逻辑概念，不是语法定义的。

把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。**通俗说，就是spring允许你使用通知的地方**

7.`切入点`：  
定位连接点的方式。

每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。

如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。

**Spring 的 AOP 技术可以通过切入点定位到特定的连接点。通俗说，要实际去增强的方法**

切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

## 五、AOP的注解方式实现 ##

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

**须知：**  
切入点表达式语法：  
execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))

![在这里插入图片描述][0ca3920c2244486d89fe295a83a126c5.png]

1.`导入Maven依赖`：

2.`准备被代理的 接口+实现类`：

/**
     * @author .29.
     * @create 2023-02-04 15:01
     */
    
    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);
    }

※ 3.`创建并配置切面类`：

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    import java.util.Arrays;
    
    /**
     * @author .29.
     * @create 2023-02-04 22:47
     */
    //切面类
    //@Aspect代表这是一个切面类
    //@Component代表将此类交给Spring处理，能够放入IOC容器中去
    @Aspect
    @Component
    public class LogAspect {
        
        //设置切入点 和 通知类型
        //切入点表达式：execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))
    
        //重用切入点表达式：使用@Pointcut注解，设置需要重复使用的切入点表达式
        @Pointcut(value = "execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
        public void pointCut(){
        }
        //之后，在使用通知时，将切入点表达式用 方法名 替换，即pointCut()（同一个切面）
        //若在不同的切面，需要加上重用切入点表达式方法的全类名：com.haojin.spring.aop.annoaop.LogAspect.pointCut()（不同的切面）
    
        //通知类型：
        // @Before("切入点表达式配置切入点") 前置
        @Before(value = "pointCut()")   //重用切入点表达式，使用方法名替换
        public void beforeMethod(JoinPoint joinPoint){
        
            String name = joinPoint.getSignature().getName();//获取增强方法的名字
            Object[] args = joinPoint.getArgs();             //获取增强方法的参数数组
            System.out.println("Logger-->前置通知，增强方法为："+name+",参数："+ Arrays.toString(args));
        }
    
        // @AfterReturning() 返回
        //返回通知 可以获取到返回值，在切入表达式中增加返回值属性:returning = ""
        @AfterReturning(value = "pointCut()",returning = "result")
        //增强方法中需要添加 返回值参数result，参数名与切入点表达式保持一致（result）
        public void afterReturningMethod(JoinPoint joinPoint,Object result){
        //可以存在参数JoinPoint，以此来获取信息
            String name = joinPoint.getSignature().getName();//获取增强方法的名字
            System.out.println("Logger-->返回通知，增强方法为："+name+"，返回结果："+result);
    
        }
    
        // @AfterThrowing() 异常
        //目标方法出现异常时，此通知会执行，在切入表达式中增加属性：
        @AfterThrowing(value = "pointCut()",throwing = "exception")
        //增加 Throwable类型参数，参数名必须与切入点表达式保持一致（exception）
        public void aAfterThrowingMethod(JoinPoint joinPoint,Throwable exception){
        //可以存在参数JoinPoint，以此来获取信息
            String name = joinPoint.getSignature().getName();//获取增强方法的名字
            System.out.println("Logger-->异常通知，增强方法为："+name+"异常信息："+exception);
    
        }
    
        // @After() 后置
        @After(value = "execution(* com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
        public void afterMethod(JoinPoint joinPoint){
        //可以存在参数JoinPoint，以此来获取信息
            String name = joinPoint.getSignature().getName();//获取增强方法的名字
            System.out.println("Logger-->后置通知，增强方法为："+name);
    
        }
        // @Around() 环绕通知，可以通过try-catch-finally,使得增强方法在所有阶段执行（增强方法可设置返回值）
        @Around("execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
        //可设置 ProceedingJoinPoint属性参数,以此调用增强方法(JoinPoint的子接口，JoinPoint没有调用目标方法的功能)
        public Object aroundMethod(ProceedingJoinPoint joinPoint){
        
            String name = joinPoint.getSignature().getName();//通过ProceedingJoinPoint参数获取增强方法名
            Object[] args = joinPoint.getArgs();             //获取增强方法参数数组
            String argStr = Arrays.toString(args);           //参数数组转字符串
            Object result = null;
    
            try{
        
                System.out.println("环绕通知 == 增强方法执行前执行");
    
                //通过ProceedingJoinPoint类型参数调用增强方法
                result = joinPoint.proceed();
    
                System.out.println("环绕通知 = 增强方法返回值之后执行");
    
            }catch(Throwable throwable){
        //捕捉Throwable类型异常
                throwable.printStackTrace();
                System.out.println("环绕通知 = 增强方法异常时执行");
    
            }finally {
        
                System.out.println("环绕方法 = 增强方法执行完毕执行");
    
            }
    
            return result;
        }

> **切面优先级：**
> 
> 切面的优先级控制切面的 内外嵌套 顺序  
> 外层切面：优先级高  
> 内层切面：优先级低
> 
> …  
> 可使用@Order()注解设置优先级  
> @Order(较小的数) 优先级较高  
> @Order(较大的数) 优先级较低

4.`配置Spring配置文件（这里命名为 bean.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.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.haojin.spring.aop.annoaop"></context:component-scan>
    
        
        <aop:aspectj-autoproxy />
    
    </beans>

5.`测试`：

import com.haojin.spring.aop.annoaop.Calculator;
    import org.junit.jupiter.api.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * @author .29.
     * @create 2023-02-06 9:34
     */
    public class TestAop {
        
        //以实现类中的加法功能为例
        @Test
        public void testAdd(){
        
            ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
            Calculator bean = context.getBean(Calculator.class);
            bean.add(3,13);
        }
    }

[![在这里插入图片描述][20a7f1b58dfb4660b75d7f021c157d57.png_pic_center]][20a7f1b58dfb4660b75d7f021c157d57.png_pic_center 1]

[8d8e0d8a542946af858489a536162608.gif_pic_center]: https://img-blog.csdnimg.cn/8d8e0d8a542946af858489a536162608.gif#pic_center
[.29.]: https://blog.csdn.net/ebb29bbe?spm=1018.2226.3001.5343
[Link 1]: https://bbs.csdn.net/forums/185241f773fb401b8ca7994dc3d02333?joinKey=cyru4ex9o7wq-mz6v1koj5x-1-add3ae8dc3827dbbd4360c79af92bbbe
[fd543646dabc428c98339174c5fbe018.png_pic_center]: https://img-blog.csdnimg.cn/fd543646dabc428c98339174c5fbe018.png#pic_center
[fd543646dabc428c98339174c5fbe018.png_pic_center 1]: https://blog.csdn.net/ebb29bbe/category_12171996.html?spm=1001.2014.3001.5482
[27b086bf396c4c13ad8ce3368537c08e.png_pic_center]: https://img-blog.csdnimg.cn/27b086bf396c4c13ad8ce3368537c08e.png#pic_center
[0ca3920c2244486d89fe295a83a126c5.png]: https://img-blog.csdnimg.cn/0ca3920c2244486d89fe295a83a126c5.png
[20a7f1b58dfb4660b75d7f021c157d57.png_pic_center]: https://img-blog.csdnimg.cn/20a7f1b58dfb4660b75d7f021c157d57.png#pic_center
[20a7f1b58dfb4660b75d7f021c157d57.png_pic_center 1]: https://blog.csdn.net/ebb29bbe?type=blog