利用Javassist 实现动态代理

最新推荐文章于 2024-07-08 21:02:47 发布
最新推荐文章于 2024-07-08 21:02:47 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linshizhan/article/details/8187146
版权
   一提到jdk中的java.lang.reflect.Proxy，用过spring，hibernate等框架的人应该都有所了解，对！就是动态代理。AOP - 面向切面编程 - 就是基于动态代理实现的。

平日里项目中用spring aop框架进行日志拦截和声明式事务处理确实很方便好用，从另一种角度将代码解耦，极大的提高了代码的灵活性和可扩展性，在获益的同时我们不得不惊叹aop框架的神奇，但是静下心来想一想：它的核心 - 动态代理 - 其实是依靠运行时动态在内存中实现要代理的接口，并在所有接口的方法实现中反射java.lang.reflect.InvocationHandler的invoke方法；所以要用动态代理就必须先实现自己的InvocationHandler；返回给用户的是代理对象本身，而非接口的原有实现。

想明白了代理的本质，实现它就很容易了，我们可以借助开源的动态生成字节码/类的项目，如：

Byte Code Engineering Library (BCEL) - 在实际的JVM 指令层次上进行操作，提供在运行时在内存中动态生成类的支持

Javassist - 提供类似BCEL的功能，不过它更强调源代码级别的工作，对于程序员来说更加容易上手

好了，废话不多说了，现在看看我用Javassist实现的动态代理，提供接近java.lang.reflect.Proxy的功能

Java代码 复制代码 收藏代码
  1. package com.cuishen.myAop;
  3. import java.lang.reflect.Method;
  5. import javassist.CannotCompileException;
  6. import javassist.ClassPool;
  7. import javassist.CtClass;
  8. import javassist.NotFoundException;
  9. import javassist.CtMethod;
  10. import javassist.CtNewMethod;
  12. /**
  13. * 基于javassist实现的动态代理类，即在运行时在内存中动态生成要代理的接口的实现，并在接口的方法实现中反射
  14. * com.cuishen.myAop.InterceptorHandler（拦截器接口）的invoke方法，所以在使用本代理之前请先实现
  15. * 拦截器接口。本代理提供接近java.lang.reflect.Proxy的功能
  16. * @author cuishen
  17. * @version 1.0
  18. * @see com.cuishen.myAop.InterceptorHandler
  19. * @see java.lang.reflect.Proxy
  20. */
  21. public class MyProxyImpl {
  22. /** 动态代理类的类名后缀 */
  23. private final static String PROXY_CLASS_NAME_SUFFIX = "$MyProxy_";
  24. /** 拦截器接口 */
  25. private final static String INTERCEPTOR_HANDLER_INTERFACE = "com.cuishen.myAop.InterceptorHandler";
  26. /** 动态代理类的类名索引，防止类名重复 */
  27. private static int proxyClassIndex = 1;
  29. /**
  30. * 暴露给用户的动态代理接口，返回某个接口的动态代理对象，注意本代理实现需和com.cuishen.myAop.InterceptorHandler拦截器配合
  31. * 使用，即用户要使用本动态代理，需先实现com.cuishen.myAop.InterceptorHandler拦截器接口
  32. * <br>
  33. * 使用方法如下:
  34. * <br>
  35. * <code>
  36. * StudentInfoService studentInfo = (StudentInfoService)MyProxyImpl.newProxyInstance(String, String, String);
  37. * <br>studentInfo.方法调用;
  38. * </code>
  39. * @param interfaceClassName String 要动态代理的接口类名, e.g test.StudentInfoService
  40. * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
  41. * @param interceptorHandlerImplClassName String 用户提供的拦截器接口的实现类的类名
  42. * @return Object 返回某个接口的动态代理对象
  43. * @throws InstantiationException
  44. * @throws IllegalAccessException
  45. * @throws NotFoundException
  46. * @throws CannotCompileException
  47. * @throws ClassNotFoundException
  48. * @see com.cuishen.myAop.InterceptorHandler
  49. */
  50. public static Object newProxyInstance(String interfaceClassName, String classToProxy, String interceptorHandlerImplClassName) throws InstantiationException, IllegalAccessException, NotFoundException, CannotCompileException, ClassNotFoundException {
  51. Class interfaceClass = Class.forName(interfaceClassName);
  52. Class interceptorHandlerImplClass = Class.forName(interceptorHandlerImplClassName);
  53. return dynamicImplementsInterface(classToProxy, interfaceClass, interceptorHandlerImplClass);
  54. }
  56. /**
  57. * 动态实现要代理的接口
  58. * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
  59. * @param interfaceClass Class 要动态代理的接口类, e.g test.StudentInfoService
  60. * @param interceptorHandlerImplClass Class 用户提供的拦截器接口的实现类
  61. * @return Object 返回某个接口的动态代理对象
  62. * @throws NotFoundException
  63. * @throws CannotCompileException
  64. * @throws InstantiationException
  65. * @throws IllegalAccessException
  66. */
  67. private static Object dynamicImplementsInterface(String classToProxy, Class interfaceClass, Class interceptorHandlerImplClass) throws NotFoundException, CannotCompileException, InstantiationException, IllegalAccessException {
  68. ClassPool cp = ClassPool.getDefault();
  69. String interfaceName = interfaceClass.getName();
  70. //动态指定代理类的类名
  71. String proxyClassName = interfaceName + PROXY_CLASS_NAME_SUFFIX + proxyClassIndex++;
  72. //要实现的接口的包名+接口名
  73. String interfaceNamePath = interfaceName;
  75. CtClass ctInterface = cp.getCtClass(interfaceNamePath);
  76. CtClass cc = cp.makeClass(proxyClassName);
  77. cc.addInterface(ctInterface);
  78. Method [] methods = interfaceClass.getMethods();
  79. for(int i = 0; i < methods.length; i++) {
  80. Method method = methods[i];
  81. dynamicImplementsMethodsFromInterface(classToProxy, cc, method, interceptorHandlerImplClass, i);
  82. }
  83. return (Object)cc.toClass().newInstance();
  84. }
  86. /**
  87. * 动态实现接口里的方法
  88. * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
  89. * @param implementer CtClass 动态代理类的包装
  90. * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装
  91. * @param interceptorClass Class 用户提供的拦截器实现类
  92. * @param methodIndex int 要实现的方法的索引
  93. * @throws CannotCompileException
  94. */
  95. private static void dynamicImplementsMethodsFromInterface(String classToProxy, CtClass implementer, Method methodToImpl, Class interceptorClass, int methodIndex) throws CannotCompileException {
  96. String methodCode = generateMethodCode(classToProxy, methodToImpl, interceptorClass, methodIndex);
  97. CtMethod cm = CtNewMethod.make(methodCode, implementer);
  98. implementer.addMethod(cm);
  99. }
  101. /**
  102. * 动态组装方法体，当然代理里面的方法实现并不是简单的方法拷贝，而是反射调用了拦截器里的invoke方法，并将接收到的参数进行传递
  103. * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
  104. * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装
  105. * @param interceptorClass Class 用户提供的拦截器实现类
  106. * @param methodIndex int 要实现的方法的索引
  107. * @return String 动态组装的方法的字符串
  108. */
  109. private static String generateMethodCode(String classToProxy, Method methodToImpl, Class interceptorClass, int methodIndex) {
  110. String methodName = methodToImpl.getName();
  111. String methodReturnType = methodToImpl.getReturnType().getName();
  112. Class []parameters = methodToImpl.getParameterTypes();
  113. Class []exceptionTypes = methodToImpl.getExceptionTypes();
  114. StringBuffer exceptionBuffer = new StringBuffer();
  115. //组装方法的Exception声明
  116. if(exceptionTypes.length > 0) exceptionBuffer.append(" throws ");
  117. for(int i = 0; i < exceptionTypes.length; i++) {
  118. if(i != exceptionTypes.length - 1) exceptionBuffer.append(exceptionTypes[i].getName()).append(",");
  119. else exceptionBuffer.append(exceptionTypes[i].getName());
  120. }
  121. StringBuffer parameterBuffer = new StringBuffer();
  122. //组装方法的参数列表
  123. for(int i = 0; i < parameters.length; i++) {
  124. Class parameter = parameters[i];
  125. String parameterType = parameter.getName();
  126. //动态指定方法参数的变量名
  127. String refName = "a" + i;
  128. if(i != parameters.length - 1) parameterBuffer.append(parameterType).append(" " + refName).append(",");
  129. else parameterBuffer.append(parameterType).append(" " + refName);
  130. }
  131. StringBuffer methodDeclare = new StringBuffer();
  132. //方法声明，由于是实现接口的方法，所以是public
  133. methodDeclare.append("public ").append(methodReturnType).append(" ").append(methodName).append("(").append(parameterBuffer).append(")").append(exceptionBuffer).append(" {\n");
  134. String interceptorImplName = interceptorClass.getName();
  135. //方法体
  136. methodDeclare.append(INTERCEPTOR_HANDLER_INTERFACE).append(" interceptor = new ").append(interceptorImplName).append("();\n");
  137. //反射调用用户的拦截器接口
  138. methodDeclare.append("Object returnObj = interceptor.invoke(Class.forName(\"" + classToProxy + "\").newInstance(), Class.forName(\"" + classToProxy + "\").getMethods()[" + methodIndex + "], ");
  139. //传递方法里的参数
  140. if(parameters.length > 0) methodDeclare.append("new Object[]{");
  141. for(int i = 0; i < parameters.length; i++) {
  142. //($w) converts from a primitive type to the corresponding wrapper type: e.g.
  143. //Integer i = ($w)5;
  144. if(i != parameters.length - 1) methodDeclare.append("($w)a" + i + ",");
  145. else methodDeclare.append("($w)a" + i);
  146. }
  147. if(parameters.length > 0) methodDeclare.append("});\n");
  148. else methodDeclare.append("null);\n");
  149. //对调用拦截器的返回值进行包装
  150. if(methodToImpl.getReturnType().isPrimitive()) {
  151. if(methodToImpl.getReturnType().equals(Boolean.TYPE)) methodDeclare.append("return ((Boolean)returnObj).booleanValue();\n");
  152. else if(methodToImpl.getReturnType().equals(Integer.TYPE)) methodDeclare.append("return ((Integer)returnObj).intValue();\n");
  153. else if(methodToImpl.getReturnType().equals(Long.TYPE)) methodDeclare.append("return ((Long)returnObj).longValue();\n");
  154. else if(methodToImpl.getReturnType().equals(Float.TYPE)) methodDeclare.append("return ((Float)returnObj).floatValue();\n");
  155. else if(methodToImpl.getReturnType().equals(Double.TYPE)) methodDeclare.append("return ((Double)returnObj).doubleValue();\n");
  156. else if(methodToImpl.getReturnType().equals(Character.TYPE)) methodDeclare.append("return ((Character)returnObj).charValue();\n");
  157. else if(methodToImpl.getReturnType().equals(Byte.TYPE)) methodDeclare.append("return ((Byte)returnObj).byteValue();\n");
  158. else if(methodToImpl.getReturnType().equals(Short.TYPE)) methodDeclare.append("return ((Short)returnObj).shortValue();\n");
  159. } else {
  160. methodDeclare.append("return (" + methodReturnType + ")returnObj;\n");
  161. }
  162. methodDeclare.append("}");
  163. System.out.println(methodDeclare.toString());
  164. return methodDeclare.toString();
  165. }
  167. } 
package com.cuishen.myAop;

import java.lang.reflect.Method;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;
import javassist.CtMethod;
import javassist.CtNewMethod;

/**
 * 基于javassist实现的动态代理类，即在运行时在内存中动态生成要代理的接口的实现，并在接口的方法实现中反射
 * com.cuishen.myAop.InterceptorHandler（拦截器接口）的invoke方法，所以在使用本代理之前请先实现
 * 拦截器接口。本代理提供接近java.lang.reflect.Proxy的功能
 * @author cuishen
 * @version 1.0
 * @see com.cuishen.myAop.InterceptorHandler
 * @see java.lang.reflect.Proxy
 */
public class MyProxyImpl {
	/** 动态代理类的类名后缀 */
	private final static String PROXY_CLASS_NAME_SUFFIX = "$MyProxy_";
	/** 拦截器接口 */
	private final static String INTERCEPTOR_HANDLER_INTERFACE = "com.cuishen.myAop.InterceptorHandler";
	/** 动态代理类的类名索引，防止类名重复 */
	private static int proxyClassIndex = 1;
	
	/**
	 * 暴露给用户的动态代理接口，返回某个接口的动态代理对象，注意本代理实现需和com.cuishen.myAop.InterceptorHandler拦截器配合
	 * 使用，即用户要使用本动态代理，需先实现com.cuishen.myAop.InterceptorHandler拦截器接口
	 * <br>
	 * 使用方法如下:
	 * <br>
	 * <code>
	 * StudentInfoService studentInfo = (StudentInfoService)MyProxyImpl.newProxyInstance(String, String, String);
	 * <br>studentInfo.方法调用;
	 * </code>
	 * @param interfaceClassName String 要动态代理的接口类名, e.g test.StudentInfoService
	 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
	 * @param interceptorHandlerImplClassName String 用户提供的拦截器接口的实现类的类名
	 * @return Object 返回某个接口的动态代理对象
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 * @throws NotFoundException
	 * @throws CannotCompileException
	 * @throws ClassNotFoundException
	 * @see com.cuishen.myAop.InterceptorHandler
	 */
	public static Object newProxyInstance(String interfaceClassName, String classToProxy, String interceptorHandlerImplClassName) throws InstantiationException, IllegalAccessException, NotFoundException, CannotCompileException, ClassNotFoundException {
		Class interfaceClass = Class.forName(interfaceClassName);
		Class interceptorHandlerImplClass = Class.forName(interceptorHandlerImplClassName);
		return dynamicImplementsInterface(classToProxy, interfaceClass, interceptorHandlerImplClass);
	}
	
	/**
	 * 动态实现要代理的接口
	 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
	 * @param interfaceClass Class 要动态代理的接口类, e.g test.StudentInfoService
	 * @param interceptorHandlerImplClass Class 用户提供的拦截器接口的实现类
	 * @return Object 返回某个接口的动态代理对象
	 * @throws NotFoundException
	 * @throws CannotCompileException
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 */
	private static Object dynamicImplementsInterface(String classToProxy, Class interfaceClass, Class interceptorHandlerImplClass) throws NotFoundException, CannotCompileException, InstantiationException, IllegalAccessException {
		ClassPool cp = ClassPool.getDefault();
		String interfaceName = interfaceClass.getName();
		//动态指定代理类的类名
		String proxyClassName = interfaceName + PROXY_CLASS_NAME_SUFFIX + proxyClassIndex++;
		//要实现的接口的包名+接口名
		String interfaceNamePath = interfaceName;
		
		CtClass ctInterface = cp.getCtClass(interfaceNamePath);
		CtClass cc = cp.makeClass(proxyClassName);
		cc.addInterface(ctInterface);
		Method [] methods = interfaceClass.getMethods();
		for(int i = 0; i < methods.length; i++) {
			Method method = methods[i];
			dynamicImplementsMethodsFromInterface(classToProxy, cc, method, interceptorHandlerImplClass, i);
		}
		return (Object)cc.toClass().newInstance();
	}
	
	/**
	 * 动态实现接口里的方法
	 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
	 * @param implementer CtClass 动态代理类的包装
	 * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装
	 * @param interceptorClass Class 用户提供的拦截器实现类
	 * @param methodIndex int 要实现的方法的索引
	 * @throws CannotCompileException
	 */
	private static void dynamicImplementsMethodsFromInterface(String classToProxy, CtClass implementer, Method methodToImpl, Class interceptorClass, int methodIndex) throws CannotCompileException {
		String methodCode = generateMethodCode(classToProxy, methodToImpl, interceptorClass, methodIndex);
		CtMethod cm = CtNewMethod.make(methodCode, implementer);
		implementer.addMethod(cm);
	}
	
	/**
	 * 动态组装方法体，当然代理里面的方法实现并不是简单的方法拷贝，而是反射调用了拦截器里的invoke方法，并将接收到的参数进行传递
	 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
	 * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装
	 * @param interceptorClass Class 用户提供的拦截器实现类
	 * @param methodIndex int 要实现的方法的索引
	 * @return String 动态组装的方法的字符串
	 */
	private static String generateMethodCode(String classToProxy, Method methodToImpl, Class interceptorClass, int methodIndex) {
		String methodName = methodToImpl.getName();
		String methodReturnType = methodToImpl.getReturnType().getName();
		Class []parameters = methodToImpl.getParameterTypes();
		Class []exceptionTypes = methodToImpl.getExceptionTypes();
		StringBuffer exceptionBuffer = new StringBuffer();
		//组装方法的Exception声明
		if(exceptionTypes.length > 0) exceptionBuffer.append(" throws ");
		for(int i = 0; i < exceptionTypes.length; i++) {
			if(i != exceptionTypes.length - 1) exceptionBuffer.append(exceptionTypes[i].getName()).append(",");
			else exceptionBuffer.append(exceptionTypes[i].getName());
		}
		StringBuffer parameterBuffer = new StringBuffer();
		//组装方法的参数列表
		for(int i = 0; i < parameters.length; i++) {
			Class parameter = parameters[i];
			String parameterType = parameter.getName();
			//动态指定方法参数的变量名
			String refName = "a" + i;
			if(i != parameters.length - 1) parameterBuffer.append(parameterType).append(" " + refName).append(",");
			else parameterBuffer.append(parameterType).append(" " + refName);
		}
		StringBuffer methodDeclare = new StringBuffer();
		//方法声明，由于是实现接口的方法，所以是public
		methodDeclare.append("public ").append(methodReturnType).append(" ").append(methodName).append("(").append(parameterBuffer).append(")").append(exceptionBuffer).append(" {\n");
		String interceptorImplName = interceptorClass.getName();
		//方法体
		methodDeclare.append(INTERCEPTOR_HANDLER_INTERFACE).append(" interceptor = new ").append(interceptorImplName).append("();\n");
		//反射调用用户的拦截器接口
		methodDeclare.append("Object returnObj = interceptor.invoke(Class.forName(\"" + classToProxy + "\").newInstance(), Class.forName(\"" + classToProxy + "\").getMethods()[" + methodIndex + "], ");
		//传递方法里的参数
		if(parameters.length > 0) methodDeclare.append("new Object[]{"); 
		for(int i = 0; i < parameters.length; i++) {
			//($w) converts from a primitive type to the corresponding wrapper type: e.g.
			//Integer i = ($w)5;
			if(i != parameters.length - 1) methodDeclare.append("($w)a" + i + ",");
			else methodDeclare.append("($w)a" + i);
		}
		if(parameters.length > 0) methodDeclare.append("});\n");
		else methodDeclare.append("null);\n");
		//对调用拦截器的返回值进行包装
		if(methodToImpl.getReturnType().isPrimitive()) {
			if(methodToImpl.getReturnType().equals(Boolean.TYPE)) methodDeclare.append("return ((Boolean)returnObj).booleanValue();\n");
			else if(methodToImpl.getReturnType().equals(Integer.TYPE)) methodDeclare.append("return ((Integer)returnObj).intValue();\n");
			else if(methodToImpl.getReturnType().equals(Long.TYPE)) methodDeclare.append("return ((Long)returnObj).longValue();\n");
			else if(methodToImpl.getReturnType().equals(Float.TYPE)) methodDeclare.append("return ((Float)returnObj).floatValue();\n");
			else if(methodToImpl.getReturnType().equals(Double.TYPE)) methodDeclare.append("return ((Double)returnObj).doubleValue();\n");
			else if(methodToImpl.getReturnType().equals(Character.TYPE)) methodDeclare.append("return ((Character)returnObj).charValue();\n");
			else if(methodToImpl.getReturnType().equals(Byte.TYPE)) methodDeclare.append("return ((Byte)returnObj).byteValue();\n");
			else if(methodToImpl.getReturnType().equals(Short.TYPE)) methodDeclare.append("return ((Short)returnObj).shortValue();\n");
		} else {
			methodDeclare.append("return (" + methodReturnType + ")returnObj;\n");
		}
		methodDeclare.append("}");
		System.out.println(methodDeclare.toString());
		return methodDeclare.toString();
	}
	
}


我也提供了类似于java.lang.reflect.InvocationHandler的接口，我暂且称其为拦截器接口，要用我的代理，就得先实现它

Java代码 复制代码 收藏代码
  1. package com.cuishen.myAop;
  3. import java.lang.reflect.Method;
  5. /**
  6. * 拦截器接口，用户使用com.cuishen.myAop.MyProxyImpl动态代理前，请先实现本接口，
  7. * 在执行动态代理对象的方法时会自动反射到invoke方法，被代理的对象、方法和参数将做为
  8. * 参数传递给invoke方法
  9. * @author cuishen
  10. * @version 1.0
  11. * @see com.cuishen.myAop.MyProxyImpl
  12. */
  13. public interface InterceptorHandler {
  15. /**
  16. * 调用动态代理对象的方法将反射本方法，可在本方法实现中添加类似AOP的事前事后操作，只有在本方法体中加入如下代码
  17. * <br>
  18. * <code>
  19. * Object returnObj = method.invoke(obj, args);
  20. * <br>
  21. * ...
  22. * <br>
  23. * return returnObj;
  24. * </code>
  25. * <br>
  26. * 被代理的方法才会被执行，返回值将返回给代理最后返回给程序
  27. * @param obj Object 被代理的对象
  28. * @param method Method 被代理对象的方法
  29. * @param args Object[] 被代理对象的方法的参数
  30. * @return Object 被代理对象的方法执行后的返回值
  31. * @throws Throwable
  32. */
  33. public Object invoke(Object obj, Method method, Object[] args) throws Throwable;
  34. }  
shizhan1881
关注
专栏目录
JavaAgent:Javassist 与 Asm JavaAgent 字节码动态编程项目
06-03
在这个“JavaAgent: Javassist与Asm JavaAgent字节码动态编程项目”中，我们将深入探讨如何利用Javassist和ASM这两个库来实现JavaAgent。 首先，Javassist是一个开源的Java字节码操作框架，它使得开发者可以在运行...
javassistDemo
10-17
通过它，我们可以在运行时动态生成实现特定接口的代理类，代理类可以在调用目标方法前后插入自定义的行为。 5. **Charles破解**：提到"Charles破解"，这通常指的是使用抓包工具Charles进行网络调试。Charles可以...
Javassist实现JDK动态代理
二进制之路
08-12 299
提到JDK动态代理，相信很多人并不陌生。然而，对于动态代理的实现原理，以及如何编码实现动态代理功能，可能知道的人就比较少了。接下一来，我们就一起来看看JDK动态代理的基本原理，以及如何通过Javassist进行模拟实现。 JDK动态代理 示例 以下是一个基于JDK动态代理的hello world示例，在很多地方都可以看到类似的版本。 public class DynamicProxyT...
Javassist的动态代理实现。
mingxin95的博客
07-02 8258
一提到jdk中的java.lang.reflect.Proxy，用过spring，hibernate等框架的人应该都有所了解，对！就是动态代理。AOP - 面向切面编程 - 就是基于动态代理实现的。 为什么要提代理模式。因为AOP的广泛实现都是通过动态代理，而动态代理又不得不说代理模式。 代理模式，顾名思义，就是对一个类的访问，变为访问这个类的代理人。经由代理再访问这个类。（代理与被代理的类实
代理模式-Javassist动态代理
Leon_Jinhai_Sun的博客
12-24 231
代理模式-Javassist动态代理
Javassist实现动态代理
weixin_39663628的博客
02-25 237
动态代理模式简述：之所以会出现代理这种模式就是因为我们常有这么一种需求：在被代理类的方法调用前后执行一些其它的逻辑，这些逻辑不适合由被代理类来实现，那这些逻辑谁来实现？当然是代理类。那代理类是谁？从哪里来？代理类是我们利用字节码生成工具动态创建的，然后利用反射实例化而得到代理对象。 tips:这篇文章讲的不是动态代理模式的思想而是怎么实现(简单实现)一个和java.lang.reflect.Pr...
业务逻辑动态化：Javassist案例研究与动态代理实现
[业务逻辑动态化：Javassist案例研究与动态代理实现](https://img-blog.csdnimg.cn/6310b5135bab40b1afca39bb374f7e82.png) # 1. 业务逻辑动态化的概念与需求 在现代软件开发中，业务逻辑的动态化已成为提升软件...
javassistDemo.zip
10-19
这个"javassistDemo.zip"压缩包提供了一个示例，展示了如何利用Javaassist库动态修改Java类的方法。在Java应用程序中，这种能力非常有用，特别是在进行AOP（面向切面编程）或者在无法重新编译源代码的情况下需要修改...
javaagent+javassist
12-25
这使得javassist成为单元测试框架、AOP（面向切面编程）和动态代理实现的理想工具。 将`javaagent`与`javassist`结合使用，可以实现强大的功能。例如，我们可以通过javaagent在程序启动时注入javassist生成的代码，...
Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）
04-24
NULL 博文链接：https://bijian1013.iteye.com/blog/2382393
Java Javassist动态代理
Excellent999的博客
09-27 199
【代码】Java Javassist动态代理。
javassist使用并生成动态代理
skh2015java的博客
09-06 946
Javaassist 就是一个用来 处理 Java 字节码的类库。它可以在一个已经编译好的类中添加新的方法，或者是修改已有的方法，并且不需要对字节码方面有深入的了解。同时也可以去生成一个新的类对象，通过完全手动的方式。 首先需要引入jar包： <dependency> <groupId>org.javassist</groupId> <artifactId>javassist</artifactId> &lt...
静态代理与动态代理
weixin_45354445的博客
02-17 211
静态代理 静态代理就是我们自己手写代理类； aspectJ静态代理（编译期生成代理类） 静态代理可以实现在不修改目标对象代码的前提下，对目标对象的功能进行扩展； 静态代理：（目标接口、目标接口实现、代理类） 优点：可以实现不对目标对象进行修改的前提下，对目标对象进行功能的扩展和增强，也就是扩展原功能，不污染原代码。 缺点：因为代理对象，需要实现与目标对象一样的接口，如果目标接口类繁多，也会导致代理类繁多，另外一旦目标接口增加新方法，则代理类也需要维护； 实现方式 /** * 目标接口 * */ pub
用javassist实现简单的动态代理
liuwenjie517333813的专栏
08-05 1699
  网上有网友已经实现了该功能，我只是把我的理解说出来，希望对大家有帮助！       主要思路：创建一个拦截器接口，里面有有一个invoke方法,再创建一个能够生成代理的类，该类的主要作用是生成了一个新类，该新类实现了被代理类接口的每个方法(生成新类的实例时是用javassist)。这个新类里每个方法都通过反射去调用拦截器中的invoke方法，（而invoke方法中我们会去调用被代理类的方法
深入理解JDK动态代理原理，使用javassist动手写一个动态代理框架
秃了也弱了
03-05 746
vm options参数设置-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true，就可以把生成的代理类的源码保存在com.sun.proxy目录下面，或者用arthas来查看运行中的类信息。
Java实现动态代理
最新发布
ZHI_YUE的博客
07-08 593
JAVA动态代理一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式在客户端和目标对象之间起到一个中介的作用（1）功能增强: 基于某个功能，再增加一些功能。（目标类只负责核心功能，其他附属功能通过代理类完成。代理类的方法名与目标类的方法相同，内容不同，在核心功能外加了一些额外逻辑）（2）控制访问: 防止直接访问目标这种模式广泛应用于软件设计中，尤其是在需要延迟加载、访问控制、缓存实现、日志记录、事务管理、远程调用等场景中。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值