1 概述

        在Java的世界中，实现AOP的主流方式是采用动态代理机制，这点对于Spring AOP也一样。代理机制的主要目的就是为其他对象提供一种dialing以控制对当前对象的访问，用于消除或缓解直接访问对象带来的问题。通过这种手段，一个对象就代表另一个对象的部分功能，我们创建包含当前对象的对象，以便向外界提供功能接口。本篇将关注目前主流的动态代理实现技术，并分析Spring AOP中的代理实现方式。

        在Spring中，采用的代理机制有两种，即JDK动态代理和CGLIB动态代理。为了介绍动态代理机制，引入一个具体的应用场景。考虑一个Account接口，它包含一个用于图片展示的open方法，代码如下：

public interface Account {void open();
}

        然后针对该接口有一个实现类RealAccount，其中的方法只用于模拟，不包括具体业务，代码如下：

public class RealAccount implements Account {private String name;public RealAccount(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic void open() {System.out.println("打开：" + name + "，账户");}
}

        现在，假设需要在执行RealAccount的open()方法的前后分别打印日志信息。接下来讨论如何分别基于JDK动态代理和CGLIB动态代理来实现这个目标。

2 JDK动态代理

        在JDK自带的动态代理中存在一个InvocationHandler接口，首先要做的就是提供一个该接口的实现类，代码如下：

public class AccountHandler implements InvocationHandler {private Object obj;public AccountHandler(Object obj) {super();this.obj = obj;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object result = null;doBefore();result = method.invoke(obj,args);doAfter();return result;}private void doAfter() {System.out.println("开户后");}private void doBefore() {System.out.println("开户前");}}

        InvocationHandler接口中包含一个invoke()方法，必须实现这个方法。在这个方法中，通常需要调用method.invoke()方法执行原有对象的代码逻辑，然后可以在该方法前后添加相应的代理实现。在上述代码中，只是简答的打印了日志。然后编写测试类来验证执行结果，测试类代码如下：

public class Test {public static void main(String[] args) {Account account = new RealAccount("zhangsan");AccountHandler handler = new AccountHandler(account);Account proxy = (Account) Proxy.newProxyInstance(account.getClass().getClassLoader(),account.getClass().getInterfaces(),handler);proxy.open();}
}

运行结果如下：

        这里的Proxy.newProxyInstance()方法的作用就是生成代理类。当该方法被调用时，RealAccount类的实例被传入。然后当代理类的open()方法被调用时，AccountHandler中invoke方法就会被触发，从而实现代理机制。这里的类层次结构图如下：

        咨询分析上述代码结构，可以发现其遵循“设计并实现业务接口——实现Handler——创建代理类”这个流程，然后在Handler中构建具体的代理逻辑。上述流程也是代表了最基本的代理机制实现流程。联想一下，很多基于AOP机制的拦截器底层实际上就是类似的原理。

3 CGLIB动态代理

        CGLIB是一个Java字节码生成库，提供了易用的API对Java字节码进行创建和修改。现在尝试拥CGLIB来代理前面的RealAccount类，代码清单如下：

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class AccountCglibProxy implements MethodInterceptor {private Enhancer enhancer = new Enhancer();public Object getProxy(Class<?> clazz){enhancer.setSuperclass(clazz);enhancer.setCallback(this);return enhancer.create();}@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("之前");methodProxy.invokeSuper(o,objects);System.out.println("之后");return o;}
}

         上述代码中的Enhancer类是CGLIB中最常用的一个类，类似于前面介绍的JDK动态代理中的Proxy类。和Proxy只能代理接口不同，Enhancer既能够代理类接口，也能够代理不同类，但不能拦截final类和方法。在这里，我们实现了MethoInterceptor中的intercept()方法以提供代理逻辑。AccountCglibProxy类的使用方法也比较简单，测试代码如下：

public class CglibProxyTest {public static void main(String[] args) {AccountCglibProxy proxy = new AccountCglibProxy();RealAccount account = (RealAccount) proxy.getProxy(RealAccount.class);account.open();}
}

        作为对比，下表展示了JDK动态代理和CGLIB动态代理之间的区别。

4 ProxyFactoryBean

        JDK自带的动态代理以及基于CGLIB的动态代理在Spring框架中都得到了应用，最典型的应用场景就是实现AOP。Spring专门提供了一个ProxyFactoryBean类用于手动创建对象代理，并将创建的代理对象作为目标对象的AOP代理。

        ProxyFactoryBean提供了一组配置属性用于指定代理的执行行为，比较常见的包括proxyTargetClass和exposeProxy。如果proxyTargetClass属性为true，则仅使用CGLIB创建代理。如果该属性未设置，那么有两种情况：如果目标实现了接口，则将使用JDK创建代理；反之，将使用CGLIB创建代理。而exposeProxy属性用于设置是否将当前代理暴露给ThreadLocal。如果该属性为true，那么开发人员可以使用AopContext.currentProxy()方法来获取代理对象。

        接下来，将演示如何使用ProxyFactoryBean来创建和管理对象。继续使用前面的场景，现在为MethodBeforeAdvice接口提供了一个实现类。显然从命名上看，这个实现类是方法执行前通知的，代码清单如下：

import com.sun.istack.internal.logging.Logger;
import org.springframework.aop.MethodBeforeAdvice;import java.lang.reflect.Method;public class AccountTransactionInterceptor implements MethodBeforeAdvice {private static final Logger LOGGER = Logger.getLogger(AccountTransactionInterceptor.class);@Overridepublic void before(Method method, Object[] objects, Object o) throws Throwable {LOGGER.info("账户交易被拦截");}
}

           接着通过Java代码创建一个通知，实现方式如下：

import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.context.annotation.Bean;public class MyAdvisor {@Beanpublic Advisor accountServiceAdvisor(){AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();pointcut.setExpression("execution(*com.jay.aop.service.AccountService.doAccountTransaction(..))");return new DefaultPointcutAdvisor(pointcut,new AccountTransactionInterceptor());}
}

        最后，创建一个ProxyFactoryBean实例，并设置相关属性，代码如下：

@Beanpublic ProxyFactoryBean accountService(){ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();proxyFactoryBean.setTarget(new AccountServiceImpl());proxyFactoryBean.addAdvisor(accountServiceAdvisor());proxyFactoryBean.setExposeProxy(true);return proxyFactoryBean;}

        注意，这里设置目标类为AccountService接口的实现类AccountServiceImpl，并把exposeProxy属性设置为true。这样，在AccountServiceImpl中就可以使用Spring AOP提供的AopContext.currentProxy方法来获取这个代理对象，实例代码如下：

public class AccountServiceImpl implements AccountService {private static  final Logger LOGGER = Logger.getLogger(AccountServiceImpl.class);@Overridepublic boolean doAccountTransaction(Account source, Account dest, int amount) throws MinimumAccountException {((AccountService)(AopContext.currentProxy())).doAccountTransaction(source,dest,amount);return true;}
}