aop的底层实现

AOP底层使用的是动态代理

（1）动态代理分为两种情况
有接口，使用JDK动态代理
没有接口，使用CGLIB动态代理

JDK动态代理 （创建接口实现类的代理对象）

1、怎么实现？
通过使用java提供的Proxy类中的方法创建代理对象
调用newProxyInstance方法
2、newProxyInstance方法
三个参数：（1）类加载器；
（2）增强方法所在的类，这个类实现的接口，支持多个接口
（3）实现InvocationHandler，创建代理对象，写增强方法

3、实现过程演示
（1）创建接口，定义方法

public interface UserDao {
   
    public int add(int a,int b);
}

（2）创建接口类的实现类

public class UserDaoImp implements UserDao {
   
    /**
     * 实现UserDao接口中的add方法
     * @param a
     * @param b
     * @return
     */
    public int add (int a, int b) {
   
        return a+b;
    }
}

（3）具体实现

/**
 * JDK动态代理
 */
public class JDKProxy {
   
    public static void main (String[] args) {
   
        /**
         * interfaces 是增强方法所在的类组成的数组
         */
        Class[] interfaces={
   UserDao.class};

//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
   
//            public Object invoke (Object proxy, Method method, Object[] args) throws Throwable {
   
//                return null;
//            }
//        }); 通过匿名内部类创建InvocationHandler对象
        /**
         * 获取代理对象
         * JDKProxy.class.getClassLoader() 类加载器
         * interfaces 增强方法所在的类组成的数组
         * new UserDaoProxy(new UserDaoImp()) 创建代理对象
         */
        UserDao  userDao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(new UserDaoImp()));
        userDao.add(2,6);
    }
}

/**
 * 创建代理对象
 * 通过实现InvocationHandler接口中的 invoke方法
 */
class UserDaoProxy implements InvocationHandler{
   

    /**
     * 将需要增强的对象 传递进行
     */
    private Object object;

    /**
     * 通过有参数构造传递 需要增强的对象
     * @param object
     */
    UserDaoProxy (Object object) {
   
        this.object = object;
    }

    /**
     * invoke方法中实现增强的逻辑
     * @param proxy     增强的对象
     * @param method    增强的方法
     * @param args      增强方法的参数列表
     * @return
     * @throws Throwable
     */
    public Object invoke (Object proxy, Method method, Object[