JDK动态代理基于拦截器和反射来实现，不需要第三方库支持的，只需要JDK环境就可以进行代理，使用条件：
- 实现InvocationHandler接口实现代理逻辑；
- 使用Proxy.newProxyInstance产生代理对象；
- 被代理的类必须要实现接口；
jdk动态代理示例：
1、使用JDK动态代理的五大步骤：
- 通过实现InvocationHandler接口来自定义自己的InvocationHandler；
- 通过Proxy.getProxyClass获得动态代理类；
- 通过反射机制获得代理类的构造方法，方法签名为getConstructor(InvocationHandler.class)；
- 通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入；
- 通过代理对象调用目标方法；
1）接口：
package cn.nuc.edu.LogTest.proxy;
public interface IHello {
void sayHello();
}
2）实现类：
package cn.nuc.edu.LogTest.proxy;
public class Hello implements IHello{
@Override
public void sayHello() {
System.out.println("hello world...");
}
}
3）InvocationHandler接口实现：
package cn.nuc.edu.LogTest.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
System.out.println("before...");
Object retureval = method.invoke(target, args);
System.out.println("after...");
return retureval;
}
}4）测试：
package cn.nuc.edu.LogTest.proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class MyProxyTest {
public static void main(String...strings) throws Exception {
// 1、生成$Proxy0的class文件
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
// 2、获取动态代理类
Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
// 3、获得代理类的构造函数，并传入参数类型InvocationHandler.class
Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
// 4、通过构造函数来创建动态代理对象，将自定义的InvocationHandler实例传入
IHello iHello1 = (IHello) constructor.newInstance(new MyInvocationHandler(new Hello()));
// 5、通过代理对象调用目标方法
iHello1.sayHello();
// ==========================第二种=============================
/**
* Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象，
*其方法签名为：newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h)
*/
IHello iHello2 = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), // 加载接口的类加载器
new Class[]{IHello.class}, // 一组接口
new MyInvocationHandler(new Hello())); // 自定义的InvocationHandler
iHello2.sayHello();
}
}
分析：从下面反编译代理类可知，代理类继承Proxy并实现IHello接口的sayHello方法，有一个构造函数且参数为InvocationHandler类型。
所以，我们可以通过Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);方法获取代理类的Class对象，然后在获取对应的构造函数，进而创建代理类对象。
2、jdk动态代理生成.class文件：
1）方法一：
配置系统属性sun.misc.ProxyGenerator.saveGeneratedFile为true
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
2）方法二：
JDK提供了sun.misc.ProxyGenerator.generateProxyClass(String proxyName,class[] interfaces) 底层方法来产生动态代理类的字节码。
package cn.nuc.edu.LogTest.proxy;
import java.io.FileOutputStream;
import java.io.IOException;
import sun.misc.ProxyGenerator;
public class ProxyUtils {
public static void generateClassFile(Class clazz, String proxyName) {
//根据类信息和提供的代理类名称，生成字节码
byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
String paths = "D:\\";
FileOutputStream out = null;
try {
out = new FileOutputStream(paths + proxyName + ".class");//保存到硬盘中
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
测试：
public class ProxyUtilsTest {
public static void main(String...strings) {
IHello hello = new Hello();//实现IHello接口
ProxyUtils.generateClassFile(hello.getClass(), "HelloProxy");
}
}反编译查看生成的HelloProxy.class：
import cn.nuc.edu.LogTest.proxy.IHello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class HelloProxy extends Proxy implements IHello {
private static Method m3;
private static Method m1;
private static Method m0;
private static Method m2;
static {
try {
m3 = Class.forName("cn.nuc.edu.LogTest.proxy.IHello").getMethod("sayHello", new Class[0]);
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
return;
} catch (NoSuchMethodException localNoSuchMethodException) {
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
} catch (ClassNotFoundException localClassNotFoundException) {
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
public HelloProxy(InvocationHandler paramInvocationHandler) throws {
super(paramInvocationHandler);
}
public final void sayHello() throws {
try {
this.h.invoke(this, m3, null);
return;
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final boolean equals(Object paramObject) throws {
try {
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode() throws {
try {
return ((Integer)this.h.invoke(this, m0, null)).intValue();
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString() throws {
try {
return (String)this.h.invoke(this, m2, null);
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
}
源码分析
1、以Proxy.newProxyInstance()方法为切入点来剖析代理类的生成及代理方法的调用：
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException {
if (h == null) {
throw new NullPointerException();
}
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//生成代理类Class对象
Class<?> cl = getProxyClass0(loader, intfs);
//创建代理类的对象
try {
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
return newInstance(cons, ih);
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
}
}该方法完成以下三步：
- 生成代理类：Class<?> cl = getProxyClass0(loader, intfs);
- 获取构造器：final Constructor<?> cons = cl.getConstructor(constructorParams);
- 生成代理对象：cons.newInstance(new Object[]{h});
可以看出来，以上三步最关键的方法是getProxyClass0，获取代理类的Class对象。
2）getProxyClass0方法：
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {//接口数不得超过65535个
throw new IllegalArgumentException("interface limit exceeded");
}
//如果缓存中有代理类了直接返回，否则将由代理类工厂ProxyClassFactory创建代理类
return proxyClassCache.get(loader, interfaces);
}3）get方法：
public V get(K key, P parameter) {//key是ClassLoader，parameter是接口数组，
// 检查指定类型的对象引用不为空null。当参数为null时，抛出空指针异常。
Objects.requireNonNull(parameter);
//清除已经被GC回收的弱引用
expungeStaleEntries();
//将ClassLoader包装成CacheKey, 作为一级缓存的key
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install 二级缓存
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
//根据代理类实现的接口数组来生成二级缓存key
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {// 这个循环提供了轮询机制, 如果条件为假就继续重试直到条件为真为止
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get();
if (value != null) {
return value;
}
}
// lazily construct a Factory
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
} else {// 期间可能其他线程修改了值, 那么就将原先的值替换
if (valuesMap.replace(subKey, supplier, factory)) {
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
} else {
// retry with current supplier
supplier = valuesMap.get(subKey);
}
}
}
}4）apply方法：
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
//验证指定的类加载器(loader)加载接口所得到的Class对象(interfaceClass)是否与intf对象相同
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // 代理类的全限定名
//验证所有非公共的接口在同一个包内
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//Choose a name for the proxy class to generate.
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//Generate the specified proxy class.
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
try {
return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}5）ProxyGenerator.generateProxyClass()方法：
private byte[] generateClassFile() {
//Step 1:Assemble ProxyMethod objects for all methods to generate proxy dispatching code for.
this.addProxyMethod(hashCodeMethod, Object.class);
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
// 获得所有接口中的所有方法，并将方法添加到代理方法中
for (Class<?> intf : interfaces) {
for (Method m : intf.getMethods()) {
addProxyMethod(m, intf);
}
}
//Step 2:生成字段信息和方法信息
try {
methods.add(generateConstructor()); // 生成代理类的构造函数
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
// add static field for method's Method object
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;",
ACC_PRIVATE | ACC_STATIC));
// 生成代理类的代理方法
methods.add(pm.generateMethod());
}
}
// 为代理类生成静态代码块，对一些字段进行初始化
methods.add(generateStaticInitializer());
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception", e);
}
if (methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
}
if (fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
}
//Step 3: 编写最终类文件
//在开始编写最终类文件之前，确保为下面的项目保留常量池索引。
cp.getClass(dotToSlash(className));
cp.getClass(superclassName);
for (Class<?> intf: interfaces) {
cp.getClass(dotToSlash(intf.getName()));
}
/*
* Disallow new constant pool additions beyond this point, since we are about to write the final constant pool table.
* 设置只读，在这之前不允许在常量池中增加信息，因为要写常量池表
*/
cp.setReadOnly();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
try {
dout.writeInt(0xCAFEBABE);// u4 magic;
dout.writeShort(CLASSFILE_MINOR_VERSION);// u2 次要版本;
dout.writeShort(CLASSFILE_MAJOR_VERSION);// u2 主版本
cp.write(dout); // (write constant pool)
dout.writeShort(accessFlags);// u2 访问标识;
dout.writeShort(cp.getClass(dotToSlash(className)));// u2 本类名;
dout.writeShort(cp.getClass(superclassName));// u2 父类名;
dout.writeShort(interfaces.length);// u2 接口;
// u2 interfaces[interfaces_count];
for (Class<?> intf : interfaces) {
dout.writeShort(cp.getClass(
dotToSlash(intf.getName())));
}
dout.writeShort(fields.size());// u2 字段;
// field_info fields[fields_count];
for (FieldInfo f : fields) {
f.write(dout);
}
dout.writeShort(methods.size());// u2 方法;
// method_info methods[methods_count];
for (MethodInfo m : methods) {
m.write(dout);
}
// u2 类文件属性：对于代理类来说没有类文件属性;
dout.writeShort(0); // (no ClassFile attributes for proxy classes)
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception", e);
}
return bout.toByteArray();
}2、分析：
从反编译后的代理类源码看：$Proxy0类继承了Proxy类，同时实现了IHello接口，即代理类接口，所以才能强制将代理对象转换为IHello接口，然后调用$Proxy0中的sayHello()方法。
$Proxy0中sayHello()源码：
public final void sayHello() throws {
try {
this.h.invoke(this, m3, null);
return;
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
- this就是$Proxy0对象；
- m3就是m3 = Class.forName("com.jpeony.spring.proxy.jdk.IHello").getMethod("sayHello", new Class[0]);即是通过全路径名，反射获取的目标对象中的真实方法加参数
- h就是Proxy类中的变量protected InvocationHandler h;
所以成功的调到了InvocationHandler中的invoke()方法，但是invoke()方法在我们自定义的MyInvocationHandler中实现：
@Override
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
System.out.println("before...");
Object retureval = method.invoke(target, args);
System.out.println("after...");
return retureval;
}绕了半天，终于调用到了MyInvocationHandler中的invoke()方法，从上面的this.h.invoke(this, m3, null); 可以看出，MyInvocationHandler中invoke第一个参数为$Proxy0（代理对象），第二个参数为目标类的真实方法，第三个参数为目标方法参数，因为sayHello()没有参数，所以是null。
到这里，我们真正的实现了通过代理调用目标对象的完全分析。
参考：