AOP是什么？ AOP底层原理、AOP的术语

• 1. AOP是什么？
• 2. AOP底层原理
• • 2.1 AOP底层使用动态代理
  • 2.2 JDK动态代理代码演示
• 3. AOP术语

面向切面编程，可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率。

通俗来说：不通过修改源代码的方式，在主干功能里面添加新功能。

1. 有接口的情况，使用JDK中的动态代理：创建接口实现类代理对象，使用JDK动态代理；
2. 没有接口的情况，使用CGLIB的动态代理；
   

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

newProxyInstance方法：

• 第一个参数：类加载器
• 第二个参数：增强方法所在的类，这个类实现的接口，支持多个接口
• 第三个参数：实现这个接口InvocationHandler，创建代理对象，写增强的方法。

2. JDK动态代理代码

//创建接口
package com.proxy.demo;

public interface UserDao {

    public int add(int a, int b);

    public String update(String id);
}

//创建实现子类
package com.proxy.demo;

public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

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

//使用Proxy类创建接口代理对象
package com.proxy.demo;

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) {
        UserDaoImpl userDao = new UserDaoImpl();
        //创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add = dao.add(1, 2);
        System.out.println(add);
    }
}

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 result = method.invoke(obj, args);
        System.out.println("执行之后：" + obj);
        return result;
    }
}

1. 连接点
2. 切入点
3. 通知（增强）
4. 切面
   

• 前置通知：在切入点之前执行
• 后置通知：在切入点之后执行
• 环绕通知：在切入点前后都执行
• 异常通知：在发生异常时执行
• 最终通知：跟finnally类似，无论如何都执行