代理模式是什么？
代理模式是一种结构性设计模式，意思是在使用者和目标中出现一个中间层，中间层才能控制目标，而使用者只能和中间层交互，类似：租客 - 中介 - 房东。中间层在双方之中增加自己的业务。
代理模式能解决什么问题？
直接访问对象时带来的问题。
比如你在访问中途需要增加中间层业务的时候。
比如你要不同业务中增加统一的一层业务。
代理模式分类
静态代理
静态代理是什么？
给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用。
例子1：电脑桌面的快捷方式。电脑对某个程序提供一个快捷方式（代理对象），快捷方式连接客户端和程序，客户端通过操作快捷方式就可以操作那个程序。
例子2：你要租房，然后通过第三方的租房平台租到了一套房。这里第三方租房平台就是代理对象，第三方租房平台连接着你和房东，房东就是目标对象。
例子3：你去银行存钱，你只需要找寻柜台工作人员帮你做存钱的业务，而不需要自己操作电脑存钱。这里柜台工作人员就是代理对象，而存钱的业务就是目标对象。
代理对象：起到了中介作用，连接客户端和目标对象。
解决问题
隐藏了真正的功能细节，一切通过代理得知结果。防止直接访问目标对象带来的不必要的复杂度。
模式原理
静态代理.png
实例讲解
实例概况
- 背景：小成希望买一台最新的顶配Mac电脑
- 冲突：国内还没上，只有美国才有
- 解决方案：寻找代购进行购买
代购（代理对象） 代替 我（真实对象） 去买Mac（间接访问的操作）
实现步骤
1、创建抽象对象接口（ISBusiness）：声明你（真实对象）需要让代购（代理对象）帮忙做的事（买Mac）
interface ISBusiness {
/**
* 买mac
*/
fun buyMac(name:String)
/**
* 买水果
*/
fun buyFruit(name:String,fruit: String)
}
2、创建真实对象类（SBusiness）,即真正做事的人
class SBusiness : ISBusiness {
override fun buyFruit(name: String,fruit: String) {
println("帮${name}买了一斤$fruit")
}
override fun buyMac(name: String) {
println("帮${name}去买了一台mac")
}
}
3、创建代理对象类（Proxy），即”代购“，并通过代理类创建真实对象实例并访问其方法
class SProxy :ISBusiness{
override fun buyFruit(name: String,fruit: String) {
//真实做事情的对象
val business = SBusiness()
business.buyFruit(name,fruit)
//代理对象做额外的操作
fruitWrap()
}
override fun buyMac(name:String) {
//真实做事情的对象
val business = SBusiness()
business.buyMac(name)
//代理对象做额外的操作
giftWrap()
}
private fun giftWrap() {
println("商品包装")
}
private fun fruitWrap() {
println("水果打包")
}
}
4、客户端调用
@Test
fun test() {
val sproxy = SProxy()
sproxy.buyMac("小明")
sproxy.buyFruit("小明","香蕉")
}
结果输出
帮小明去买了一台mac
商品包装
帮小明买了一斤香蕉
水果打包
优缺点
优点
- 由代理类对目标对象进行访问控制和扩展，降低了系统的耦合度。
- 代理对象作为客户端和目标对象的中间层，起到了保护目标对象的作用。
缺点
- 重复性：静态代理的原则是一个代理类对应一个基础接口，如果基础接口过多，那么就需要创建多个代理类来分别管理不同的目标对象。重复的模板也会越来越多。
- 脆弱性：基础接口一旦修改，所以相关的目标对象都要进行改动，代理类也无法避免。
- 实现代理模式需要额外的工作（有些代理模式的实现非常复杂），从而增加了系统实现的复杂度。如果多个不同的基础接口需要提供一个相关的功能，比如日志，那么所有实现的代理类都需要进行修改。
动态代理
动态代理的意义
假设项目中要给多个实现了一个相同的业务接口增加一个统一的功能，比如日志，这个时候你使用静态代理其实可以实现。但是如果项目中要给多个不同的业务接口实现类增加一个日志功能呢？你一个静态代理是不够的，静态代理的原则是一个代理类对应着一个基础接口。那如果是多个基础接口，就需要创建多个静态代理类。这就暴露了静态代理的缺点：
一、重复性，在程序规模开始增加时，需要代理的方法越来越多，你所需要的代理类就越来越多，重复的模板就越来越多了。
二、脆弱性，基础接口一旦修改，除了所有的业务类需要修改，代理类也必须改动。
怎么解决这个问题？
动态代理（Dymanic Proxy API）是JDK1.3中引入的特性，核心API是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。它利用反射机制在运行时生成代理类的字节码，为Java平台在带来了运行时动态扩展对象行为的能力。
动态代理和静态代理的区别？
静态代理：在编译期间就已经确定目标对象是哪一个，运行前目标对象已经存在。
动态代理：程序运行时才确定目标对象是哪一个，运行过程中动态生成代理类。
为什么要用动态代理？
因为一个静态代理类只能服务一种类型的对象，在目标对象较多的情况下，会出现代理类较多，代码量较大的问题。
而使用动态代理动态生成代理者对象能避免这种情况的发生。
动态代理核心组件
Proxy：代理类，内部通过反射机制动态生成代理类对象。
InvocationHandler：这是一个接口，代理实例的调用处理程序。
原理时序图
动态代理.png
实现步骤
1、声明目标对象的抽象接口
interface Ibusiness {
fun business()
}
2、生成目标对象（实现目标对象的抽象接口，这里由于每个代理类都继承了 Proxy 类，又 Java 的单继承特性，所以，只能针对接口创建代理类，不能针对类创建代理类）
class OneBusiness : Ibusiness {
override fun business() {
println("我外出买了mac")
}
}
3、声明调用处理类
public class BusinessHandler implements InvocationHandler {
private Ibusiness ibusiness;
public BusinessHandler(Ibusiness bui) {
ibusiness = bui;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("外出前先收拾垃圾");
try {
method.invoke(ibusiness, args);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("外出回来了");
return null;
}
}
4、生成相关对象并通过代理类对象调用目标对象方法
//生成相关对象
OneBusiness business = new OneBusiness();
BusinessHandler handler = new BusinessHandler(business);
Ibusiness ibusiness = (Ibusiness) Proxy.newProxyInstance(business.getClass().getClassLoader(), business.getClass().getInterfaces(), handler);
//调用方法
ibusiness.business();
5、最终会在调用处理类中执行目标对象的对应方法，并且你可以在此期间增加新的业务
public class BusinessHandler implements InvocationHandler {
private Ibusiness ibusiness;
public BusinessHandler(Ibusiness bui) {
ibusiness = bui;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//可以执行一些扩展的业务，比如日志，埋点等
System.out.println("外出前先收拾垃圾");
try {
//调用目标对象方法
method.invoke(ibusiness, args);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("外出回来了");
return null;
}
}
结果输出
外出前先收拾垃圾 ->这是扩展的业务
我外出买了mac -> 这是目标对象执行的函数
外出回来了 -> 这也是扩展的业务
静态代理和动态代理
共同点：两种代理模式都是在不改动目标对象的前提下，对目标对象进行访问和扩展，符合开闭原则。
不同点：静态代理模式在程序规模稍大时，重复性和脆弱性的缺点出现，动态代理实现了一个代理处理N个基础接口并扩展，本质上是代理类和基础接口的解耦，一定程度上规避了静态代理的缺点。从原理上讲，静态代理的代理类在编译期生成，而动态代理的代理类在运行时生成。代理类在coding阶段并不存在，代理关系直到运行时才确定。
使用动态代理的好处？
它可以无侵入的增加其他的方法，不会对基础业务有任何影响。
应用场景
Android的跨进程通信中使用了动态代理
比如activity的启动过程中，有动态代理的使用
Retrofit中create()也使用了动态代理，用途是封装接口转化成一个OkHttpCall对象传给OkHttp
AOP面向切面编程领域
动态代理源码分析
这是java.lang.reflect.Proxy的源码，试着理解代理类Class如何生成，这是jdk1.3之后引入的特性
package java.lang.reflect;
* @author Peter Jones
* @see InvocationHandler
* @since 1.3
*/
public class Proxy implements java.io.Serializable {
公共方法
2.png
分析newProxyInstance方法
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
throws IllegalArgumentException
参数一：ClassLoader 类加载器，这里可以传代理类要实现的接口的ClassLoader
为什么要指定ClassLoader对象？
ClassLoader相当于类的命名空间，类的唯一性由它本身和加载它的ClassLoader确定。一个Class文件如果由两个ClassLoader加载，结果是两个独立的类。
参数二：Class<?>[] 要实现的接口，因为一个类可以实现多个接口，所以这里是个数组
参数三：InvocationHandler 这个就是接口代理类执行方法的回调
{
...
//查找或生成指定的代理类
Class<?> cl = getProxyClass0(loader, intfs);
...
//实例化代理类，H就是我们实现的BusinessHandler
return cons.newInstance(new Object[]{h});
...
}
分析通过动态代理生成的字节码文件
getProxyClass0()获取代理类字节码文件，主要使用了ProxyGenerator.generateProxyClass()生成了代理类，默认在内存中，如果你想生成文件观看需要设置两个步骤：
一、设置System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true") 获取本地文件, 通过此语句可以立个flag让生成字节码文件的时候，输出本地字节码文件,注意这句话一定要在获取代理类实例之前。
二、需要在main函数中调用才能生成字节码文件，原因未知，但是我在其他地方调用是不能生成字节码文件的。
生成的文件在当前项目的根目录，对应的包名文件夹里：com/sun/proxy/$Proxy().class
3.png
ProxyGenerator
这个类是生成对应的代理类字节码,也就是通过这个方法
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
//这是对应设置是否生成对应路径的字节码文件，默认只会生成在内存中
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();
//我们现在控制的就是这个变量，如果为ture表示字节码文件写入本地
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;
}
来看下生成的字节码文件
package com.sun.proxy;
import com.wzy.dynamic.proxy.dproxy.Ibusiness;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Ibusiness {
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 business() 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.wzy.dynamic.proxy.dproxy.Ibusiness").getMethod("business");
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());
}
}
}
关键的构造函数
//这个handler就是我们最初传入的那个InvocationHandler的实现类
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
接着看父类
//这个H就是我们自己的InvocationHandler
protected Proxy(InvocationHandler var1) {
Objects.requireNonNull(var1);
this.h = var1;
}
Proxy中有一个这个静态方法就是最终会回到我们实现的invoke类中
private static Object invoke(Proxy proxy, Method method, Object[] args) throws Throwable {
InvocationHandler h = proxy.h;
return h.invoke(proxy, method, args);
}
所有相关的调用最终也都会调用这个方法，具体可以看上面的字节码类
//$Proxy0.class
public final void business() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
总结一下，代理类执行的任何一个方法都会回调你的InvocationHandler实现类。而且通过ProxyGenerator.generateProxyClass()确实动态生成了字节码文件！
那么看完这些咱们也明白了InvocationHandler中invoke(Object proxy, Method method, Object[] args) 这三个参数分别是什么?
参数一：Object 生成的代理类对象
参数二：Method 代理类调用的方法
参数三：args 调用方法时的参数
网友评论