除了JDK、CGLIB，还有3种类代理方式

 五种类代理的方式

不出意外，你可能只知道两种类代理的方式。一种是JDK自带的，另外一种是CGLIB。

创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于成都网站制作、成都网站建设、前郭网络推广、微信小程序定制开发、前郭网络营销、前郭企业策划、前郭品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联公司为所有大学生创业者提供前郭建站搭建服务，24小时服务热线：18982081108，官方网址：www.cdcxhl.com

我们先定义出一个接口和相应的实现类，方便后续使用代理类在方法中添加输出信息。

「定义接口」 

 
 
 
 
    
  
  
  
  
  1. public interface IUserApi { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     String queryUserInfo(); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. } 
    6.

「实现接口」 

 
 
 
 
    
  
  
  
  
  1. public class UserApi implements IUserApi { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public String queryUserInfo() { 
    4.   
  
  
  
  4.         return "沉淀、分享、成长，让自己和他人都能有所收获！"; 
    5.   
  
  
  
  5.     } 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. } 
    8.

好！接下来我们就给这个类方法使用代理加入一行额外输出的信息。

0. 先补充一点反射的知识

 
 
 
 
    
  
  
  
  
  1. @Test 
    2.   
  
  
  
  2. public void test_reflect() throws Exception { 
    3.   
  
  
  
  3.     Class clazz = UserApi.class; 
    4.   
  
  
  
  4.     Method queryUserInfo = clazz.getMethod("queryUserInfo"); 
    5.   
  
  
  
  5.     Object invoke = queryUserInfo.invoke(clazz.newInstance()); 
    6.   
  
  
  
  6.     System.out.println(invoke); 
    7.   
  
  
  
  7. } 
    8.
  • 点评：有代理地方几乎就会有反射，他们是一套互相配合使用的功能类。在反射中可以调用方法、获取属性、拿到注解等相关内容。这些都可以与接下来的类代理组合使用，完成各种框架中的技术场景。

1. JDK代理方式 

 
 
 
 
    
  
  
  
  
  1. public class JDKProxy { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static  T getProxy(Class clazz) throws Exception { 
    4.   
  
  
  
  4.         ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); 
    5.   
  
  
  
  5.         return (T) Proxy.newProxyInstance(classLoader, new Class[]{clazz}, new InvocationHandler() { 
    6.   
  
  
  
  6.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    7.   
  
  
  
  7.                 System.out.println(method.getName() + " 你被代理了，By JDKProxy！"); 
    8.   
  
  
  
  8.                 return "沉淀、分享、成长，让自己和他人都能有所收获！"; 
    9.   
  
  
  
  9.             } 
    10.   
  
  
  
  10.         }); 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. @Test 
    16.   
  
  
  
  16. public void test_JDKProxy() throws Exception { 
    17.   
  
  
  
  17.     IUserApi userApi = JDKProxy.getProxy(IUserApi.class); 
    18.   
  
  
  
  18.     String invoke = userApi.queryUserInfo(); 
    19.   
  
  
  
  19.     logger.info("测试结果：{}", invoke); 
    20.   
  
  
  
  20. } 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22. /** 
    23.   
  
  
  
  23.  * 测试结果： 
    24.   
  
  
  
  24.  *  
    25.   
  
  
  
  25.  * queryUserInfo 你被代理了，By JDKProxy！ 
    26.   
  
  
  
  26.  * 19:55:47.319 [main] INFO  org.itstack.interview.test.ApiTest - 测试结果： 沉淀、分享、成长，让自己和他人都能有所收获！ 
    27.   
  
  
  
  27.  * 
    28.   
  
  
  
  28.  * Process finished with exit code 0 
    29.   
  
  
  
  29.  */ 
    30.
  • 指数：⭐⭐
  • 场景：中间件开发、设计模式中代理模式和装饰器模式应用
  • 点评：这种JDK自带的类代理方式是非常常用的一种，也是非常简单的一种。基本会在一些中间件代码里看到例如：数据库路由组件、Redis组件等，同时我们也可以使用这样的方式应用到设计模式中。

2. CGLIB代理方式 

 
 
 
 
    
  
  
  
  
  1. public class CglibProxy implements MethodInterceptor { 
    2.   
  
  
  
  2.     public Object newInstall(Object object) { 
    3.   
  
  
  
  3.         return Enhancer.create(object.getClass(), this); 
    4.   
  
  
  
  4.     } 
    5.   
  
  
  
  5.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
    6.   
  
  
  
  6.         System.out.println("我被CglibProxy代理了"); 
    7.   
  
  
  
  7.         return methodProxy.invokeSuper(o, objects); 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9. } 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. @Test 
    12.   
  
  
  
  12. public void test_CglibProxy() throws Exception { 
    13.   
  
  
  
  13.     CglibProxy cglibProxy = new CglibProxy(); 
    14.   
  
  
  
  14.     UserApi userApi = (UserApi) cglibProxy.newInstall(new UserApi()); 
    15.   
  
  
  
  15.     String invoke = userApi.queryUserInfo(); 
    16.   
  
  
  
  16.     logger.info("测试结果：{}", invoke); 
    17.   
  
  
  
  17. } 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19. /** 
    20.   
  
  
  
  20.  * 测试结果： 
    21.   
  
  
  
  21.  *  
    22.   
  
  
  
  22.  * queryUserInfo 你被代理了，By CglibProxy！ 
    23.   
  
  
  
  23.  * 19:55:47.319 [main] INFO  org.itstack.interview.test.ApiTest - 测试结果：  沉淀、分享、成长，让自己和他人都能有所收获！ 
    24.   
  
  
  
  24.  * 
    25.   
  
  
  
  25.  * Process finished with exit code 0 
    26.   
  
  
  
  26.  */ 
    27.
  • 场景：Spring、AOP切面、鉴权服务、中间件开发、RPC框架等
  • 点评：CGLIB不同于JDK，它的底层使用ASM字节码框架在类中修改指令码实现代理，所以这种代理方式也就不需要像JDK那样需要接口才能代理。同时得益于字节码框架的使用，所以这种代理方式也会比使用JDK代理的方式快1.5~2.0倍。

3. ASM代理方式

 
 
 
 
    
  
  
  
  
  1. public class ASMProxy extends ClassLoader { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static  T getProxy(Class clazz) throws Exception { 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.         ClassReader classReader = new ClassReader(clazz.getName()); 
    6.   
  
  
  
  6.         ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS); 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.         classReader.accept(new ClassVisitor(ASM5, classWriter) { 
    9.   
  
  
  
  9.             @Override 
    10.   
  
  
  
  10.             public MethodVisitor visitMethod(int access, final String name, String descriptor, String signature, String[] exceptions) { 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.                 // 方法过滤 
    13.   
  
  
  
  13.                 if (!"queryUserInfo".equals(name)) 
    14.   
  
  
  
  14.                     return super.visitMethod(access, name, descriptor, signature, exceptions); 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.                 final MethodVisitor methodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.                 return new AdviceAdapter(ASM5, methodVisitor, access, name, descriptor) { 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.                     @Override 
    21.   
  
  
  
  21.                     protected void onMethodEnter() { 
    22.   
  
  
  
  22.                         // 执行指令；获取静态属性 
    23.   
  
  
  
  23.                         methodVisitor.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); 
    24.   
  
  
  
  24.                         // 加载常量 load constant 
    25.   
  
  
  
  25.                         methodVisitor.visitLdcInsn(name + " 你被代理了，By ASM！"); 
    26.   
  
  
  
  26.                         // 调用方法 
    27.   
  
  
  
  27.                         methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false); 
    28.   
  
  
  
  28.                         super.onMethodEnter(); 
    29.   
  
  
  
  29.                     } 
    30.   
  
  
  
  30.                 }; 
    31.   
  
  
  
  31.             } 
    32.   
  
  
  
  32.         }, ClassReader.EXPAND_FRAMES); 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.         byte[] bytes = classWriter.toByteArray(); 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36.         return (T) new ASMProxy().defineClass(clazz.getName(), bytes, 0, bytes.length).newInstance(); 
    37.   
  
  
  
  37.     } 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39. } 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41. @Test 
    42.   
  
  
  
  42. public void test_ASMProxy() throws Exception { 
    43.   
  
  
  
  43.     IUserApi userApi = ASMProxy.getProxy(UserApi.class); 
    44.   
  
  
  
  44.     String invoke = userApi.queryUserInfo(); 
    45.   
  
  
  
  45.     logger.info("测试结果：{}", invoke); 
    46.   
  
  
  
  46. } 
    47.   
  
  
  
  47.  
    48.   
  
  
  
  48. /** 
    49.   
  
  
  
  49.  * 测试结果： 
    50.   
  
  
  
  50.  *  
    51.   
  
  
  
  51.  * queryUserInfo 你被代理了，By ASM！ 
    52.   
  
  
  
  52.  * 20:12:26.791 [main] INFO  org.itstack.interview.test.ApiTest - 测试结果： 沉淀、分享、成长，让自己和他人都能有所收获！ 
    53.   
  
  
  
  53.  * 
    54.   
  
  
  
  54.  * Process finished with exit code 0 
    55.   
  
  
  
  55.  */ 
    56.
  • 场景：全链路监控、破解工具包、CGLIB、Spring获取类元数据等
  • 点评：这种代理就是使用字节码编程的方式进行处理，它的实现方式相对复杂，而且需要了解Java虚拟机规范相关的知识。因为你的每一步代理操作，都是在操作字节码指令，例如：Opcodes.GETSTATIC、Opcodes.INVOKEVIRTUAL，除了这些还有小200个常用的指令。但这种最接近底层的方式，也是最快的方式。所以在一些使用字节码插装的全链路监控中，会非常常见。

4. Byte-Buddy代理方式

 
 
 
 
    
  
  
  
  
  1. public class ByteBuddyProxy { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static  T getProxy(Class clazz) throws Exception { 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.         DynamicType.Unloaded dynamicType = new ByteBuddy() 
    6.   
  
  
  
  6.                 .subclass(clazz) 
    7.   
  
  
  
  7.                 .method(ElementMatchers.named("queryUserInfo")) 
    8.   
  
  
  
  8.                 .intercept(MethodDelegation.to(InvocationHandler.class)) 
    9.   
  
  
  
  9.                 .make(); 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11.         return (T) dynamicType.load(Thread.currentThread().getContextClassLoader()).getLoaded().newInstance(); 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14. } 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16. @RuntimeType 
    17.   
  
  
  
  17. public static Object intercept(@Origin Method method, @AllArguments Object[] args, @SuperCall Callable callable) throws Exception { 
    18.   
  
  
  
  18.     System.out.println(method.getName() + " 你被代理了，By Byte-Buddy！"); 
    19.   
  
  
  
  19.     return callable.call(); 
    20.   
  
  
  
  20. } 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22. @Test 
    23.   
  
  
  
  23. public void test_ByteBuddyProxy() throws Exception { 
    24.   
  
  
  
  24.     IUserApi userApi = ByteBuddyProxy.getProxy(UserApi.class); 
    25.   
  
  
  
  25.     String invoke = userApi.queryUserInfo(); 
    26.   
  
  
  
  26.     logger.info("测试结果：{}", invoke); 
    27.   
  
  
  
  27. } 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29. /** 
    30.   
  
  
  
  30.  * 测试结果： 
    31.   
  
  
  
  31.  *  
    32.   
  
  
  
  32.  * queryUserInfo 你被代理了，By Byte-Buddy！ 
    33.   
  
  
  
  33.  * 20:19:44.498 [main] INFO  org.itstack.interview.test.ApiTest - 测试结果： 沉淀、分享、成长，让自己和他人都能有所收获！ 
    34.   
  
  
  
  34.  * 
    35.   
  
  
  
  35.  * Process finished with exit code 0 
    36.   
  
  
  
  36.  */ 
    37.
  • 场景：AOP切面、类代理、组件、监控、日志
  • 点评：Byte Buddy 也是一个字节码操作的类库，但 Byte Buddy 的使用方式更加简单。无需理解字节码指令，即可使用简单的 API 就能很容易操作字节码，控制类和方法。比起JDK动态代理、cglib，Byte Buddy在性能上具有一定的优势。「另外」，2015年10月，Byte Buddy被 Oracle 授予了 Duke's Choice大奖。该奖项对Byte Buddy的“ Java技术方面的巨大创新 ”表示赞赏。

5. Javassist代理方式 

 
 
 
 
    
  
  
  
  
  1. public class JavassistProxy extends ClassLoader { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static  T getProxy(Class clazz) throws Exception { 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.         ClassPool pool = ClassPool.getDefault(); 
    6.   
  
  
  
  6.         // 获取类 
    7.   
  
  
  
  7.         CtClass ctClass = pool.get(clazz.getName()); 
    8.   
  
  
  
  8.         // 获取方法 
    9.   
  
  
  
  9.         CtMethod ctMethod = ctClass.getDeclaredMethod("queryUserInfo"); 
    10.   
  
  
  
  10.         // 方法前加强 
    11.   
  
  
  
  11.         ctMethod.insertBefore("{System.out.println(\"" + ctMethod.getName() + " 你被代理了，By Javassist\");}"); 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.         byte[] bytes = ctClass.toBytecode(); 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.         return (T) new JavassistProxy().defineClass(clazz.getName(), bytes, 0, bytes.length).newInstance(); 
    16.   
  
  
  
  16.     } 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18. } 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20. @Test 
    21.   
  
  
  
  21. public void test_JavassistProxy() throws Exception { 
    22.   
  
  
  
  22.     IUserApi userApi = JavassistProxy.getProxy(UserApi.class) 
    23.   
  
  
  
  23.     String invoke = userApi.queryUserInfo(); 
    24.   
  
  
  
  24.     logger.info("测试结果：{}", invoke); 
    25.   
  
  
  
  25. } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. /** 
    28.   
  
  
  
  28.  * 测试结果： 
    29.   
  
  
  
  29.  *  
    30.   
  
  
  
  30.  * queryUserInfo 你被代理了，By Javassist 
    31.   
  
  
  
  31.  * 20:23:39.139 [main] INFO  org.itstack.interview.test.ApiTest - 测试结果： 沉淀、分享、成长，让自己和他人都能有所收获！ 
    32.   
  
  
  
  32.  * 
    33.   
  
  
  
  33.  * Process finished with exit code 0 
    34.   
  
  
  
  34.  */ 
    35.
  • 场景：全链路监控、类代理、AOP
  • 点评：Javassist 是一个使用非常广的字节码插装框架，几乎一大部分非入侵的全链路监控都是会选择使用这个框架。因为它不想ASM那样操作字节码导致风险，同时它的功能也非常齐全。另外，这个框架即可使用它所提供的方式直接编写插装代码，也可以使用字节码指令进行控制生成代码，所以综合来看也是一个非常不错的字节码框架。

四、总结

  • 代理的实际目的就是通过一些技术手段，替换掉原有的实现类或者给原有的实现类注入新的字节码指令。而这些技术最终都会用到一些框架应用、中间件开发以及类似非入侵的全链路监控中。
  • 一个技术栈深度的学习能让你透彻的了解到一些基本的根本原理，通过这样的学习可以解惑掉一些似懂非懂的疑问，也可以通过这样技术的拓展让自己有更好的工作机会和薪资待遇。
  • 这些技术学起来并不会很容易，甚至可能还有一些烧脑。但每一段值得深入学习的技术都能帮助你突破一定阶段的技术瓶颈。

网站名称：除了JDK、CGLIB，还有3种类代理方式
网页URL：http://www.mswzjz.cn/qtweb/news4/152204.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

全网营销推广知识

行业网站建设

简阳网站建设　　 　鑫友邦火锅桌　　 　微信公众号开发　　 　丹棱网站建设　　 　成都网站营销推广　　 　四川盐亭做网站　　 　微信小程序　　 　营销型网站建设　　 　广告品牌策划设计　　 　成都包装设计公司　　 　盐亭网站设计　　 　成都雨棚定制　　 　成都西信服务器托管　　 　品牌网站建设　　 　服务器托管　　 　成都网站建设哪家好　　 　香港云服务器租用　　 　工程造价　　 　商标注册　　 　成都水电改造