Spring AOP底层实现原理

Spring AOP的底层实现为动态代理。其中动态代理有两种代理机制：

• JDK动态代理

• cglib动态代理

一. JDK动态代理

1.概念介绍
在JDK 1.3以后提供了动态代理的技术，允许开发者在运行期创建接口的代理实例，JDK的动态代理主要涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。其中InvocationHandler是一个接口，可以通过实现该接口定义横切逻辑，在并通过反射机制调用目标类的代码，动态将横切逻辑和业务逻辑编织在一起。
2.代码实现
此处实现一个自定义的AOP

抽象出一个接口　　Logger，这个接口里就只有两个方法：一个是在被代理对象要执行方法之前执行的方法,我们取名为start，第二个方法就是在被代理对象执行方法之后执行的方法,我们取名为end
　Logger的接口：

public interface ILogger {
     void start();
     void end();
 }

Logger的接口实现：

public class DLogger implements ILogger{
    @Override
    public void start() {
        System.out.println(new Date()+  " say hello start...");
    }
    @Override
    public void end() {
        System.out.println(new Date() + " say hello end");
    }
}

　动态代理类：

public class DynaProxyHello1 implements InvocationHandler{
    //调用对象
    private Object proxy;
    //目标对象
    private Object target;

    public Object bind(Object target,Object proxy){
        this.target=target;
        this.proxy=proxy;
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        //反射得到操作者的实例
        Class clazz = this.proxy.getClass();
        //反射得到操作者的Start方法
        Method start = clazz.getDeclaredMethod("start");
        //反射执行start方法
        start.invoke(this.proxy);
        //执行要处理对象的原本方法
        method.invoke(this.target, args);
        //反射得到操作者的end方法
        Method end = clazz.getDeclaredMethod("end");
        //反射执行end方法
        end.invoke(this.proxy);
        return result;
    }

}

　测试代码：

public class DynaTest1 {
    public static void main(String[] args) {
        IHello hello = (IHello) new DynaProxyHello1().bind(new Hello(),new DLogger());//如果我们需要日志功能，则使用代理类
        //IHello hello = new Hello();//如果我们不需要日志功能则使用目标类
        hello.sayHello("明天");
    }
}

通过上面例子，可以发现通过动态代理和反射技术，已经基本实现了AOP的功能，如果我们只需要在方法执行前打印日志，则可以不实现end()方法，这样就可以控制打印的时机了。如果我们想让指定的方法打印日志，我们只需要在invoke（）方法中加一个对method名字的判断，method的名字可以写在xml文件中，这样我们就可以实现以配置文件进行解耦了，这样我们就实现了一个简单的spring aop框架

二.CGLIB动态代理

1.概念解释
使用JDK创建代理有一个限制，即它只能为接口创建代理，这一点我们从Proxy的接口方法newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)就看得很清楚，第三个入参interfaces就是为代理实例指定的实现接口。所以CGLib作为一个替代者，填补了这个空缺。

CGLib采用非常底层的字节码技术，可以为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，并在拦截方法相应地织入横切逻辑。下面，我们采用CGLib技术，编写一个可以为任何类创建织入性能监视横切逻辑的代理对象的代理器（需要CGLIB的类包，可以从spring的关联类库lib/ cglib中获取类包）
2. Cglib动态代理增强一个类中的方法
定义一个目标类CustomerDao

public class MyCglibProxy implements MethodInterceptor{

    private CustomerDao customerDao;

    public MyCglibProxy(CustomerDao customerDao){
        this.customerDao = customerDao;
    }

    // 生成代理的方法:
    public CustomerDao createProxy(){
        // 创建Cglib的核心类:
        Enhancer enhancer = new Enhancer();
        // 设置父类:
        enhancer.setSuperclass(CustomerDao.class);
        // 设置回调:
        enhancer.setCallback(this);
        // 生成代理：
        CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
        return customerDaoProxy;
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        if("delete".equals(method.getName())){
            Object obj = methodProxy.invokeSuper(proxy, args);
            System.out.println("日志记录================");
            return obj;
        }

        return methodProxy.invokeSuper(proxy, args);
    }
}

通过上述方法即可完成对目标对象的方法执行，并对其进行增强