Java学习整理系列之Java动态代理

代理模式 
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
按照代理的创建时期，代理类可以分为两种。 
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 

动态代理：在程序运行时，运用反射机制动态创建而成。 

首先看一下静态代理： 

1、Count.java 

package net.battier.dao;/** * 定义一个账户接口 *  * @author Administrator *  */public interface Count {// 查看账户方法public void queryCount();// 修改账户方法public void updateCount();}

2、CountImpl.java 

package net.battier.dao.impl;    import net.battier.dao.Count;    /**  * 委托类(包含业务逻辑)  *   * @author Administrator  *   */  public class CountImpl implements Count {        @Override      public void queryCount() {          System.out.println("查看账户方法...");        }        @Override      public void updateCount() {          System.out.println("修改账户方法...");        }    } 

3、CountProxy.java 

package net.battier.dao.impl;    import net.battier.dao.Count;    /**  * 这是一个代理类（增强CountImpl实现类）  *   * @author Administrator  *   */  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("事务处理之后");        }    }  

4、TestCount.java 

package net.battier.test;import net.battier.dao.impl.CountImpl;import net.battier.dao.impl.CountProxy;/** *测试Count类 *  * @author Administrator *  */public class TestCount {public static void main(String[] args) {CountImpl countImpl = new CountImpl();CountProxy countProxy = new CountProxy(countImpl);countProxy.updateCount();countProxy.queryCount();}}

观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。 

再来看一下动态代理： 
JDK动态代理中包含一个类和一个接口： 
InvocationHandler接口： 
public interface InvocationHandler { 
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
} 
参数说明： 
Object proxy：proxy一般是指代理类。 
Method method：method是代理的方法
Object[] args：args为该方法的参数数组

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。 

Proxy类： 
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法： 
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
InvocationHandler h)  throws IllegalArgumentException 
参数说明： 
ClassLoader loader：类加载器 
Class<?>[] interfaces：得到全部的接口,只有知道有哪些接口，那么Proxy才能有哪些方法需要这个代理类实现。一般我们通过实现类Impl.class.getInterfaces() 获得那些需要代理类实现的方法。
InvocationHandler h：得到InvocationHandler接口的子类实例 

Ps:类加载器 
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器; 
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。 

动态代理 
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

简单地说，A接口有c方法，类B实现A接口，原本应该是执行B类中的c方法，可现在不这样做； 
我声明产生B类的代理类B',由它来冒充B类的“兄弟”并“实现”A接口， 
对外界来说B'应该也有c方法，可当真正调用它的时候， 
它会去执行与它关联InvocationHandler的invoke()方法， 
在这个方法里面你可以做很多事情。这样，这个请求就被“代理”到其它地方去了。 

动态代理示例: 

抽象接口

package com.lxq.proxy;public interface Hello{void sayHello(String to);void print(String p);}

接口的实现类:

package com.lxq.proxy;public class HelloImpl implements Hello{public void sayHello(String to){System.out.println("Say hello to " + to);}public void print(String s){System.out.println("print : " + s);}}

在这里生成与代理类相关联的InvocationHandler对象 

package com.lxq.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class LogHandler implements InvocationHandler{private Object dele;//将被代理对象传入public LogHandler(Object obj){this.dele = obj;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{doBefore();//而做一些其它的事情Object result = method.invoke(dele, args);after();//而做一些其它的事情return result;}private void doBefore(){System.out.println("before....");}private void after(){System.out.println("after....");}}

最后是测试类: 

package com.lxq.proxy;import java.lang.reflect.Proxy;public class ProxyTest{public static void main(String[] args){HelloImpl impl = new HelloImpl();//利用构造方法将被代理对象传入LogHandler handler = new LogHandler(impl);//新生成的代理类与handler相关联，因为handler中有被代理类//通过Proxy生成实现Hello接口的类HelloImpl的代理类//这就说明JDK的动态代理只能是代理实现接口的类，而无法代理继承的类Hello hello = (Hello) Proxy.newProxyInstance(HelloImpl.class.getClassLoader(), HelloImpl.class.getInterfaces(),handler);//这里无论访问哪个方法，都是会把请求转发到handler.invokehello.print("All the test");hello.sayHello("Denny");}}

这里是输出结果: 

before....print : All the testafter....before....Say hello to Dennyafter....

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。 

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

没有实现接口的实现类

<span style="color:#330033;">package com.lxq.proxy.cglib;/*** @author lxq* @version 2014年9月9日 上午10:34:23 */public class BookFacadeImpl{public void addBook(){System.out.println("增加图书方法。。。");}}</span>

代理对象生成类和调用类

package com.lxq.proxy.cglib;import java.lang.reflect.Method;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;/*** @author lxq* @version 2014年9月9日 上午10:34:59 */public class BookFacadeCglib implements MethodInterceptor {      private Object target;        /**      * 创建代理对象      *       * @param target      * @return      */      public Object getInstance(Object target) {          this.target = target;          Enhancer enhancer = new Enhancer();          enhancer.setSuperclass(this.target.getClass());          //Enhancer在生成一个类之前需要指定一个Callback，当类方法调用时，方法的执行被分配给这个Callback        //MethodInterceptor是一个使用比较多的继承自Callback的接口，它只有一个方法声明intercept        enhancer.setCallback(this);          // 创建代理对象          return enhancer.create();      }        @Override      // 回调方法      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;      }  }  

测试类

package com.lxq.proxy.cglib;/*** @author lxq* @version 2014年9月9日 上午10:37:52 */public class TestCglib {          public static void main(String[] args) {          BookFacadeCglib cglib=new BookFacadeCglib();          BookFacadeImpl bookCglib=(BookFacadeImpl)cglib.getInstance(new BookFacadeImpl());          bookCglib.addBook();      }  } 

输出结果

事物开始增加图书方法。。。事物结束