7种结构型模式之：代理模式 、JDK动态代理、cglib动态代理

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图：

根据上文的阐述，代理模式就比较容易的理解了，我们看下代码：

[java]  view plain  copy

 public interface Sourceable {
     public void method();
 }

[java]  view plain  copy

 public class Source implements Sourceable {

     @Override
     public void method() {
         System.out.println("the original method!");
     }
 }

[java]  view plain  copy

 public class Proxy implements Sourceable {

     private Source source;
     public Proxy(){
         super();
         this.source = new Source();
     }
     @Override
     public void method() {
         before();
         source.method();
         atfer();
     }
     private void atfer() {
         System.out.println("after proxy!");
     }
     private void before() {
         System.out.println("before proxy!");
     }
 }

测试类：

[java]  view plain  copy

 public class ProxyTest {

     public static void main(String[] args) {
         Sourceable source = new Proxy();
         source.method();
     }

 }

输出：

before proxy!
the original method!
after proxy!

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

--------------------------------------------------------------------------------------------------------------------------------------------------------

jdk动态代理

特点：只能对实现了接口的类生产代理，不能针对类

定义接口

 /**
  * 创建业务接口，包含业务可以提供对外的接口
  *
  * @author Fighter
  * @date 2016-04-19
  *
  */
 public interface UserService{

     /**
      * 目标方法
      */
     public void add();
 }

定义实现类

 /**
  * 创建业务接口实现类
  *
  * @author Fighter
  * @date 2016-04-19
  *
  */
 public class UserServiceImpl implements UserService{
     @Override
     public void add() {
      System.out.println("----------add----------");

     }
 }

定义代理

 /**
  * 自定义简单的Invocation，对接口提供的方法进行增强
  *
  * @author Fighter
  * @date 2016-04-19
  */
 public class MyInvocationHandler implements InvocationHandler {


     //目标对象
     private Object target;

     /**
      * 构造方法
      * @param target 目标对象
      */
     public MyInvocationHandler(Object target) {
         super();
         this.target=target;
     }

      * 执行目标对象的方法
      */
     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {

          //在目标方法执行前简单打印一下
          System.out.println("----------before----------");

          //执行目标方法对象
          Object result=method.invoke(target, args);

          //在目标方法执行之后简单打印一下
          System.out.println("----------after----------");

          return result;
     }


     /**
      * 获取目标对象的代理对象
      * @return 代理对象
      * this.target.getClass().getInterfaces()//获取被代理对象实现的所有接口
      */
     public Object getProxy(){
         return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                 this.target.getClass().getInterfaces(),this);
     }


 }

jdk动态代理测试

 public class ProxyTest{

     @Test
     public void testProxy() throws Throwable{
         //实例化目标对象
         UserService userService=new UserServiceImpl();

         //实例化Invocation
         MyInvocationHandler invocationHandler=new MyInvocationHandler(userService);

         //根据目标生成代理对象
         UserService proxy=(UserService)invocationHandler.getProxy();

         //调用代理对象方法
         proxy.add();
     }
 }

CGLIB动态代理示例

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

CGLIB是一个强大的高性能的代码生成包。被广泛的许多AOP框架使用，如Spring的AOP和dynaop，为他们提供方法的interceptor(拦截)，最流行的是OR Mapping工具hibernate也是使用CGLIB来代理单端的single-ended（多对一和一对一）关联（对集合的延迟抓取是采用其他机制实现）。EsayMock和jMock是通过模仿（moke）对象来测试java代码的包。他们都是通过使用CGLIB来为那些没有接口的类创建模仿（moke）对象。

我们先通过demo来快速了解CGLIB的使用示例。

定义实现类

 /**
  * 这个是没有实现接口的实现类
  *
  * @author student
  *
  */
 public class BookFacadeImpl {
     public void addBook() {
         System.out.println("增加图书的普通方法...");
     }
 }

定义代理

 /**
  * 使用cglib动态代理
  *
  * @author student
  *
  */
 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.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;


     }

 }

编写Cglib测试

 public class TestCglib {

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

总结

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