Spring AOP底层原理

spring AOP的底层原理实现

spring的AOP是直接封装好的，那么它具体的实现原理是如何进行的呢？
众周所知，代理分为动态代理和静态代理。初始的代理模式大都是基于静态代理进行的，但是操作起来并不方便，每次都是需要重新进行编译。spring的动态代理分为有接口的和没有接口的，下面我们来分析关于有接口的代理模式——jdk动态代理。

1. 创建一个接口，添加方法。

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);


}

2.添加接口的实现类，重写方法。

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;
    }
}

3.重点，通过动态代理，在add和update方法里面增加新的功能。进行增强的功能。使用Proxy类创建对象，作为代理对象。

public class JdkProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};
//        创建接口实现类代理对象
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao =(UserDao) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
       String res = dao.update("001");
        System.out.println(res);

    }

}
class UserDaoProxy implements InvocationHandler{
//    把创建谁的代理对象，把谁传递过来，通过有参数构造进行传递。为了更加通用 可以直接使用object，实际应该传递的是
//    Impl userdao
    private Object obj;
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }
//增强的逻辑
    @Override
    /**对象一创建，调用invoke*/
    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("方法之后执行");
        return res;
    }
}

看一下结果。

术语

1. 联结点，Jointpoint，典型的联结点有很多，比如调用一个方法，方法执行这个过程本身等等。这些方法称为联结点。用来在定义程序的哪里通过AOP加入新的逻辑。比如add和update。
2. 切入点,Pointcut，一个典型的联结点就是方法的调用，典型的切入点是对某一个类所有方法调用的集合。通俗就是真正被增强的方法，切入点的集合就是联结点的子集。比如update。
3. 通知，Advice,或者增强，真正被执行的部分，或者是在一个特定的联结点处运行的代码称为通知。通知有很多种类型。5种，前置，后置，环绕，异常，最终。很好理解，基于字面意思理解。
4. 切面，Aspect,通知和切入点的组合。切面定义了一段程序中应该包括的逻辑以及何时执行的逻辑。