现在的位置: 首页 > 综合 > 正文

最详细的代理讲解–JDK动态代理和cglib代理 (类比spring中事物的代理) 最详细的代理讲解–JDK动态代理和cglib代理

2018年05月23日 ⁄ 综合 ⁄ 共 6373字 ⁄ 字号 小 中 大 ⁄ 评论关闭
 

最详细的代理讲解--JDK动态代理和cglib代理

1.代理相关的概念

代理模式

    代理模式的英文叫做Proxy或Surrogate，中文都可译为”代理“，所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用

抽象主题角色

    声明了真实主题和代理主题的共同接口，这样一来在任何可以使用真实主题的地方都可以是使用代理主题

代理主题（Proxy）角色

    代理主题角色内部含有对真实主题的引用，从而可以在任何时候操作真实主题对象；代理主题角色提供一个与真实主题角色相同的接口，以便可以在任何时候都可以替代真实主题控制对真实主题的引用，负责在需要的时候创建真实主题对象（和删除真实主题对象）；代理角色通常在将客户端调用传递给真实的主题之前或之后，都要执行某个操作，而不是单纯地将调用传递给真实主题对象。

真实主题角色

   定义了代理角色所代表地真实对象

spring有两种代理方式：

   1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。

   2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

2.案例分析两种代理的异同

JDK动态代理

    注意事项：编写JDK代理类引用的是java的工具包lang中的反射包下的Proxy，不需要引入其他jar包，但是要注意不要倒错包了；import java.lang.reflect.Proxy; 目标对象实现了若干接口。

   两个接口类SayByeBye、SayGoodBye

[java] view
plaincopyprint?

  1. package www.csdn.spring.proxy.jdk;  
  2.   
  3. public interface SayByeBye {  
  4.       
  5.     public void sayByeBye();  
  6.   
  7. }  
  8.   
  9. package www.csdn.spring.proxy.jdk;  
  10.   
  11. public interface SayGoodBye {  
  12.       
  13.     public void sayGoodBye(String content);  
  14.   
  15. }  
  16.    这两个接口类的实现类SayByeImplement  
  17. package www.csdn.spring.proxy.jdk;  
  18.   
  19. public class SayByeImpl implements SayGoodBye,SayByeBye {  
  20.   
  21.     @Override  
  22.     public void sayGoodBye(String content) {  
  23.         System.out.println("say:"+content);  
  24.     }  
  25.   
  26.     @Override  
  27.     public void sayByeBye() {  
  28.         System.out.println("say:拜拜！");  
  29.     }  
  30.   
  31. }  
  32.   JDK代理类JDKProxy  
  33. package www.csdn.spring.proxy.jdk;  
  34.   
  35. import java.lang.reflect.InvocationHandler;  
  36. import java.lang.reflect.Method;  
  37. import java.lang.reflect.Proxy;  
  38.   
  39. public class JDKProxy implements InvocationHandler {  
  40.   
  41.     // 代理目标对象  
  42.     private Object target;  
  43.   
  44.     // 创建目标对象的代理对象  
  45.     public Object createProxyInstance(Object target) {  
  46.         // 代理的目标对象  
  47.         this.target = target;
     
  48.         // 创建代理对象  
  49.         // 1、定义代理类的类加载器  
  50.         // 2、代理类要实现的接口列表  
  51.         // 3、 指派方法调用的调用处理程序  
  52.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
  53.                 target.getClass().getInterfaces(), this);  
  54.     }  
  55.   
  56.     /** 
  57.      * proxy:目标对象的代理实例,改代理实例不管运行多少次都是class $Proxy4 ; 
  58.      * method：对于代理实例调用接口方法的Method实例; 
  59.      * args：方法参数 
  60.      */  
  61.     @Override  
  62.     public Object invoke(Object proxy, Method method, Object[] args)  
  63.             throws Throwable {  
  64.         /* 
  65.          * 测试invoke方法的三个参数的含义 
  66.          */  
  67.         System.out.println("proxy:"+proxy.getClass());  
  68.         System.out.println("method:"+method.getName());  
  69.         if(args!=null&&args.length>0){  
  70.             for(Object obj : args){  
  71.                 System.out.println("args:"+obj);  
  72.             }  
  73.         }  
  74.           
  75.         //声明返回值  
  76.         Object returnValue = null; 
  77.         //执行真正方法之前执行的方法 
  78.         beforeMethod();  
  79.         //执行真正的方法
  80.         returnValue = method.invoke(target, args); 
  81.         //执行完真正方法之后做的操作
  82.         afterMethod();  
  83.         return returnValue;  
  84.     }  
  85.       
  86.     public void beforeMethod(){  
  87.         System.out.println("----方法执行之前的操作----");  
  88.     }  
  89.     public void afterMethod(){  
  90.         System.out.println("----方法执行之后的操作----");  
  91.     }  
  92. }  
  93.   测试类ProTest  
  94. package www.csdn.spring.proxy.jdk;  
  95.   
  96. import org.junit.Test;  
  97.   
  98. public class ProxyTest {  
  99.   
  100.     @Test  
  101.     public void testSay() {  
  102.           
  103.         //真是主题角色  
  104.         SayByeImpl sayByeImpl = new SayByeImpl();  
  105.           
  106.         /* 
  107.          * //不使用代理的情况 
  108.          *  sayByeImpl.sayGoodBye("我要离婚！");  
  109.          *  sayByeImpl.sayByeBye(); 
  110.          */  
  111.         
  112.         //代理主题角色,这里用代理主题和真实主题实现的同样接口类来接收创建的代理主题，就是创建一个目标类  
  113.         SayGoodBye sayGoodBye = (SayGoodBye) new JDKProxy().createProxyInstance(sayByeImpl);  
  114.         SayByeBye sayByeBye = (SayByeBye) new JDKProxy().createProxyInstance(sayByeImpl);  
  115.         sayGoodBye.sayGoodBye("受不了了，我要离婚！");  
  116.         System.out.println("00000000000000000000000000000000000000000000000");  
  117.         sayByeBye.sayByeBye();  
  118.     }  
  119.   
  120. }  


 

CGLIB做代理

    CGlib是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。

    注意事项：使用cglib做代理，java中不想jdk动态代理那样给封装好了相应的类，他需要导入所依赖的jar包asm-3.3.jar、cglib-2.2.jar这两个jar包；目标对象没有实现任何接口

   目标类SayHello

package www.csdn.spring.proxy.cglib;

 

publicclass SayHello {

  

   publicvoid say(String content) {

      System.out.println("say:" + content);

   }

}

   cglib代理类CglibProxy

[java] view
plaincopyprint?
  1. package www.csdn.spring.proxy.cglib;  
  2.   
  3. import java.lang.reflect.Method;  
  4.   
  5. import net.sf.cglib.proxy.Enhancer;  
  6. import net.sf.cglib.proxy.MethodInterceptor;  
  7. import net.sf.cglib.proxy.MethodProxy;  
  8.   
  9. public class CglibProxy implements MethodInterceptor{  
  10.       
  11.     private Object target;  
  12.     public Object createProxyInstance(Object target){  
  13.         this.target = target;  
  14.         //生成代理对象  
  15.         Enhancer  enhancer = new Enhancer();  
  16.         // 用于设置代理对象的父类  
  17.         enhancer.setSuperclass(this.target.getClass());  
  18.         //设置回调  
  19.         enhancer.setCallback(this);  
  20.         //创建代理对象   
  21.         return enhancer.create();  
  22.     }  
  23.   
  24.     /** 
  25.      * proxy：目标对象代理的实例； 
  26.      * method:目标对象调用父类方法的method实例 ； 
  27.      * args:调用父类方法传递参数 
  28.      * methodProxy:代理的方法去调用目标方法 
  29.      */  
  30.     @Override  
  31.     public Object intercept(Object proxy, Method method, Object[] args,  
  32.             MethodProxy methodProxy) throws Throwable {  
  33.         /* 
  34.          * 测试invoke方法的四个参数的含义 
  35.          */  
  36.         System.out.println("proxy:"+proxy.getClass());  
  37.         System.out.println("method:"+method.getName());  
  38.         System.out.println("methodProxy:"+methodProxy.getSuperName());  
  39.         if(args!=null&&args.length>0){  
  40.             for(Object obj : args){  
  41.                 System.out.println("args:"+obj);  
  42.             }  
  43.         }  
  44.           
  45.         //声明返回值  
  46.         Object returnValue = null;  
  47.         beforeMethod();  
  48.         //使用method和methodProxy参数都可以调用invoke方法，并且执行出来的效果一样  
  49.         //returnValue = methodProxy.invoke(target, args);  
  50.         returnValue = method.invoke(target, args);  
  51.         afterMethod();  
  52.         return returnValue;  
  53.     }  
  54.       
  55.     public void beforeMethod(){  
  56.         System.out.println("----方法执行之前的操作----");  
  57.     }  
  58.     public void afterMethod(){  
  59.         System.out.println("----方法执行之后的操作----");  
  60.     }  
  61. }  
  62.    测试类proxyTest  
  63. package www.csdn.spring.proxy.cglib;  
  64.   
  65. import org.junit.Test;  
  66.   
  67. public class ProxyTest {  
  68.   
  69.     @Test  
  70.     public void testSay() {  
  71.           
  72.         //真是主题角色  
  73.         SayHello sayHello = new SayHello();  
  74.         //sayHello.say("嗨！你好啊！");  
  75.           
  76.         //创建了一个 目标类的对象 ，jdk动态代理中创建的是接口类对象，cglib由于不实现任何接口，所以直接创建一个目标类的对象  
  77.         SayHello sh = (SayHello) new CglibProxy().createProxyInstance(sayHello);  
  78.         sh.say("嗨！你好啊！");  
  79.     }  
  80.   
  81. }  
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞