一、代理相关概念：被代理类(真实类)，代理类
二、代理的作用：
1、无侵入式扩展代码，既增强功能，且做到解耦，代理逻辑与业务逻辑是互相独立，在不改变真实类代码情况下做一些额外处理(Spring AOP 事务控制、日志管理)。
2、保护真实类（被代理类）：代理类拦截对真实类的直接访问，对真实类做访问检查和控制，调用者只需要和代理类进行交互即可，不必关心真实类的实现细节。
3、懒加载，程序启动时加载的是轻量级代理类，真实类只有在通过代理类调用的时候才会创建(Hibernate 的延迟加载（lazy load）本质上就是代理模式的应用，我们就经常通过代理模式来降低系统的内存开销、提升应用的运行性能。Hibernate 充分利用了代理模式的这种优势，并结合了 Javassist 或 CGLIB 来动态地生成代理对象，这更加增加了代理模式的灵活性，Hibernate 给这种用法一个新名称：延迟加载)。
三、动态代理静态代理区别
动态代理是一对多，静态代理一对一
动态代理是在运行时动态成代理类放在内存中，静态代理运行前就已经生成代理类的.class文件
四、jdk动态代理简单实现以及底层原理
4-1 jdk动态代理简单实现：
接口：Cooker.java
public interface Cooker {
public void cook();
}
真实类(被代理类)：ElectricCooker.java
public class ElectricCooker implements Cooker {
@Override
public void cook() {
System.out.println("电饭锅煮饭");
}
}
InvocationHandler接口实现类：DynamicProxy.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* Class<?> cl = getProxyClass0(loader, intfs);生成代理类
*/
public class DynamicProxy implements InvocationHandler {
private Cooker target;
public Cooker getInstance(Cooker cooker ) {
this.target = cooker;
Class<?> clazz = target.getClass();
return (Cooker) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object obj = method.invoke(this.target, args);
after();
return obj;
}
private void before() {
System.out.println("before。。。插上电源");
}
private void after() {
System.out.println("after。。。拔掉电源");
}
}
测试类：DynamicProxyTest.java
public class DynamicProxyTest {
String basePath = "C:/Users/zhou/Desktop/Jad/";
@Test
public void testCook() {
Cooker cooker = new DynamicProxy().getInstance(new ElectricCooker());
cooker.cook();
}
@Test
public void testGetClassFile() {
Cooker cooker = new DynamicProxy().getInstance(new ElectricCooker());
byte[] classFile = sun.misc.ProxyGenerator.generateProxyClass(cooker.getClass().getName(),
cooker.getClass().getInterfaces());
String path = basePath + cooker.getClass().getSimpleName() + ".class";
try (FileOutputStream fos = new FileOutputStream(path)) {
fos.write(classFile);
fos.flush();
System.out.println("代理类class文件写入成功,classNme:" + cooker.getClass().getName());
} catch (Exception e) {
e.printStackTrace();
System.out.println("写文件错误");
}
}
}
测试结果 testCook()：
before。。。插上电源
电饭锅煮饭
after。。。拔掉电源
测试结果 testGetClassFile()，通过jad反编译得到动态生成的代理类$Proxy4代码：
package com.uniz.study.proxy.source;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import com.uniz.study.proxy.Cooker;
public final class $Proxy4 extends Proxy implements Cooker {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("com.uniz.study.proxy.Cooker").getMethod("cook", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (Exception e) {
e.printStackTrace();
}
}
public $Proxy4(InvocationHandler paramInvocationHandler) {
super(paramInvocationHandler);
}
public final void cook() {
try {
this.h.invoke(this, m3, null);
return;
} catch (RuntimeException localRuntimeException) {
throw localRuntimeException;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final boolean equals(Object paramObject)
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString()
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode()
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
}
Proxy.java
4-2 通过上面testGetClassFile()测试方法分析动态代理底层逻辑实现：
Cooker cooker = new DynamicProxy().getInstance(new ElectricCooker());
此处cooker的实际类型是动态生成的代理类$Proxy4，
1、$Proxy4的实现了Cooker 接口：
public final void cook() {
try {
this.h.invoke(this, m3, null);
return;
} catch (RuntimeException localRuntimeException) {
throw localRuntimeException;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
2、方法中this.h是$Proxy4类的属性protected InvocationHandler h，在生成动态代理类时，DynamicProxy 把自己作为参数传给了代理类，因此此处this.h = DynamicProxy对象，而DynamicProxy类刚好实现了InvocationHandler接口的invoke方法，并且invoke方法中执行method.invoke(target, args)时，参数target是真实类的对象引用，因而能执行真实对象的方法
五、debug跟踪动态代理类的详细创建过程：
至此，由上面debug过程发现，代理类$Proxy4的关键创建过程如下：
Cooker cooker = new DynamicProxy().getInstance(new ElectricCooker());
Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this)
Class<?> cl = getProxyClass0(loader, intfs);
valueFactory.apply(key, parameter)
byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags);
最后发现创建代理类的方法 ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags);
测试方法testGetClassFile()正是调用此方法得到代理对象$Proxy4
小结：
1、真实类（被代理类）把自己委托给代理类，在代理类中可以对其功能增强，同时做到代理逻辑与业务逻辑的解耦，当真实类比较臃肿时，初始化时用轻量级的代理类替代直接初始化真实类，从而实现真实类的延迟加载。
2、jdk的动态代理简单实现逻辑：
// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..);
// 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,
new Class[] { Interface.class },
handler );
3、常见的代理场景：
远程代理：为位于两个不同地址空间对象的访问提供了一种实现机制，可以将一些消耗资源较多的对象和操作移至性能更好的计算机上，提高系统的整体运行效率。
虚拟代理：通过一个消耗资源较少的对象来代表一个消耗资源较多的对象，可以在一定程度上节省系统的运行开销
缓存代理：为某一个操作的结果提供临时的缓存存储空间，以便在后续使用中能够共享这些结果，优化系统性能，缩短执行时间
保护代理：可以控制对一个对象的访问权限，为不同用户提供不同级别的使用权限。
智能引用代理：当需要为一个对象的访问（引用）提供一些额外的操作时可以使用智能引用代理
参考：
Java 动态代理机制分析及扩展
743
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
