JVM动态代理

最新推荐文章于 2022-08-22 16:17:40 发布

qgbihc

最新推荐文章于 2022-08-22 16:17:40 发布

阅读量343

点赞数

分类专栏： java 文章标签： java 后端

本文链接：https://blog.csdn.net/qgbihc/article/details/104393185

版权

java 专栏收录该内容

29 篇文章 4 订阅

订阅专栏

JVM动态代理原理

使用java.lang.reflect.Proxy类动态的根据您指定的接口生成一个class byte，该class会继承Proxy类，并实现所有你指定的接口。
然后再利用指定的classloader将 class byte加载进系统，最后生成这样一个类的实例，并初始化该对象的一些值，如invocationHandler,以及所有的接口对应的Method成员。
初始化之后将对象实例返回给调用的客户端。这样客户端得到一个实现你所有的接口的Proxy对象。
JVM动态生成的类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

实例分析：

接口类

public interface IBusinessProcess {
	public void processBusiness();
}

实现类

public class BusinessProcessImpl implements IBusinessProcess {
	@Override
	public void processBusiness() {
		System.out.println("processing business .....");
	}
}

代理类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class BusinessProcessInvocationHandler implements InvocationHandler {

	private Object target = null;

	public BusinessProcessInvocationHandler(Object target) {
		this.target = target;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("do something before process");
		Object result = method.invoke(target, args);
		System.out.println("do something after process");
		return result;
	}
}

实现了InvocationHandler接口的invoke方法。这个方法就是最终Proxy调用的固定接口方法。当客户端调用Proxy时，它只会调用InvocationHandler的invoke接口，所以我们的真正实现的方法就必须在invoke方法中去调用。

代理测试类

public class Test {

	public static void main(String[] args) {
		BusinessProcessImpl bpimpl = new BusinessProcessImpl();
		BusinessProcessInvocationHandler handler = new BusinessProcessInvocationHandler(bpimpl);

		IBusinessProcess bp = (IBusinessProcess) Proxy.newProxyInstance(IBusinessProcess.class.getClassLoader(),
				new Class<?>[] { IBusinessProcess.class }, handler);
		bp.processBusiness();

	}
}

newProxyInstance方法生成代理类的实例。
三个参数：
loader: 用哪个类加载器去加载代理对象
interfaces:动态代理类需要实现的接口
handler:动态代理方法在执行时，会调用handler里面的invoke方法去执行

执行结果

do something before process
processing business .....
do something after process

分析JVM动态生成的类

Class分析工具类，工具类实现如下功能：
1、列出动态类名称，继承的类名及实现的接口名。
2、列出动态类中的内部变量。
3、列出动态类中所有方法和参数名称。

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public final class ClassUtil {

	public static void printClassDefinition(Class clz) {
		String clzModifier = getModifier(clz.getModifiers());
		if (clzModifier != null && !clzModifier.equals("")) {
			clzModifier = clzModifier + " ";
		}

		String superClz = clz.getSuperclass().getName();
		if (superClz != null && !superClz.equals("")) {
			superClz = "extends " + superClz;
		}

		Class[] interfaces = clz.getInterfaces();
		String inters = "";
		for (int i = 0; i < interfaces.length; i++) {
			if (i == 0) {
				inters += "implements ";
			}
			inters += interfaces[i].getName();
		}

		System.out.println(clzModifier + clz.getName() + " " + superClz + " " + inters);
		System.out.println("{");
		Field[] fields = clz.getDeclaredFields();
		for (int i = 0; i < fields.length; i++) {
			String modifier = getModifier(fields[i].getModifiers());
			if (modifier != null && !modifier.equals("")) {
				modifier = modifier + " ";
			}
			String fieldName = fields[i].getName();
			String fieldType = fields[i].getType().getName();
			System.out.println("  " + modifier + fieldType + " " + fieldName + ";");
		}
		System.out.println();

		Method[] methods = clz.getDeclaredMethods();
		for (int i = 0; i < methods.length; i++) {
			Method method = methods[i];
			String modifier = getModifier(method.getModifiers());
			if (modifier != null && !modifier.equals("")) {
				modifier = modifier + " ";
			}
			String methodName = method.getName();
			Class returnClz = method.getReturnType();
			String retrunType = returnClz.getName();
			Class[] clzs = method.getParameterTypes();
			String paraList = "(";
			for (int j = 0; j < clzs.length; j++) {
				paraList += clzs[j].getName();
				if (j != clzs.length - 1) {
					paraList += ", ";
				}
			}
			paraList += ")";
			clzs = method.getExceptionTypes();
			String exceptions = "";
			for (int j = 0; j < clzs.length; j++) {
				if (j == 0) {
					exceptions += "throws ";
				}
				exceptions += clzs[j].getName();
				if (j != clzs.length - 1) {
					exceptions += ", ";
				}
			}
			exceptions += ";";
			String methodPrototype = modifier + retrunType + " " + methodName + paraList + exceptions;
			System.out.println("  " + methodPrototype);
		}
		System.out.println("}");
	}

	public static String getModifier(int modifier) {
		String result = "";
		switch (modifier) {
		case Modifier.PRIVATE:
			result = "private";
		case Modifier.PUBLIC:
			result = "public";
		case Modifier.PROTECTED:
			result = "protected";
		case Modifier.ABSTRACT:
			result = "abstract";
		case Modifier.FINAL:
			result = "final";
		case Modifier.NATIVE:
			result = "native";
		case Modifier.STATIC:
			result = "static";
		case Modifier.SYNCHRONIZED:
			result = "synchronized";
		case Modifier.STRICT:
			result = "strict";
		case Modifier.TRANSIENT:
			result = "transient";
		case Modifier.VOLATILE:
			result = "volatile";
		case Modifier.INTERFACE:
			result = "interface";
		}
		return result;
	}
}

调用ClassUtil ，输出代理类

ClassUtil.printClassDefinition(bp.getClass());

输出的结果如下：

com.sun.proxy.$Proxy0
  extends java.lang.reflect.Proxy
  implements IBusinessProcess
{
  java.lang.reflect.Method m1;
  java.lang.reflect.Method m2;
  java.lang.reflect.Method m3;
  java.lang.reflect.Method m0;

  boolean equals(java.lang.Object);
  java.lang.String toString();
  int hashCode();
  void processBusiness();
}

可以看出，Proxy.newProxyInstance方法会做如下几件事：

1，根据传入的第二个参数interfaces动态生成一个类，实现interfaces中的接口，该例中即IBusinessProcess接口的processBusiness方法。并且继承了Proxy类，重写了hashcode,toString,equals等三个方法。
2，通过传入的第一个参数classloder将刚生成的类加载到jvm中。即将$Proxy0类load到内存中。
3，利用第三个参数，调用$Proxy0的$Proxy0(InvocationHandler)构造函数创建$Proxy0的对象，并且用interfaces参数遍历其所有接口的方法，并生成Method对象初始化对象的几个Method成员变量
4，将$Proxy0的实例返回给客户端。

AOP面向切面编程

1、面向切面变成同样适用，通过面向切面接口的方式，理解一下代理类的作用。
2、将对象传递给InvocationHandler，在invoke()方法中去执行传递的对象中的方法，这样的话，就能动态的去改变执行的代码了。传递进来的对象就是那个切面，执行切面中的方法，并增加特定的处理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public class AdviceTest {

	public static void main(String[] args) {
		final List<String> target = new ArrayList<String>();
		// 直接一步到位 其实本质还是一样的，只不过写法不一样
		List<String> proxy3 = (List<String>) getProxy(target, new Advice());

		proxy3.add("aaa");
		proxy3.add("bbb");
		proxy3.add("ccc");
		System.out.println(proxy3.size());
	}

	// 直接生成代理类
	private static Object getProxy(final Object target, final Advice advice) {
		Object proxy3 = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

						// 这里就是List类中的方法执行 也就是调用了add()方法 同时我还做了一些其他事情。计算程序运行时间
						advice.beforeMethod(method);
						Object retVal = method.invoke(target, args);
						advice.afterMethod(method);

						return retVal;
					}
				});
		return proxy3;
	}
}

执行结果如下：

Advice中的方法开始执行了。。。
add  running time:0
Advice中的方法结束执行了。。。
Advice中的方法开始执行了。。。
add  running time:0
Advice中的方法结束执行了。。。
Advice中的方法开始执行了。。。
add  running time:0
Advice中的方法结束执行了。。。
Advice中的方法开始执行了。。。
size  running time:0
Advice中的方法结束执行了。。。
3

可以看出我们通过代理类改变了List的Add的处理。

JVM动态代理，你get到了吗？

qgbihc

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JVM动态代理

JVM动态代理使用java.lang.reflect.Proxy类动态的根据您指定的接口生成一个classbyte，该class会继承Proxy类，并实现所有你指定的接口；（您在参数中传入的接口数组）然后再利用指定的classloader将 classbyte加载进系统，最后生成这样一个类的实例，并初始化该对象的一些值，如invocationHandler,以及所有的接口对应的Metho...
复制链接

扫一扫

专栏目录