动态代理理论及Mybatis实战
动态代理在我们平时编程并不常用，但因为Spring AOP以及大量框架均使用动态代理机制。
所以必须要掌握。
动态代理其本质是：PrxoyGenerator.generateProxyClass生成字节码文件，然后通defineClass0加载这个类
说白了是重生成了一个字节码文件。
那先看下源码，在来简单实践一下
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
//克隆一份
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//通过getProxyClass0方法动态生成Class类
Class<?> cl = getProxyClass0(loader, intfs);
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
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);
}
}
该方法首先创建了一个接口的克隆，之后检查权限。
最重要的一步是Class<?> cl = getProxyClass0(loader, intfs)
Java通过该方法中proxyClassCache.get()方法拿到生成的字节码
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//首先，限制一个类接口不能多余65535
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
// proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
return proxyClassCache.get(loader, interfaces);
}
proxyClassCache.get()方法的部分实现
//最终通过 supplier.get()返回对象
while (true) {
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get();
if (value != null) {
return value;
}
}
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);
}
}
}
//supplier.get()的实现
public synchronized V get() { // serialize access
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {
return null;
}
// else still us (supplier == this)
// create new value
V value = null;
try {
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// the only path to reach here is with non-null value
assert value != null;
// wrap value with CacheValue (WeakReference)
CacheValue<V> cacheValue = new CacheValue<>(value);
// put into reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
// try replacing us with CacheValue (this should always succeed)
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}
// successfully replaced us with new CacheValue -> return the value
// wrapped by it
return value;
}
之后回过头看apply方法（value = Objects.requireNonNull(valueFactory.apply(key, parameter));）
找到类：ProxyClassFactory
//·········省略部分验证代码
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, accessFlags);
try {
return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
其关键部分位于PrxoyGenerator.generateProxyClass生成代理类字节码文件。
之后返回newProxyInstance方法，看这个类如何被实例化，
private static final Class<?>[] constructorParams = { InvocationHandler.class };
····
final Constructor<?> cons = cl.getConstructor(constructorParams);
return cons.newInstance(new Object[]{h});
首先，获取了带参数InvocationHandler类的构造器，然后通过构造器，往里看最后通过调用NativeConstructorAccessorImpl的本地方法实例化了这个类,这样就完成了整个代理过程
接下来看下一个实践，知道原理还是要用一下：
public interface Subject {
//先做一个接口，里面只有一个方法
void sayHello(String str);
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//实现InvocationHandler接口
public class Invoke implements InvocationHandler {
//这个就是我们要代理的真实对象
private Object subject;
//构造方法，给我们要代理的真实对象赋初值
public Invoke(Object subject) {
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//doSomeThing
System.out.println("即将被代理的方法");
method.invoke(subject, args);
return null;
}
}
以上就完成了代理类的构建，接下倆我们去调用一下
import java.lang.reflect.Proxy;
public class doMain {
public static void main(String[] args){
Subject subjectImpl = str -> System.out.println("Hello:" + str);
Invoke invoke = new Invoke(subjectImpl);
Subject subject = (Subject) Proxy.newProxyInstance(subjectImpl.getClass().getClassLoader(), subjectImpl.getClass().getInterfaces(), invoke);
//并未直接调用subjectImpl，而是调用生成的代理类
subject.sayHello("test");
}
}
/* 控制台输出：
* 即将被代理的方法
* Hello:test
*/
