设计模式 - 代理模式

  今天看了下几篇文章，终于把代理模式讲清楚了。
  Java的代理模式用于解决如下的几个问题：

• 隔离作用：使用方只需要关注业务功能，其他的不需要关注，这就需要隐藏相关的内容，隔离原来的委托对象。
• 增加功能：还可以通过给代理类增加额外的功能来扩展委托类的功能。

  举个例子：传统观念中，学生只需要学习，不用关心日常生活琐事（当然这是不对的）。早上起来，你只要到学校开始早读、上课就行了，至于怎么去，吃什么这些就是由家长（这就是代理）去帮你安排好（隔离隐藏作用）。

一、静态代理

  你的核心就是读书上课，所以将它封装成接口。

interface Student{
    void study();
    void classBegins();
}

  每一个人（对象），都有自己的习惯，每个实现的方式都不同。比如你：

class StudentImpl implements Student{
    @Override
    public void study() {
        System.out.println("我不想读书");
    }
    @Override
    public void classBegins() {
        System.out.println("上课是什么，可以吃吗?!");
    }
}

  好了，接下来就是怎么到达教室，所以需要一个代理，帮你关心其他的事情，当然你要是有其他的兄弟姐妹也一起搞定。

class StudentProxy implements Student{

    private Student student;
    public StudentProxy(Student student){
        this.student = student;
    }

    /**
    * 交通
    */
    public void traffic(){
        System.out.println("走路");
    }

    @Override
    public void study() {
        traffic();
        student.study();
    }
    @Override
    public void classBegins() {
        traffic();
        student.classBegins();
    }
}

  好了，就只要将抠门的父母和你组装起来就行了，当然你要是有一个马云舅舅，就需要换一个代理。

Student proxy = new StudentProxy(new StudentImpl());
proxy.study();

一、动态代理

  静态代理，是在程序运行之前，代理类.class文件就已经被创建了。每次你增加新的内容，你的代理都要增加一份，会比较麻烦。动态代理是在程序运行时通过反射机制动态创建的。

class StudentProxy implements InvocationHandler {

    private Object target=null;//保存真实业务对象
    /**
     * 返回动态代理类的对象,这样用户才可以利用代理类对象去操作真实对象
     * @param obj  包含有真实业务实现的对象
     * @return   返回代理对象
     */
    public Object getProxy(Object obj) {
        this.target=obj;//保存真实业务对象
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        traffic();
        Object result=method.invoke(target, args);//通过反射调用真实业务对象的业务方法,并且返回
        return result;
    }
    
     /**
    * 交通
    */
    public void traffic(){
        System.out.println("走路");
    }
}

  每次增加了新的业务功能，代理就不用关系，因为你的Impl自动会被调用.

 Student proxy = (Student) new StudentProxy().getProxy(new StudentImpl());
 proxy.study();

  动态代理和静态代理相比较，最大的好处就是接口中声明的所有的方法都被转移到一个集中的方法中去处理，就是invocke()方法.这样在接口中声明的方法比较多的情况下我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。

三、CGLIB

   JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

public class CglibProxy implements MethodInterceptor {
     private Object target;
     public Object getInstance(final Object target) {
         this.target = target;
         Enhancer enhancer = new Enhancer();
         enhancer.setSuperclass(this.target.getClass());
         enhancer.setCallback(this);
         return enhancer.create();
     }
 
     public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
         traffic();
         Object result = methodProxy.invokeSuper(object, args);
         return result;
     }
     /**
    * 交通
    */
    public void traffic(){
        System.out.println("走路");
    }
 }

Student proxy  = (Student) new CglibProxy.getInstance(new StudentImpl());
proxy.study();

总结

  CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。