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到了吗？
扫一扫
62
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
