Java代理学习笔记

代理模式 
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 

按照代理的创建时期，代理类可以分为两种。 
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
动态代理：在程序运行时，运用反射机制动态创建而成。

AOP（面向切面编程），就是针对代理的一种应用。

下面以一个简单示例开始：

public interface Hello {
    void say(String name);
}

public class HelloImpl implements Hello {
    @Override
    public void say(String name) {
        System.out.println("Hello! "+name);
    }
}

---------------main------------------------
Hello hello = new HelloImpl();
hello.say("Jack");
---------------console------------------------
Hello! Jack

现在有个需求，在say()方法执行前后分别执行相关逻辑。下面分别通过静态代理和动态代理来实现。

1.静态代理(GoF代理模式)

public class HelloProxy implements Hello {
    private Hello hello;
    public HelloProxy(){
        hello = new HelloImpl();
    }
    @Override
    public void say(String name) {
        before();
        hello.say(name);
        after();
    }
    private void before(){
        System.out.println("Before");
    }
    private void after(){
        System.out.println("After");
    }
}

---------------main------------------------
Hello hp = new HelloProxy();
hp.say("Tom");
---------------console------------------------
Before
Hello! Tom
After

2.动态代理(JDK动态代理，CGLIB动态代理)

(1).JDK动态代理

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

public class DynamicProxy implements InvocationHandler {

    private Object target;
    public DynamicProxy(Object target){
        this.target = target;
    }
    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        before();
        Object result = method.invoke(target, args);
        after();
        return result;
    }
    
    private void before(){
        System.out.println("Before");
    }
    private void after(){
        System.out.println("After");
    }
}

----------------main-----------------------
DynamicProxy dp = new DynamicProxy(new HelloImpl());
Hello helloProxy = dp.getProxy();
helloProxy.say("Grace");
-----------------console----------------------
Before
Hello! Grace
After

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 

(2).CGLib实现动态代理
需要引入两个jar: cglib-2.2.2.jar,  asm-3.3.jar
ASM：一个轻量级的字节码生成及转换器。 
CGLIB：一个功能强大的动态代理代码工具，可以根据指定的类动态生成一个子类，并提供了方法拦截的相关机制，并且在大量的流行开源框架(如 Hibernate、Spring 等)中得到使用。

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGLibProxy implements MethodInterceptor {
    private static CGLibProxy instance = new CGLibProxy();
    private CGLibProxy() {
    }
    public static CGLibProxy getInstance() {
        return instance;
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy(Class<T> cls) {
        return (T) Enhancer.create(cls, this);
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
        before();
        Object result = proxy.invokeSuper(obj, args);
        after();
        return result;
    }
    
    private void before(){
        System.out.println("Before");
    }
    private void after(){
        System.out.println("After");
    }

}
----------------main-----------------------
HelloImpl helloImpl = CGLibProxy.getInstance().getProxy(HelloImpl.class);
helloImpl.say("Victor");
---------------console------------------------
Before
Hello! Victor
After

参考：
1.http://my.oschina.net/huangyong/blog/159788 Proxy那点事儿
2.http://my.oschina.net/huangyong/blog/161338 AOP那点事儿
3.http://jinnianshilongnian.iteye.com/blog/1474325 我对AOP的理解
4.http://kiral.iteye.com/blog/1198982 AOP实现机制