Java-动态代理
0x01 摘要
我们在看源码的时候，往往能发现很多实用动态代理的例子，本文将对其进行简要介绍。
0x02 概念
在不想直接暴露真实对象，且想再对象的方法前后增加逻辑时可以用代理。
代理类和被代理类实现共同接口，且代理类可以访问被代理类的实际对象，在其方法调用前后增加自定义的逻辑。
代理的好处就是隐藏了真实对象，且可加逻辑处理代码。这一切对客户端来说是无感知的。
0x03 被代理对象和接口
public interface Interface {
void doSomething();
void somethingElse(String arg);
}
class RealObject implements Interface {
@Override
public void doSomething() {
System.out.println("doSomething.");
}
@Override
public void somethingElse(String arg) {
System.out.println("somethingElse " + arg);
}
}
0x04 简陋的代理
代码如下：
class SimpleProxy implements Interface {
private Interface proxy;
public SimpleProxy(Interface proxy) {
this.proxy = proxy;
}
@Override
public void doSomething() {
System.out.println("SimpleProxy doSomething.");
proxy.doSomething();
}
@Override
public void somethingElse(String arg) {
System.out.println("SimpleProxy somethingElse " + arg);
proxy.somethingElse(arg);
}
}
0x05 InvocationHandler实现动态代理< span>
动态代理代码示例如下：
class DynamicProxyHandler implements InvocationHandler {
//要代理的原始对象
private Object proxy;
//传入被代理的对象
public DynamicProxyHandler(Object proxy) {
this.proxy = proxy;
}
/**
* 该invoke方法会在我们对生成的代理类 $ProxyX 调用其方法时调用
* 在代理实例上处理方法调用并返回结果
* @param proxy 生成的代理类 $ProxyX 的实例对象
* @param method 和被代理对象的原始方法代码相同
* @param args 该方法的参数数组
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("method.getDeclaringClass() = "+ method.getDeclaringClass());
// 这一步的作用是为了防止调用继承自Object的方法如 toString hashCode等
// 也就是说，接口创建出的代理对象不仅有接口的方法，还有从Object类继承的方法
if (method.getDeclaringClass()== Object.class) {
// this表示DynamicProxyHandler对象
return method.invoke(this, args);
}
System.out.println("*** proxy: " + proxy.getClass() +
". method: " + method + ". args: " + args);
// 在调用被代理方法前加逻辑
System.out.println("something you need do before invoking");
if(args != null) {
for(Object arg : args)
System.out.println(" " + arg);
}
// 对被代理对象（真实对象）调用方法
Object result = method.invoke(this.proxy, args);
// 在调用被代理方法后加逻辑
System.out.println("something you need do after invoking");
return result;
}
}
0x06 测试代码
客户端调用测试代码如下：
public static void main(String[] args) {
Interface real = new RealObject();
real.doSomething();
real.somethingElse("bonobo");
System.out.println("--------------------------Insert a Simple proxy and call again");
consumer(new SimpleProxy(real));
System.out.println("--------------------------Insert a dynamic proxy and call again");
System.out.println(real.getClass().getInterfaces().length);
System.out.println(new Class[]{ Interface.class }.length);
/**
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class to implement
* @param h the invocation handler to dispatch method invocations to
* @return a proxy instance with the specified invocation handler of a
* proxy class that is defined by the specified class loader
* and that implements the specified interfaces
*/
Interface proxy = (Interface)Proxy.newProxyInstance(
RealObject.class.getClassLoader(),
new Class[]{ Interface.class },
new DynamicProxyHandler(real));
Interface proxy2 = (Interface)Proxy.newProxyInstance(
real.getClass().getClassLoader(),
real.getClass().getInterfaces(),
new DynamicProxyHandler(real));
consumer(proxy2);
}
0x07 JDK动态代理原理分析
7.1 原理
总的来说，就是由ProxyClassFactory底层使用ASM直接操作字节码的方式生成了一个继承自java.lang.reflect.Proxy且实现了目标代理的接口的$ProxyX字节码，并由指定的ClassLoader加载到了JVM中。该$ProxyX中实现了和被代理类相同的方法，但是调用这些方法的时候会调用我们定义的InvocationHandler的invoke方法。这其中就可以在调用真实对象的方法前后加入自定义逻辑。
7.2 源码分析
7.2.1 java.lang.reflect.Proxy
- 重要属性
/**
* proxy类的缓存
* KeyFactory
*/
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
// 构造方法的参数
private static final Class<?>[] constructorParams =
{ InvocationHandler.class };
// 空构造方法
private Proxy() {
}
// InvocationHandler为参数的构造方法
// 会被Proxy子类，动态生成的$ProxyX 构造方法中调用此父Proxy的构造方法
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}
- Proxy.KeyFactory
KeyFactory是一个函数，将接口数组interfaces映射到一个Key
private static final class KeyFactory
implements BiFunction<ClassLoader, Class<?>[], Object>
{
@Override
public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
switch (interfaces.length) {
// 这是最常见的用法，接口数组长度为1
case 1: return new Key1(interfaces[0]);
case 2: return new Key2(interfaces[0], interfaces[1]);
// 长度为0时返回其代表值
case 0: return key0;
default: return new KeyX(interfaces);
}
}
}
- Proxy.Key1
这个类代表interfaces数组长度为1。注意该类继承自WeakReference，且泛型为Class，也就是说该类拥有对某个Class对象的弱引用。
private static final class Key1 extends WeakReference<Class<?>> {
private final int hash;
Key1(Class<?> intf) {
// 将目标Class对象作为弱引用对象，未关联引用队列
super(intf);
// 将Class的hashCode作为该Key1的hashCode
this.hash = intf.hashCode();
}
@Override
public int hashCode() {
return hash;
}
@Override
// 重写equals方法
// 1.对象相等
// 2.1对象class为Key1.class
// 2.2引用对象不为空
// 2.3目标对象的引用和本对象的引用对象相同
public boolean equals(Object obj) {
Class<?> intf;
return this == obj ||
obj != null &&
obj.getClass() == Key1.class &&
(intf = get()) != null &&
intf == ((Key1) obj).get();
}
}
- Proxy.ProxyClassFactory
ProxyClassFactory被用来通过制定的ClassLoader和interfaces，生成、define一个proxy Class，最终返回该Class对象。
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
// 所有proxy Class的名称前缀
private static final String proxyClassNamePrefix = "$Proxy";
// 为每一个proxy Class准备的唯一自增编码
private static final AtomicLong nextUniqueNumber = new AtomicLong();
// 用指定的ClassLoader和interfaces来生成Class对象的方法
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
// 创建一个用来存放interfaceSet的映射表
// IdentityHashMap的特点是比较(key == taget.key)而不是equals
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
// for循环对interfaces数组里的接口类做3个验证
// ClassLoader可见性、是否是接口、未重复
// 然后放入interfaceSet
for (Class<?> intf : interfaces) {
// 下面几步是验证该接口Class是由该ClassLoader加载的
// 其实说白了就是ClassLoader可见性的判断
Class<?> interfaceClass = null;
try {
// 采用指定的ClassLoader来加载该接口类，但不初始化
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
// 对该ClassLoader不可见，抛异常
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
// 验证该Class确实是个接口
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
// 验证该接口不重复，验证通过就放入interfaceSet
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
// 用来define proxy Class的包
String proxyPkg = null;
// 二进制10001, 即17
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
for (Class<?> intf : interfaces) {
// 返回int代表的如
// (public,protected等以及final,static,abstract,interface等修饰符)
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
// 此时代表该类没有声明public
// 那就会将proxyPkg设为包名
// 比如`demos.designPattern.dynamicProxy.`
accessFlags = Modifier.FINAL;
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) {
// 申明了public的代理接口，proxyPkg=`com.sun.proxy.`
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
// 原子地获取当前proxy Class唯一值，并增1
long num = nextUniqueNumber.getAndIncrement();
// public 形如：`com.sun.proxy.$Proxy0`
// 非public 形如`demos.designPattern.dynamicProxy.$Proxy0`
String proxyName = proxyPkg + proxyClassNamePrefix + num;
// 使用接口数组生成指定的proxy 字节码(目前还是byte[])
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// 使用指定ClassLoader、proxyName将该proxyClassFile define为Class对象(这里就已经加载了该代理类$Proxy0)
// 注意，该Class对象实现了我们传入的接口数组定义的方法
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}
- ProxyGenerator.generateProxyClass
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
// 这一步会利用ASM直接操作字节码来生成我们的代理类$Proxy0
final byte[] var4 = var3.generateClassFile();
// 这里就是根据我们配置的sun.misc.ProxyGenerator.saveGeneratedFiles
// 是否为true来决定是否输出动态生成的代理$Proxy0
if (saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
int var1 = var0.lastIndexOf(46);
Path var2;
if (var1 > 0) {
Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
Files.createDirectories(var3);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class");
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}
- Proxy.newProxyInstance
我们代码里面的调用是:
Interface proxy = (Interface)Proxy.newProxyInstance(
DynamicProxyHandler.class.getClassLoader(),
new Class[]{ Interface.class },
new DynamicProxyHandler(real));
/**
* 通过指定接口返回`proxy`即代理类的实例，
* 该接口将方法调用分派给指定的InvocationHandler。
*
* @param loader: 用来define class的ClassLoader
* @param interfaces: proxy类需要实现的接口列表
* @param h: 方法调用需要分派给的InvocationHandler
* @return 一个proxy实例，该实例拥有由指定的ClassLoader define，
* 并实现了指定接口的proxy类其中的InvocationHandler
* @throws IllegalArgumentException 当关于传递给getProxyClass的参数的任何限制被触发
* @throws SecurityException
* @throws NullPointerException 当 interfaces 参数为空或内部元素为null,
* 或是InvocationHandler h 为null
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// h为空就跑空指针议程
Objects.requireNonNull(h);
// 克隆该接口数组
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
// 查找或生成指定的proxy Class
// 注意该生成的Class已经预定义了一个构造方法，参数就是InvocationHandler,形如：
// public demos.$Proxy0(java.lang.reflect.InvocationHandler)
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// 获得 $Proxy0 的参数为InvocationHandler的构造方法
final Constructor<?> cons = cl.getConstructor(constructorParams);
// 这里的h就是我们传入的new DynamicProxyHandler(real)
// real是我们的真实对象，即被代理对象
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
// 这里 $Proxy0 不是public的，所以会运行run方法
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
// 只是将该构造方法设为可访问
cons.setAccessible(true);
return null;
}
});
}
// 将new DynamicProxyHandler(real)传入 $Proxy0 的构造方法
// 调用之，产生代理类 $Proxy0 的实例对象
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
- getProxyClass0(loader, intfs)
loader为目标ClassLoader，intfs为传入的接口数组
/**
* 生成一个proxy Class对象
* 注意：必须在调用该方法前调用checkProxyAccess方法来进行权限检查
*/
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 1.如果proxy由该ClassLoader define且实现了指定接口的类存在于proxyClassCache
// 则仅会返回缓存中的拷贝
// 2.否则通过ProxyClassFactory来创建proxy class
return proxyClassCache.get(loader, interfaces);
}
7.2.2 java.lang.reflect.WeakCache
- proxyClassCache.get(loader, interfaces) 即 WeakCache.get
因为proxyClassCache就是WeakCache
/**
* WeakCache泛型有三个
* K ClassLoader
* P Class<?>[]
* V Class<?>
*/
final class WeakCache<K, P, V>
// 引用队列，注意泛型是K即keys
private final ReferenceQueue<K> refQueue
= new ReferenceQueue<>();
private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map
= new ConcurrentHashMap<>();
private final BiFunction<K, P, ?> subKeyFactory;
private final BiFunction<K, P, V> valueFactory;
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
// 这里的subKeyFactory就是我们在Proxy里传入的new KeyFactory(),
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
// valueFactory是new ProxyClassFactory()
this.valueFactory = Objects.requireNonNull(valueFactory);
}
get方法核心代码如下：
// 注意这里传入的参数是
// loader, interfaces
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
// 删除无效的Entry
expungeStaleEntries();
// CacheKey<K>也是继承自WeakReference<K>
// 创建一个关联了refQueue的到key的弱引用
Object cacheKey = CacheKey.valueOf(key, refQueue);
// 获取子key对应的map
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
// 如果没有valuesMap，就放置一个新的ConcurrentMap
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
// oldValuesMap不为空就是那就赋值给valuesMap
valuesMap = oldValuesMap;
}
}
// 这里调用apply方法就是创建了一个Key1
// 也是就是说创建了到interfaces[0]的弱引用
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
// interfaces[0]为key对应的Supplier
// 注意这里的泛型是V，即values
Supplier<V> supplier = valuesMap.get(subKey);
// 下面这个循环取出旧的supplier或新的Factory
// 调用其get方法，得到新建的class com.sun.proxy.$Proxy0
while (true) {
if (supplier != null) {
// supplier 可能为Factory或CacheValue<V>的实例
V value = supplier.get();
if (value != null) {
// 这里调用get不为空，就代表是使用ProxyClassFactory成功生成了Class
// (可能来自缓存也可能是上次循环生成的)
return value;
}
}
// 否则可能的情况有3：
// 1.cache中没有supplier
// 2.一个返回值为null的supplier(可能是清空了的CacheValue)
// 3.一个未成功加载CacheValue的Factory
// 懒构建一个Factory,他实现了Supplier
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// 说明之前没有旧的supplier
// 直接赋值为factory
supplier = factory;
}
// else retry with winning supplier
} else {
// supplier!=null && supplier.get()==null
// 将subKey对应的supplier CAS替换为factory
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);
}
}
}
}
}
- WeakCache.Factory
该类实现自Supplier，且是懒构建的，会放入cache中。
// 这里的泛型V是WeakCache的泛型V，即Class<?>
private final class Factory implements Supplier<V> {
// loader
private final K key;
// interfaces
private final P parameter;
// subKey为Key1 有到interfaces[0]的弱引用
private final Object subKey;
private final ConcurrentMap<Object, Supplier<V>> valuesMap;
Factory(K key, P parameter, Object subKey,
ConcurrentMap<Object, Supplier<V>> valuesMap) {
this.key = key;
this.parameter = parameter;
this.subKey = subKey;
this.valuesMap = valuesMap;
}
@Override
public synchronized V get() { // serialize access
// re-check
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {
// 其他人改了valuesMap里subKey对应的supplier
// 此时返回null
// something changed while we were waiting:
// might be that we were replaced by a CacheValue
// or were removed because of failure ->
// return null to signal WeakCache.get() to retry
// the loop
return null;
}
// else still us (supplier == this)
V value = null;
try {
// 调用ProxyClassFactory.apply生成了目标Class
// 该Class实现了我们传入的接口数组的方法
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) {
// 生成目标Class失败，valuesMap中移除该subKey
valuesMap.remove(subKey, this);
}
}
// the only path to reach here is with non-null value
assert value != null;
// 将该Class作为弱引用放入缓存，无关联RQ
CacheValue<V> cacheValue = new CacheValue<>(value);
// 将当前subKey对应的Supplier替换为cacheValue
if (valuesMap.replace(subKey, this, cacheValue)) {
// 还要把cacheValue放入reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
} else {
throw new AssertionError("Should not reach here");
}
// 最后返回生成的Class对象
return value;
}
}
7.2.3 $Proxy0
前文中，byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags);生成了代表代理类的byte[]。
但需要注意的是，经过观察他并未真的在磁盘生成.class文件，而是直接对该byte[]使用了defineClass方法生成Class对象使用。这里我们将该$Proxy0对象通过debug时调用如下命令：
Files.write(Paths.get("javaDemos/target/classes/demos/designPattern/dynamicProxy/$Proxy.class"),proxyClassFile)
输出到磁盘上，然后将$Proxy.class放入ideal进行观察:
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package demos.designPattern.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
// 该类继承自java.lang.reflect.Proxy，实现自我们自定义接口Interface
final class $Proxy0 extends Proxy implements Interface {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
private static Method m0;
static {
try {
// m0,m1,m2 继承自Object的hashCode,equls,toString方法
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
// m3 实现自Interface的doSomething方法
m3 = Class.forName("demos.designPattern.dynamicProxy.Interface").getMethod("doSomething");
// m4 实现自Interface的somethingElse方法
m4 = Class.forName("demos.designPattern.dynamicProxy.Interface").getMethod("somethingElse", Class.forName("java.lang.String"));
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
// 构造方法，注意这里传入的是InvocationHandler实例
public $Proxy0(InvocationHandler var1) throws {
// 直接调用父类Proxy的构造方法，将InvocationHandler对象引用传给Proxy类
super(var1);
}
// 注意这里继承自Object的equals方法也会在这里重写，
public final boolean equals(Object var1) throws {
try {
// 调用super.h.invoke
// 即已传给Proxy的invocationHandler对象的invoke方法
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void doSomething() throws {
try {
// 注意这里调用invocationHandler对象的invoke方法
// 并把当前代理对象和Interface的doSomething方法一并作为参数传递
// 注意这里第三个参数为
// 1.当前代理类proxy0的对象
// 2.实现自Interface的doSomething方法
// 3.该方法参数
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void somethingElse(String var1) throws {
try {
super.h.invoke(this, m4, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
}
7.3 JDK动态代理总结
7.3.1 源码回顾
最后，点击这里可以再次回顾下我们实现的invocationhandler内调用代理对象的前后怎么操作的，相信现在应该彻底能理解了。
7.3.2 原理总结
也可以点击这里看我对整个jdk动态代理画的流程图，加深理解。
7.3.3 动态代理和SpringAOP关系
AOP（Aspect Oriented Programming）意为：面向切面编程，即通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
切面如下图所示：
- 当目标对象实现了接口时，默认使用JDK的动态代理来实现AOP，但也可以强制使用Cglib.
- 当目标对象没有接口时，就必须使用Cglib实现AOP
- 以上切换由SPring处理
7.3.4 输出生成的代理类
前面已经分析过，动态代理生成的代理类不会输出，难以观察。
其实是可以输出的，只要做以下配置：
- JDK9以前：
System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”,“true”); - JDK9及以后：
System.getProperties().put(“jdk.proxy.ProxyGenerator.saveGeneratedFiles”,“true”);
配置后会在同包目录生成代理对象的Class类文件：
0x08 Cglib动态代理
8.1 简介
Cglib利用ASM开源包，对要代理的目标类的.class文件加载后，修改其字节码，最后生成新类来达到动态代理的效果。
Cglib是以继承的方式，对被代理类动态生成一个子类，并覆盖其中的方法进行逻辑添加（方法织入）。也就是说对于final类无法继承。
8.2 Cglib与AOP
可以通过maven加入org.aspectj.aspectjrt和aspectjweaver，然后在Spring配置文件加入<aop:aspectj-autoproxy proxy-target-class="true"/>。
这样就能强制让SrpingAOP底层实现采用Cglib方式。
8.3 Cglib和JDK方式代理速度对比
- CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类。
在jdk6之前比使用Java反射效率要高。**需要注意的是，CGLib不能对声明为final的方法进行代理，**因为CgLib原理是动态生成被代理类的子类。 - 在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率，
只有当进行大量调用的时候，jdk6和jdk7比CGLIB代理效率低一点，但是到jdk8的时候，jdk代理效率高于CGLIB代理。 - 可根据目标类是否实现了接口来决定选择哪种实现方式。
扫一扫
2803
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
