017 Java中的静态代理、JDK动态代理、cglib动态代理

1、静态代理

代理模式是经常使用设计模式的一种，咱们在软件设计时经常使用的代理通常是指静态代理，也就是在代码中显式指定的代理。

静态代理由业务实现类、业务代理类两部分组成。业务实现类负责实现主要的业务方法，业务代理类负责对调用的业务方法做拦截、过滤、预处理。在须要调用业务时，不是直接经过业务实现类来调用的，而是经过业务代理类的同名方法来调用被处理过的业务方法。

静态代理的实现：

一、首先定义一个接口，说明业务逻辑。

package com.nnngu.dao;      
    /** 
     * 定义一个帐户接口 
     */  
    public interface Count {  
        // 查询帐户
        public void queryCount();  
      
        // 修改帐户  
        public void updateCount();  
      
    }

二、而后定义业务实现类，实现业务逻辑接口。

import com.nnngu.dao.Count;    
/** 
 * 委托类(包含业务逻辑) 
 */  
public class CountImpl implements Count {  
  
    @Override  
    public void queryCount() {  
        System.out.println("查看帐户...");   
    }  
  
    @Override  
    public void updateCount() {  
        System.out.println("修改帐户...");    
    }  
  
}

三、定义业务代理类：在代理类中建立一个业务实现类的对象来调用具体的业务方法；

在代理类中实现业务逻辑接口中的方法时：①进行预处理操做、②经过业务实现类的对象调用真正的业务方法、③进行调用后的操做。

public class CountProxy implements Count {  
    private CountImpl countImpl;  // 组合一个业务实现类的对象来进行真正的业务方法的调用
  
    /** 
     * 覆盖默认构造器 
     *  
     * @param countImpl 
     */  
    public CountProxy(CountImpl countImpl) {  
        this.countImpl = countImpl;  
    }  
  
    @Override  
    public void queryCount() {  
        System.out.println("查询帐户的预处理——————");  
        // 调用真正的查询帐户方法
        countImpl.queryCount();  
        System.out.println("查询帐户以后————————");  
    }  
  
    @Override  
    public void updateCount() {  
        System.out.println("修改帐户以前的预处理——————");  
        // 调用真正的修改帐户操做
        countImpl.updateCount();  
        System.out.println("修改帐户以后——————————");  
  
    }  
  
}

四、在使用时，首先建立业务实现类对象，而后把业务实现类对象看成构造参数建立一个代理类对象，最后经过代理类对象进行业务方法的调用。

public static void main(String[] args) {  

        CountImpl countImpl = new CountImpl();  
        CountProxy countProxy = new CountProxy(countImpl);  
        countProxy.updateCount();  
        countProxy.queryCount();  
  
    }

静态代理的缺点很明显：一个代理类只能对一个业务接口的实现类进行包装，若是有多个业务接口的话就要定义不少实现类和代理类才行。并且，若是代理类对业务方法的预处理、调用后操做都是同样的（好比：调用前输出提示、调用后自动关闭链接），则多个代理类就会有不少重复代码。这时咱们能够定义这样一个代理类，它能代理全部实现类的方法调用：根据传进来的业务实现类和方法名进行具体调用。——这就是动态代理。

2、JDK动态代理

JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正建立，JVM根据传进来的 业务实现类对象 以及 方法名 ，动态地建立了一个代理类的class文件并被字节码引擎执行，而后经过该代理类对象进行方法调用。咱们须要作的，只需指定代理类的预处理、调用后操做便可。

一、首先，定义业务逻辑接口

public interface BookFacade {  
    public void addBook();  
}

二、而后，实现业务逻辑接口建立业务实现类

public class BookFacadeImpl implements BookFacade {   
    @Override  
    public void addBook() {  
        System.out.println("增长图书方法。。。");  
    }  
  
}

三、最后，实现 调用管理接口InvocationHandler 建立动态代理类

public class BookFacadeProxy implements InvocationHandler {  
    private Object target; // 这是业务实现类对象，用来调用具体的业务方法 
	
    /** 
     * 绑定业务对象并返回一个代理类  
     */  
    public Object bind(Object target) {  
        this.target = target;  // 接收业务实现类对象参数

       // 经过反射机制，建立一个代理类对象实例并返回。
       // 建立代理对象时，须要传递该业务类的类加载器、接口、handler实现类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
                target.getClass().getInterfaces(), this); 
	}  
	
    /** 
     * 包装调用方法：进行预处理、调用后处理 
     */  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        Object result=null;  

        System.out.println("预处理操做——————");  
		
        // 调用真正的业务方法  
        result=method.invoke(target, args);  

        System.out.println("调用后处理——————");  
        return result;  
    }  
  
}

四、在使用时，首先建立一个业务实现类对象和一个代理类对象，而后定义接口引用，并用代理对象.bind(业务实现类对象)的返回值进行赋值。最后经过接口引用调用业务方法便可。

public static void main(String[] args) {  
        BookFacadeImpl bookFacadeImpl=new BookFacadeImpl();
        BookFacadeProxy proxy = new BookFacadeProxy();  
        BookFacade bookfacade = (BookFacade) proxy.bind(bookFacadeImpl);  
        bookfacade.addBook();  
    }

JDK动态代理的代理对象在建立时，须要使用业务实现类所实现的接口做为参数。若是业务实现类是没有实现接口而是直接定义业务方法的话，就没法使用JDK动态代理了。而且，若是业务实现类中新增了接口中没有的方法，这些方法是没法被代理的（由于没法被调用）。

3、cglib动态代理

cglib是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中的业务方法来实现代理。由于采用的是继承，因此不能对final修饰的类进行代理。

一、首先定义业务类，无需实现接口

public class BookFacadeImpl2 {  
    public void addBook() {  
        System.out.println("新增图书...");  
    }  
}

二、实现 MethodInterceptor 方法代理接口，建立代理类

public class BookFacadeCglib implements MethodInterceptor {  
    private Object target; // 业务类对象，供代理方法中进行真正的业务方法调用
  
    // 至关于JDK动态代理中的绑定
    public Object getInstance(Object target) {  
        this.target = target;  // 给业务对象赋值
        Enhancer enhancer = new Enhancer(); // 建立增强器，用来建立动态代理类
        enhancer.setSuperclass(this.target.getClass());  // 为增强器指定要代理的业务类
        // 设置回调：对于代理类上全部方法的调用，都会调用CallBack，而Callback则须要实现intercept() 方法进行拦截
        enhancer.setCallback(this); 
       // 建立动态代理类对象并返回  
       return enhancer.create(); 
    }
	
    // 实现回调方法 
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
        System.out.println("预处理——————");
        proxy.invokeSuper(obj, args); // 调用业务类（父类中）的方法
        System.out.println("调用后操做——————");
        return null; 
    }

三、建立业务类对象和代理类对象，而后经过 代理类对象.getInstance(业务类对象) 返回一个动态代理类对象（它是业务类的子类，能够用业务类引用指向它）。最后经过动态代理类对象进行方法调用。

public static void main(String[] args) {      
        BookFacadeImpl2 bookFacade=new BookFacadeImpl2()；
        BookFacadeCglib  cglib=new BookFacadeCglib();  
        BookFacadeImpl2 bookCglib=(BookFacadeImpl2)cglib.getInstance(bookFacade);  
        bookCglib.addBook();  
    }

4、总结

静态代理是经过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户经过代理类调用被包装过的业务方法；

JDK动态代理是经过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；

CGlib动态代理是经过继承业务类，生成的动态代理类是业务类的子类，经过重写业务方法进行代理；

---

本文永久更新地址：https://github.com/nnngu/LearningNotes/blob/master/Java%20Basis/017%20Java%E4%B8%AD%E7%9A%84%E9%9D%99%E6%80%81%E4%BB%A3%E7%90%86%E3%80%81JDK%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86%E3%80%81cglib%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86.md