代理模式简介

一、概念

　　为某个对象提供一个代理，以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。 
　　代理可以分为静态代理和动态代理

二、静态代理

　　由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

代理接口：

public interface BookStore {

    public void buybook(int i);
    
    public void querybook();

}

委托类：

public class BookStoreImpl implements BookStore {

    public static int count = 0;

    public static int getCount() {
        return count;
    }

    public static void setCount(int count) {
        BookStoreImpl.count = count;
    }

    @Override
    public void buybook(int i) {
        count += i;
        System.out.println("购买了" + i + "本书");

    }

    @Override
    public void querybook() {
        System.out.println("手上有" + count + "本书");
    }

}

静态代理：

public class StaticProxyBookStore implements BookStore {
    BookStore bs = new BookStoreImpl();

    @Override
    public void buybook(int i) {
        System.out.println("开始");
        bs.buybook(i);
        System.out.println("结束");
    }

    @Override
    public void querybook() {
        bs.querybook();
    }

}

测试类：

package ty.practice.dynmicTest;

public class ProxyTest2 {
    public static void main(String[] args) {
        StaticProxyBookStore proxy = new StaticProxyBookStore();
        proxy.buybook(10);
        System.out.println(".........");
        proxy.querybook();
    }
}

结果：

开始
购买了10本书
结束
.........
手上有10本书

优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。 
缺点： 
1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。 
2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。 

三、JDK动态代理

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。 

实现步骤：

a. 实现InvocationHandler接口创建自己的调用处理器 
b. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类 
c. 以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数 
d. 以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象 

代理类：

public class DynamicProxyBookStore implements InvocationHandler {

    Object target;

    public DynamicProxyBookStore(Object bs) {
        this.target = bs;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始");
        method.invoke(target, args);
        System.out.println("结束");
        return null;
    }

}

测试类：

public class ProxyTest {
    public static void main(String[] args) {
        BookStore bs = (BookStore)Proxy.newProxyInstance(BookStore.class.getClassLoader(), BookStoreImpl.class.getInterfaces(), new DynamicProxyBookStore(new BookStoreImpl()));
            bs.buybook(10);
            
            bs.querybook();
    }
}

结果：

开始
购买了10本书
结束
..........
开始
手上有10本书
结束

优点： 
　　动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。在本示例中看不出来，因为invoke方法体内嵌入了具体的外围业务（记录任务处理前后时间并计算时间差），实际中可以类似Spring AOP那样配置外围业务。 

缺点： 
　　诚然，Proxy 已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持 interface 代理的桎梏，因为它的设计注定了这个遗憾。

四、CGLIB动态代理

委托类：

public class BookStore {
    public int count = 0;

    public void buyBook(int i) {
        System.out.println("购买了" + i + "本书");
        count += i;
    }

    public void query() {
        System.out.println(count);
    }
}

代理类：

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 arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
        System.out.println("前置代理");
        Object result = arg3.invokeSuper(arg0, arg2);
        System.out.println("后置代理");
        return null;
    }

}

测试类：

public class CglibTest extends TestCase {
    public void testCglib() {
        CglibProxy proxy = new CglibProxy();
        // 通过生成子类的方式创建代理类
        BookStore Bookproxy = (BookStore) proxy.getProxy(BookStore.class);
        Bookproxy.buyBook(10);
        Bookproxy.buyBook(20);
        Bookproxy.query();
    }
}

总结：CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

参考：

http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/