1 订单服务实例

假设有这样的一个订单服务，它提供新增订单的方法，我们需要对这个方法的性能做监控。

OrderService：

public interface OrderService {

    void add();
}

OrderServiceImpl：

public class OrderServiceImpl implements OrderService {

    /**
     * 新增
     */
    public void add() {
        PerformanceMonitor.begin("net.deniro.spring4.aop.add");//开启监视

        System.out.println("模拟新增订单");
        try {
            Thread.currentThread().sleep(50);
        } catch (InterruptedException e) {
            throw new RuntimeException();
        }
        PerformanceMonitor.end();//结束监视

    }
}

PerformanceMonitor（性能监控器）：

public class PerformanceMonitor {

    //通过 ThreadLocal，保存与调用线程相关的性能监视信息
    private static ThreadLocal<PerformanceRecord> record=new
            ThreadLocal<PerformanceRecord>();

    /**
     * 开启监视
     * @param method 需要监视的方法
     */
    public static void begin(String method) {
        System.out.println("开启监视...");
        record.set(new PerformanceRecord(method));
    }

    /**
     * 结束监视
     */
    public static void end() {
        System.out.println("结束监视...");
        record.get().print();

    }
}

ThreadLocal 可以将非线程安全的类改造为线程安全的类。

PerformanceRecord（性能记录）：

public class PerformanceRecord {

    private final String methodName;//方法名称
    private final long begin;//开始时间

    public PerformanceRecord(String method) {
        this.methodName = method;
        this.begin = System.currentTimeMillis();
    }

    /**
     * 打印性能信息
     */
    public void print() {
        long end = System.currentTimeMillis();
        long elapse = end - begin;
        System.out.println(methodName + " 耗费时间：" + elapse + " 毫秒");
    }
}

输出结果：

开启监视…
模拟新增订单
结束监视…
net.deniro.spring4.aop.add 耗费时间：50 毫秒

虽然方法添加了性能监视功能，但这些性能监视代码侵入了业务逻辑。我们可以通过 JDK 与 CGLib 动态代理技术把这些具有横切性质的代码动态织入目标方法。

2 JDK 动态代理

Java1.3 以后， JAVA 实现了动态代理技术，允许开发者在运行期创建接口的代理实例。

JDK 的动态代理主要涉及 java.lang.reflect 包中的两个类： Proxy 和 InvocationHandler。

InvocationHandler 是接口，可以通过实现该接口来定义横切逻辑，并通过反射机制调用目标类的代码，动态地将横切逻辑和业务逻辑编织在一起。
Proxy 利用 InvocationHandler 动态创建出一个实现某一接口的实例，来生成目标类的代理对象。

在 OrderServiceImpl 中，新建一个只包含业务逻辑的方法 addByJDKProxy：

/**
 * 新增（JDK 代理）
 */
public void addByJDKProxy() {
    addOrder();
}

/**
 * 新增订单
 */
private void addOrder() {
    System.out.println("模拟新增订单");
    try {
        Thread.currentThread().sleep(50);
    } catch (InterruptedException e) {
        throw new RuntimeException();
    }
}

接着创建动态代理类 PerformanceHandler：

public class PerformanceHandler implements InvocationHandler {

    private final Object target;//目标类

    public PerformanceHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName());
        Object obj=method.invoke(target,args);//调用业务类的目标方法
        PerformanceMonitor.end();
        return obj;
    }
}

InvocationHandler 接口只定义了一个方法：public Object invoke(Object proxy, Method method, Object[] args)，各参数说明如下：

参数	说明
proxy	最终生成的代理实例，很少用到。
method	被代理目标实例的某个具体方法，通过它可以发起目标实例方法的反射调用。
args	被代理实例某个方法的入参，在方法反射调用时使用。

在构造函数中，我们通过 target 参数传入希望被代理的目标对象。

单元测试：

//编织目标业务类与横切代码
PerformanceHandler handler=new PerformanceHandler(orderService);

//创建代理实例
OrderService proxy=(OrderService) Proxy.newProxyInstance(orderService.getClass()
        .getClassLoader(),orderService.getClass().getInterfaces(),handler);

proxy.addByJDKProxy();

这里通过 Proxy 的 newProxyInstance() 的静态方法为编织了业务逻辑和性能监视逻辑的 handler 创建了一个符合 OrderService 接口的代理实例。这个方法的各参数说明如下：

参数	类型	说明
loader	ClassLoader	类加载器。
interfaces	Class[]	创建代理实例所需要实现的一组接口。
h	InvocationHandler	整合了业务逻辑和横切逻辑的编织器对象。

JDK 动态代理时序图

3 CGLib 动态代理

JDK 创建代理时只能为接口创建代理实例。 Proxy 的 newProxyInstance 方法定义为：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

第二个参数 interfaces 就是需要代理实例实现的接口列表。

所以对于没有通用接口定义业务方法的类，可以 CGLib 实现动态代理。

CGLib 采用底层的字节码技术，可以为一个类创建子类，在子类中采用方法拦截技术来拦截所有父类方法的调用并顺势织入横切逻辑。

代理类：

public class PerformanceProxy implements MethodInterceptor {

    private Enhancer enhancer = new Enhancer();

    public Object getProxy(Class clazz) {
        enhancer.setSuperclass(clazz);//设置父类
        enhancer.setCallback(this);
        return enhancer.create();//使用字节码技术动态创建子类的实例
    }

    /**
     * 拦截父类所有方法的调用
     *
     * @param o           目标类实例
     * @param method      目标类方法的反射对象
     * @param args        方法的动态入参
     * @param methodProxy 代理类实例
     * @return
     * @throws Throwable
     */
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        PerformanceMonitor.begin(o.getClass().getName() + "." + method.getName());
        Object result = methodProxy.invokeSuper(o, args);
        PerformanceMonitor.end();
        return result;
    }
}

单元测试：

PerformanceProxy proxy = new PerformanceProxy();
OrderServiceImpl orderService = (OrderServiceImpl) proxy.getProxy(OrderServiceImpl.class);
orderService.addOrder();

输出结果：

开启监视…
模拟新增订单
结束监视…
net.deniro.spring4.aop.OrderServiceImpl$$EnhancerByCGLIB$$aea908ed.addOrder 耗费时间：83 毫秒

代理类名变为 OrderServiceImpl$$EnhancerByCGLIB$$aea908ed.addOrder 这个特殊的类就是 CGLib 为 OrderServiceImpl 动态创建的子类。

Spring AOP 通过切点（Pointcut）来决定需要在哪些类的哪些方法上织入横切逻辑；接着通过增强（Advice）来描述横切逻辑和方法的具体织入点；然后通过切面（Advisor）把切点与增强装配起来；最后，利用 JDK 或 CGLib 的动态代理技术为目标类创建已织入切面的代理对象。

所创建的动态代理对象的性能，CGLib 是 JDK 的 10 倍；而创建动态代理对象所花费的时间上，CGLib 却比 JDK 多花 8 倍的时间。所以，对于单例模式或者具有实例池的代理类，适合采用 CGLib 技术；反之，则适合采用 JDK 技术。

说说 Spring AOP 的底层实现技术（JDK 与 CGLib 动态代理）

1 订单服务实例

2 JDK 动态代理

3 CGLib 动态代理

猜你喜欢