spring AOP详解二

AOP实例（通过Proxy代理模式）

Spring AOP使用纯java实现，不需要专门的编译过程和类装载器，它在运行期间通过代理方式向目标类织入增强代码，它更侧重于提供一种和Spring IoC容器整合的AOP实现，在Spring中，我们可以无缝的将AOP,IoC,AspectJ整合在一起。

Spring AOP使用了两种代理机制：一种是基于JDK的动态代理，一种是基于CGLib的动态代理；

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

下面我们来看一个JDK动态代理的例子：

1.业务接口UserService.java

package spring.aop.demo1;

public interface UserService {
    void removeUser(int userId);
}

2.横切逻辑代理监视代码PerformanceMonitor.java

package spring.aop.demo1;

public class MethodPerformance {

    private long begin;

    private long end;

    private String serviceMethod;

    public MethodPerformance(String serviceMethod) {
        this.serviceMethod = serviceMethod;
        this.begin = System.currentTimeMillis();
    }

    public void printPerformance() {
        this.end = System.currentTimeMillis();
        long elapse = end - begin;

        System.out.println(serviceMethod + "花费" + elapse + "毫秒");
    }

}

package spring.aop.demo1;

public class PerformanceMonitor {

    // 通过一个ThreadLocal保存调用线程相关的性能监视信息
    private static ThreadLocal<MethodPerformance> performanceRecord = new ThreadLocal<MethodPerformance>();

    // 启动对一目标方法的性能监视
    public static void begin(String method) {
        System.out.println("begin monitor...");
        MethodPerformance mp = new MethodPerformance(method);
        performanceRecord.set(mp);
    }

    public static void end() {
        System.out.println("end monitor...");
        MethodPerformance mp = performanceRecord.get();
        mp.printPerformance();
    }

}

3.横切逻辑代理代码PerformanceHandler.java

package spring.aop.demo1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class PerformanceHandler implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object arg0, Method arg1, Object[] arg2)
            throws Throwable {
        PerformanceMonitor.begin(target.getClass().getName() + "."
                + arg1.getName());
        Object obj = arg1.invoke(target, arg2);// 通过反射机制调用目标对象的方法
        PerformanceMonitor.end();
        return obj;
    }

}

首先，我们实现InvocationHandler接口，该接口定义了一个invoke方法，proxy最是最终生成的一个代理实例，一般不会用到，参数arg1是被代理目标实例的某个具体的方法，通过它可以发起目标实例方法的反射调用；参数arg2是通过被代理实例某一个方法的入参，在方法反射调用时候使用，通过代理将横切逻辑代码和业务类的代码编织到了一起。

我们在构造函数里通过target传入希望被代理的目标对象，将目标实例产地个method.inoke(),调用目标实例的方法。

4.通过Proxy结合PerformanceHandler创建UserService接口的代理实例：

package spring.aop.demo1;

import java.lang.reflect.Proxy;

public class UserServiceImpl implements UserService {

    @Override
    public void removeUser(int userId) {
        System.out.println("模拟删除用户：" + userId);
        try {
            Thread.currentThread().sleep(200);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        // 将目标业务类和横切代码编织到一起
        PerformanceHandler handler = new PerformanceHandler(userService);

        // 根据编织了目标业务类逻辑和性能监视横切逻辑的InvocationHandler实例创建代理实例
        UserService proxy = (UserService) Proxy.newProxyInstance(userService
                .getClass().getClassLoader(), userService.getClass()
                .getInterfaces(), handler);

        proxy.removeUser(3);

    }
}

输出：

begin monitor...
模拟删除用户：3
end monitor...
spring.aop.demo1.UserServiceImpl.removeUser花费203毫秒

说明：上面的代码完成业务类代码和横切代码的编制工作，并生成了代理实例，newProxyInstance方法的第一个参数为类加载器，第二个参数为目标类所实现的一组接口，第三个参数是整合了业务逻辑和横切逻辑的编织器对象。使用JDK代理模式有一个限制，即它只能为接口创建代理实例，这一点我们可以从Proxy.newProxyInstance的方法签名中就可以看的很清楚，第二个参数interfaces就是需要代理实例实现的接口列表。