Spring-AOP底层原理

1、什么是 AOP

（ 1 ）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （ 2 ）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 （ 3 ）使用登录例子说明 AOP

2、AOP（底层原理）

1、AOP 底层使用动态代理

（ 1 ）有两种情况动态代理  

第一种 有接口情况，使用 JDK 动态代理

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

• 如上图，比如说想在实现类UserDaoImp的login()的登录功能中再添加一个新的功能，使用AOP的JDK动态代理，创建一个UserDao接口的实现类代理对象，在代理对象中完成功能的添加，就可以不需要改动源码UserDaoImp的login()

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

public interface Dao {
    public int add(int a,int b);
    public String add(String id);
}

class DaoImp implements Dao{
    @Override
    public int add(int a, int b) {
        System.out.println("原始方法");
        return a+b;
    }

    @Override
    public String add(String id) {
        return id;
    }
}

           

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxy {
    public static void main(String[] args){

        Class[] interfaces = {Dao.class};//所有类和接口都是Class类的对象

        DaoImp daoImp = new DaoImp();

        //创建接口实现类代理对象
        Dao dao = (Dao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new DaoProxy(daoImp));
        int res = dao.add(1,2);
        System.out.println(res);
    }
}

class DaoProxy implements InvocationHandler{


    //1、创建谁的代理对象，就把谁传进来
    DaoImp daoImp;
    //有参数构造传递
    public DaoProxy(DaoImp daoImp){
        this.daoImp = daoImp;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //增强的逻辑
        //原始方法执行前
        System.out.println("原始方法执行前");
        //原始方法
        Object res = method.invoke(daoImp,args);
        //原始方法执行后
        System.out.println("原始方法执行后");
        return res;
    }
}
           

第二种 没有接口情况，使用 CGLIB 动态代理

• 创建子类的代理对象，增强类的方法
• 比如说想在类User的add()的功能中再添加一个新的功能

  

• 方法一（原始方法）：创建其子类，重写add（）方法 

  

• 方法二：