Spring AOP （Spring 3.x 企业应用开发实战读书笔记第六章）

从面相对象编程到面相切面编程，是一种代码组织方式的进化。

每一代的代码组织方式，其实是为了解决当时面对的问题。比如写编译器和写操作系统的时候的年代当然要pop，比如写界面的时候当然要oop，因为界面这东西是人造的约定俗成的，继承关系清晰明了，当写互联网软件的时候自然要面相服务sop。大型商务系统的编写，问题就更加复杂，aop就应运而生了。

AOP 应用：
1. 监控系统重要API的调用事件，用来监控系统的性能。
2.Authentication 权限
3. Caching 缓存
4. Context passing 内容传递
5. Error handling 错误处理
6. Lazy loading　懒加载
7. Debugging　　调试
8. logging, tracing, profiling and monitoring　记录跟踪　优化　校准
9. Performance optimization　性能优化
10. Persistence　　持久化
11. Resource pooling　资源池
12. Synchronization　同步
13. Transactions 事务

我们用最简单的性能监控来举个例子，记录一个服务所消耗的时间.

服务类，计算一个数的阶乘：

public class FactorialUtil {
    public static int exFactirial(int n){
        PerformanceMonitor.begin("FactorialUtil -- exFactirial");
        int result = 1;
        for(int i=n;i>0;i--){
            result = result * i;
        }
        PerformanceMonitor.end();
        return result;
    }
}

里面使用了PerformanceMonitor类，来计算时间，这个类特别的简单：

public class PerformanceMonitor {
    private static ThreadLocal<Long> beginTime = new ThreadLocal<>();

    public static void begin (String url){
        beginTime.set(System.currentTimeMillis());
        System.out.println("begin monitor "+url);
    }

    public static void end (){
        long endTime = System.currentTimeMillis();
        System.out.println("end monitor");
        long costTime = endTime - beginTime.get();
        System.out.println("the method cost : " + costTime +"ms");
    }
}

线程安全，记录begin的系统时间和在end的时候把消耗时间减出来。

这样写代码有个好处，代码清晰明了，问题是阶乘计算类需要插入性能监控相关的代码，如果性能监控的代码需要修改，修改起来也比较麻烦。如果什么功能也需要添加性能监控，加起来也是很蛋疼的事。这种代码枯燥无味，全是套路不说，还容易出错。

因此第一个版本的解决方案旋即提出，他使用的jdk提供的动态代理的功能。实现方式如下：

首先将功能实现分为接口层和实现层。以期将功能代码标准化，能面相接口编程

public abstract class FactorialService {
    public abstract int exFactirial(int n);
}

public class FactorialServiceImpl extends FactorialService {
    @Override
    public int exFactirial(int n) {
        int result = 1;
        for(int i=n;i>0;i--){
            result = result * i;
        }
        return result;
    }
}

第二步，将性能监控的代码，封装在jdk动态代理提供的handler类之中：

public class PerformanceHandler implements InvocationHandler {
    private Object target;
    public PerformanceHandler(Object obj){
        this.target = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        PerformanceMonitor.begin("FactorialUtil -- exFactirial");
        Object result = method.invoke(target,args);
        PerformanceMonitor.end();
        return result;
    }
}

第三步，调用服务，使用java的proxy类，将服务包裹起来。

    public static int invokeByproxy(int n){
        FactorialService target = new FactorialServiceImpl();
        PerformanceHandler handler = new PerformanceHandler(target);
        FactorialService proxy = (FactorialService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler);
        return proxy.exFactirial(8);
    }

这样写，也就是用了个代理模式。细节上倒是没什么瑕疵，问题只有一个成本太高，类太多。出错不容易，但是估计也没有多少人愿意这么写。接着新一代技术就出来了Cglib技术，本质差不多，先上写法：

public class CglibProxy implements MethodInterceptor {
    private Enhancer enhancer= new Enhancer();

    public Object getProxy(Class clazz){
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        PerformanceMonitor.begin("FactorialUtil -- exFactirial");
        Object result = methodProxy.invokeSuper(o, args);
        PerformanceMonitor.end();
        return result;
    }
}

代理类实现和上面的代理类实现差别不大，使用了Cglib jar包中的MethodInterceptor接口。类的内部使用的是Enhancer来实例化。

调用方式特别简单：

    public static int invokeByCglib(int n){
        CglibProxy proxy = new CglibProxy();
        FactorialServiceImpl service = (FactorialServiceImpl)proxy.getProxy(FactorialServiceImpl.class);
        return service.exFactirial(8);
    }

好处：减少了实现接口类，只要实现功能类和代理类就可以了。

问题：1.目标类里面的所有方法都被增加性能监控了。

　　2.只能已方法作为单位增加性能监控的位置。

　　3.每个新功能都要增加代理类，写起来很麻烦。