本文已参与「新人创作礼」活动，一起开启掘金创作之路。

Spring5-Aop框架学习

在前面文章的学习中已经有一些导包和创建相关工程的说明可以参考这篇Spring的基础学习篇

1.什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2.AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ....
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

前置通知 -- 方法前
后置通知 -- 方法后
环绕通知 -- 方法前后
异常抛出通知 -- 方法抛出异常
引介通知 -- 类中最终的通知，finally 即在Aop不改变原有代码的情况下，去增加新的功能

3.AOP底层

简单描述：不通过修改源码方式，在主干功能里面添加新功能

1.AOP底层使用动态代理

1.有接口，使用JDK动态代理

创建接口实现代理对象，增强类的方法

没有接口使用CGLIB动态代理创建子类的代理对象，增强类的方法

2.AOP（JDK动态代理）

1.使用JDK动态代理对象，使用 Proxy类里面的方法创建代理对象

调用newProxyInstance方法

方法的三个参数

loader -- 类加载器
类interface --增强方法所在类这个类实现的接口，这个支持多个接口
InvocationHandler实现这个接口，创建代理对象，写增强的方法

2.JDK动态代理代码实现创建接口

    package com.Spring.AOp;
    
    public interface UserDao {
        public int add(int a,int b);
        public String update(String id);
    }

接口实现方法

    package com.Spring.AOp;
    
    public class UserDaoImpl implements UserDao {
        @Override
        public int add(int a, int b) {
            System.out.println("add 方法执行");
            return a+b;
        }
    
        @Override
        public String update(String id) {
            System.out.println("update方法执行");
            return id;
        }
    }

创建Proxy类实现接口代理对象

    package com.Spring.AOp;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Arrays;
    
    public class JDKProxy {
        public static void main(String[] args) {
            Class[] interfaces = {UserDao.class};
    //            Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), new InvocationHandler() {
    //                @Override
    //                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //                    return null;
    //
    //            });
    //
    //                    }
            UserDaoImpl userDao = new UserDaoImpl();
            UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces, new UserDaoProxy(userDao));
            int result = dao.add(1,2);
            System.out.println("result"+result);
        }
                            //创建接口实现类代理对象
    }
    //代理对象代码
     class UserDaoProxy implements InvocationHandler {
        //将创建的代理对象，传入
        private Object obj;
        public UserDaoProxy(Object obj){
            this.obj = obj;
        }
        //增强的逻辑
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //方法之前执行
             System.out.println("方法之前执行..."+method.getName()+"传递的参数"+ Arrays.toString(args));
            //被增强的方法执行
             Object res =  method.invoke(obj,args);
            //方法之后执行
             System.out.println("方法之后执行.."+obj);
            return res;
         }
     }