“这是我参与8月更文挑战的第17天，活动详情查看：8月更文挑战”
一、什么是代理模式？
代理模式是指为其它对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，当一个对象不合适或者不能直接引用另一个对象时，我们可以采用代理模式来解决，代理对象可以在客户端和目标对象之间起到中介的作用。
二、代理模式的应用场景
生活中的售票黄牛、租房中介、经纪人、婚介、快递、事务代理、非侵入式日志监听等，都是代理模式的实际体现。当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过代理对象来间接访问。
使用代理模式主要有两个目的： 一是保护目标对象，二是增强目标对象。
三、静态代理
举个例子，有些人到了适婚年龄，其父母总是迫不及待的希望早点抱孙子。而现在在各种压力之下，很多人都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女自己还着急。下面来看代码实现，创建顶层接口IPerson的代码如下：
public interface IPerson {
void findLove();
}
儿子ZhangSan要找对象，实现IPerson接口：
public class ZhangSan implements IPerson {
@Override
public void findLove() {
System.out.println("儿子要求：肤白貌美大长腿");
}
}
父亲ZhangLaoSan要帮儿子ZhangSan相亲，实现IPerson接口：
public class ZhangLaoSan implements IPerson {
private ZhangSan zhangSan;
public ZhangLaoSan(ZhangSan zhangSan) {
this.zhangSan = zhangSan;
}
@Override
public void findLove() {
System.out.println("张老三开始物色");
zhangSan.findLove();
System.out.println("开始交往");
}
}
测试代码：
public class Test {
public static void main(String[] args) {
ZhangLaoSan zhangLaoSan = new ZhangLaoSan(new ZhangSan());
zhangLaoSan.findLove();
}
}
上面的场景有个弊端，就是自己父亲只会给自己的子女去物色相亲对象，别人家的孩子是不会管的。但社会上这项业务发展成了一个产业，出现了媒人，婚介所等，还有各种各样的定制套餐。如果还使用静态代理成本就太高了，需要一个更加通用的解决方案，满足任何单身人士找对象的需求。
四、动态代理
承接上文，静态代理到动态代理。采用动态代理基本上只要是人（IPerson）就可以提供相亲服务。动态代理的底层实现一般不用我们自己亲自去实现，已经有很多现成的API。在Java生态中，目前最普通使用的是JDK自带的代理和CGLib提供的类库。下面我们首先基于JDK的动态代理来升级下代码。
创建媒人类JdkMeiRen：
public class JdkMeiRen implements InvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target) {
this.target = target;
Class<? extends IPerson> clazz = target.getClass();
return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(target, args);
after();
return result;
}
private void before() {
System.out.println("我是媒人，已经收集到你的需求，开始物色。");
}
private void after() {
System.out.println("双方同意，开始交往。");
}
}
再创建一个类ZhaoLiu：
public class ZhaoLiu implements IPerson {
@Override
public void findLove() {
System.out.println("赵六要求：有车有房有学历");
}
}
测试代码如下：
public class Test {
public static void main(String[] args) {
JdkMeiRen jdkMeiRen = new JdkMeiRen();
IPerson zhangSan = jdkMeiRen.getInstance(new ZhangSan());
zhangSan.findLove();
System.out.println("=====================");
IPerson zhaoLiu = jdkMeiRen.getInstance(new ZhaoLiu());
zhaoLiu.findLove();
}
}
运行效果如下图所示：
五、手写JDK动态代理实现原理
不仅知其然，还得知其所以然。既然JDK动态代理功能如此强大，那么它是如何实现的呢？我们先来探究一下原理，并模仿JDK动态代理动手写一个属于自己的动态代理。
我们都知道JDK动态代理采用字节码重组，重新生成对象来替代原始对象，以达到动态代理的目的。
JDK动态代理生成对象的步骤如下：
- 获取被代理对象的引用，并且获取它的所有接口，反射获取。
- JDK动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口。
- 动态生成Java代码，新加的业务逻辑方法有一定的逻辑代码调用（在代码中体现）。
- 编译新生成的Java代码.class文件。
- 重新加载到JVM中运行。
以上过程就叫字节码重组。JDK中有一个规范，在ClassPath下只要是$开头的.class文件，一般都是自动生成的。那么我们有没有办法看到代替后对象的 “真容” 呢？做一个这样测试，我们将内存中的对象字节码通过文件流输出到一个新的.class文件，然后利用反编译工具查看其源代码。
public class JDKProxyTest {
public static void main(String[] args) {
try {
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{IPerson.class});
FileOutputStream fos = new FileOutputStream("$Proxy0.class");
fos.write(bytes);
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行以上代码，找到一个文件$Proxy0.class文件，利用Java反编译，内容如下：
public final class $Proxy0 extends Proxy implements IPerson {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
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 findLove() throws {
try {
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 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);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("com.mark.proxy.staticproxy.IPerson").getMethod("findLove");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
我们发现，$Proxy0继承了Proxy类，同时还实现了IPerson接口，而且重写了findLove()等方法。在静态块中用反射查找到了目标对象的所有方法，而且保存了所有方法的引用。“小伙伴们” 此时一定会好奇：这些代码是哪里来的呢？其实是JDK帮我们自动生成的。现在我们不依赖JDK，自己来动态生成源代码、动态完成编译、然后替代目标对象并执行。
创建MarkInvocationHandler接口：
public interface MarkInvocationHandler {
Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
创建MarkClassLoader类：
public class MarkClassLoader extends ClassLoader {
private File classPathFile;
public MarkClassLoader() {
String path = MarkClassLoader.class.getResource("").getPath();
System.out.println("MarkClassLoader path = " + path);
this.classPathFile = new File(path);
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String className = MarkClassLoader.class.getPackage().getName() + "." + name;
System.out.println("findClass className = " + className);
if (classPathFile != null) {
File classFile = new File(classPathFile, name.replaceAll("\.", "/") + ".class");
if (classFile.exists()) {
FileInputStream in = null;
ByteArrayOutputStream out = null;
try {
in = new FileInputStream(classFile);
out = new ByteArrayOutputStream();
byte[] buff = new byte[1024];
int len;
while ((len = in.read(buff)) != -1) {
out.write(buff, 0, len);
}
return defineClass(className, out.toByteArray(), 0, out.size());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
return null;
}
}
创建MarkProxy类：
public class MarkProxy {
public static final String ln = "\r\n";
public static Object newProxyInstance(MarkClassLoader classLoader, Class<?>[] interfaces, MarkInvocationHandler h) {
try {
//1、动态生成源代码.java文件
String src = generateSrc(interfaces);
System.out.println(src);
//2、Java文件输出磁盘
String filePath = MarkProxy.class.getResource("").getPath();
System.out.println(filePath);
File f = new File(filePath + "$Proxy0.java");
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//3、把生成的.java文件编译成.class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manage = compiler.getStandardFileManager(null, null, null);
Iterable iterable = manage.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null, manage, null, null, null, iterable);
task.call();
manage.close();
//4、编译生成的.class文件加载到JVM中来
Class proxyClass = classLoader.findClass("$Proxy0");
Constructor c = proxyClass.getConstructor(MarkInvocationHandler.class);
f.delete();
//5、返回字节码重组以后的新的代理对象
return c.newInstance(h);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private static String generateSrc(Class<?>[] interfaces) {
StringBuffer sb = new StringBuffer();
sb.append(MarkProxy.class.getPackage() + ";" + ln);
sb.append("import " + interfaces[0].getName() + ";" + ln);
sb.append("import java.lang.reflect.*;" + ln);
sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
sb.append("MarkInvocationHandler h;" + ln);
sb.append("public $Proxy0(MarkInvocationHandler h) { " + ln);
sb.append("this.h = h;");
sb.append("}" + ln);
for (Method m : interfaces[0].getMethods()) {
Class<?>[] params = m.getParameterTypes();
StringBuffer paramNames = new StringBuffer();
StringBuffer paramValues = new StringBuffer();
StringBuffer paramClasses = new StringBuffer();
for (int i = 0; i < params.length; i++) {
Class clazz = params[i];
String type = clazz.getName();
String paramName = toLowerFirstCase(clazz.getSimpleName());
paramNames.append(type + " " + paramName);
paramValues.append(paramName);
paramClasses.append(clazz.getName() + ".class");
if (i > 0 && i < params.length - 1) {
paramNames.append(",");
paramClasses.append(",");
paramValues.append(",");
}
}
sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
sb.append("try{" + ln);
sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod("" + m.getName() + "",new Class[]{" + paramClasses.toString() + "});" + ln);
sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})", m.getReturnType()) + ";" + ln);
sb.append("}catch(Error _ex) { }");
sb.append("catch(Throwable e){" + ln);
sb.append("throw new UndeclaredThrowableException(e);" + ln);
sb.append("}");
sb.append(getReturnEmptyCode(m.getReturnType()));
sb.append("}");
}
sb.append("}" + ln);
return sb.toString();
}
private static Map<Class, Class> mappings = new HashMap<Class, Class>();
static {
mappings.put(int.class, Integer.class);
}
private static String getReturnEmptyCode(Class<?> returnClass) {
if (mappings.containsKey(returnClass)) {
return "return 0;";
} else if (returnClass == void.class) {
return "";
} else {
return "return null;";
}
}
private static String getCaseCode(String code, Class<?> returnClass) {
if (mappings.containsKey(returnClass)) {
return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()";
}
return code;
}
private static boolean hasReturnValue(Class<?> clazz) {
return clazz != void.class;
}
private static String toLowerFirstCase(String src) {
char[] chars = src.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}
}
创建MarkMeiRen类：
public class MarkMeiRen implements MarkInvocationHandler {
//被代理的对象，把引用保存下来
private Object target;
public Object getInstance(Object target) {
this.target = target;
Class<?> clazz = target.getClass();
return MarkProxy.newProxyInstance(new MarkClassLoader(), clazz.getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
method.invoke(target, args);
after();
return null;
}
private void before() {
System.out.println("我是媒人，我要给你找对象，现在已经确认了你的需求。");
System.out.println("开始物色");
}
private void after() {
System.out.println("如果合适的话，就准备办事。");
}
}
客户端测试代码如下：
public class Test {
public static void main(String[] args) {
IPerson zhangSan = (IPerson) new MarkMeiRen().getInstance(new ZhangSan());
System.out.println(zhangSan.getClass());
zhangSan.findLove();
}
}
运行结果如下图所示：
到此，手写JDK动态代理就完成了，“小伙伴们”是不是又多了一个面试用的 “杀手锏” 呢？
六、CGLib代理调用API及原理分析
简单看一下CGLib代理的使用，还是以媒人为例，创建CglibMeiRen类：
public class CglibMeiRen implements MethodInterceptor {
public Object getInstance(Class<?> clazz) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object result = methodProxy.invokeSuper(o, objects);
after();
return result;
}
private void before() {
System.out.println("我是媒人，我要给你找对象，现在已经确认了你的需求。");
System.out.println("开始物色");
}
private void after() {
System.out.println("如果合适的话，就准备办事。");
}
}
创建单身客户类Customer：
public class Customer {
public void findLove() {
System.out.println("肤白貌美大长腿");
}
}
有个小细节，CGLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代理的。来看测试代码：
public class Test {
public static void main(String[] args) {
Customer customer = (Customer) new CglibMeiRen().getInstance(Customer.class);
System.out.println(customer.getClass());
customer.findLove();
}
}
运行结果如下图所示：
CGLib代理的实现原理又是怎样的呢？我们可以在测试代码中加上一句代码，将CGLib代理后的.class文件写入磁盘，然后反编译来一探究竟，代码如下：
public class Test {
public static void main(String[] args) {
//利用CGLib的代理类可以将内存中的.class文件写入本地磁盘
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F://test/");
Customer customer = (Customer) new CglibMeiRen().getInstance(Customer.class);
System.out.println(customer.getClass());
customer.findLove();
}
}
重新执行代码，我们会发现在指定目录下多了三个.class文件，如下图所示：
通过调试跟踪发现，Customerd1ca6fd2.class就是CGLib代理生成的代理类，继承了Customer类。
// 代理方法（methodProxy.invokeSuper()方法会调用）
final void CGLIB$findLove$0()
{
super.findLove();
}
CGLib代理执行代理方法的效率之所以比JDK的高，是因为CGlib采用了FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index（int类型），这个index当作一个入参，FastClass就可以直接定位要调用的方法并直接进行调用，省去了反射调用，所以调用效率比JDK代理通过反射调用高。
七、CGLib和JDK动态代理对比
- JDK动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象。
- JDK动态代理和CGLib代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLib使用ASM框架写Class字节码，CGLib代理实现更复杂，生成代理类比JDK动态代理效率低。
- JDK动态代理调用代理方法是通过反射机制调用的，CGLib代理是通过FastClass机制直接调用方法的，CGLib代理的执行效率更高。
八、代理模式在Spring生态的例子
先看ProxyFactoryBean核心方法getObject()，源码如下：
public Object getObject() throws BeansException {
initializeAdvisorChain();
if (isSingleton()) {
return getSingletonInstance();
}
else {
if (this.targetName == null) {
logger.info("Using non-singleton proxies with singleton targets is often undesirable. " +
"Enable prototype proxies by setting the 'targetName' property.");
}
return newPrototypeInstance();
}
}
在getObject()方法中，主要调用getSingletonInstance()和newPrototypeInstance()。在Spring的配置中，如果不做任何设置，那么Spring代理生成的Bean都是单例对象。如果修改scope，则每次创建一个新的原型对象。newPrototypeInstance()里面的逻辑比较复杂，读者可以先自行了解下。
Spring利用动态代理实现AOP时有两个非常重要的类：JdkDynamicAopProxy类和CglibAopProxy类，来看一下类图，如下图所示：
Spring中的代理选择原则
- 当Bean有实现接口时，Spring就会利用JDK动态代理。
- 当Bean没有实现接口时，Spring就会选择CGLib代理。
- Spring可以通过配置强制使用CGLib代理，只需要在Spring配置文件中加入如下代码：<aop:aspectj-autoproxy proxy-target-class="true" />
九、代理模式的优缺点
优点：
- 代理模式能将代理对象与真实被调用目标对象分离。
- 在一定程度上降低了系统的耦合度，扩展性好。
- 可以起到保护目标对象的作用。
- 可以增强目标对象的功能。
缺点：
- 代理模式会造成系统设计中类的数量增加。
- 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢。
- 增加了系统的复杂度。
十、友情链接
欢迎大家关注微信公众号（MarkZoe）互相学习、互相交流。
