文章目录
1. 前言
首先看下百度百科对代理模式的介绍:
代理模式的定义:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
其实也就是中介模式或者委托模式。在日常生活中代理模式很多,比如叫同事带饭、打官司等。使用代理模式的主要意图为:为其他对象提供一种代理以控制对这个对象的访问。主要的使用场景为:当无法或不想直接访问某个对象时,可以通过一个代理对象来间接访问,为了保证客户端使用的透明性,委托对象与代理对象需要实现相同的接口。
在Spring-AOP简介一文中曾提到过两种代理方式,即:静态代理和动态代理。
- 静态代理:是由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。
- 动态代理:是在实现阶段不用关心代理类,而在运行阶段才指定哪一个对象。
这里继续围绕这两种方式进行回顾和展开。
2. 代理模式(Proxy Pattern)
2.1 静态代理模式
比如下面的案例:
interface ISubject {
void doSomething();
}
// 真正的实现类
class RealSubject_ZhangSan implements ISubject{
@Override
public void doSomething() {
System.out.println("买手机");
}
}
class ProxySubject_Shop implements ISubject{
private RealSubject_ZhangSan mSubject; // 真正做这件事的对象
public ProxySubject_Shop(RealSubject_ZhangSan subject){
this.mSubject = subject;
}
@Override
public void doSomething() { // 只做代理
mSubject.doSomething();
}
}
public class Client {
public static void main(String[] args) {
RealSubject_ZhangSan subject = new RealSubject_ZhangSan();
// 构造代理对象
ProxySubject_Shop proxySubject = new ProxySubject_Shop(subject);
// 调用代理的方法
proxySubject.doSomething();
}
}
对应的类图为:
Client
通过接口知道需要调用什么方法,而因为在代理模式中不能直接访问真正的目标对象,而需要通过代理对象来进行访问。所以在Client
中需要使用代理对象,由于代理模式规定了需要保证客户端使用的透明性,所以被代理对象和代理对象都需要事项相同的接口,即这里的doSomething
方法。
值得注意的是,按照上面的写法对于每个具体的代理类,我们都需要在其中指定维护(代理)的具体Subject
类,那么当有很多具体的RealSubject
的时候,就需要定义很多的代理类,当然这是不合理的。所以在代理类中只有的应该是接口,比如:
class ProxySubject_Shop implements ISubject{
private ISubject mSubject; // 真正做这件事的对象,面向接口编程而不要面向具体的实现
public ProxySubject_Shop(ISubject subject){
this.mSubject = subject;
}
@Override
public void doSomething() { // 只做代理
mSubject.doSomething();
}
}
虽然上面这种方式确实解决了存在多个真实主题类的情况,但是如果代理类需要在原有的真实Subject
前或者后做一些自己独有的操作的时候,就需要根据代理类的种类,来定义多个代理类。这显然也是不合理的。所以就需要动态代理。
从前面我们知道使用静态代理其实也就是在源码中直接指定。而动态代理方式相反,是通过反射的机制来动态地生成代理者的对象,也就是说代理谁将会在执行阶段决定。
2.2 动态代理模式
动态代理中所使用的技术也就是反射,在Java
中提供了一个便捷的动态代理接口InvocationHandler
以及相关的代理类Proxy
。
InvocationHandler
:调用处理程序,并返回一个结果的;Proxy
:提供了创建动态代理类和实例的静态方法,用于生成动态代理的这个实例;
interface ISubject {
void doSomething();
}
// 真正的实现类
class RealSubject_ZhangSan implements ISubject{
@Override
public void doSomething() {
System.out.println("买手机");
}
}
public class Client {
public static void main(String[] args) {
RealSubject_ZhangSan realSubject = new RealSubject_ZhangSan();
// 动态构造一个代理者 ==> 代理realSubject
ISubject subject = (ISubject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
new Class[]{ISubject.class}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(realSubject, args);
}
});
// 得到类RealSubject_ZhangSan的实现接口Class对象
// new Class[]{ISubject.class} 或者:RealSubject_ZhangSan.class.getInterfaces()
// 调用代理的方法
subject.doSomething();
}
}
当然这里可以抽离出来一个动态代理类:
class DynamicProxy<T extends ISubject> implements InvocationHandler {
private T mObj;
public DynamicProxy(T obj){
this.mObj = obj;
}
public ISubject getProxy(){
return (ISubject) Proxy.newProxyInstance(mObj.getClass().getClassLoader(),
mObj.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(mObj, args);
}
}
public class Client {
public static void main(String[] args) {
RealSubject_ZhangSan realSubject = new RealSubject_ZhangSan();
// 动态代理
ISubject subject = new DynamicProxy<RealSubject_ZhangSan>(realSubject).getProxy();
// 调用代理的方法
subject.doSomething();
}
}
对应的类图:
观察上面类图,可以直观的看到就是动态代理类和具体的实现类就没有直接关联关系了。而需要做的是在Client
代理类中进行动态确定。可以看到就是这种方式的代码耦合度更低。也就是完成了代理者和被代理者之间的解耦,使得这两者之间没有直接的耦合关系。当然,静态代理类的方式更加符合面向对象原则,开发时具体使用哪种代理方式,就没有什么规定了。
3. Android 中的代理模式
在Android
中有ActivityManagerProxy
、ActivityManagerService
以及Retrofit
等均有代理模式的身影。这里以Retrofit
中的代理模式为例。
3.1 Retrofit中的代理模式(没有被代理者)
为了了解Retrofit
中的代理模式,首先需要先引入相关依赖到项目中:
// https://mvnrepository.com/artifact/com.squareup.retrofit2/retrofit
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
对于怎么使用在Retrofit的使用案例中曾简单的使用过这个框架。这里做一个简单的回顾:
- 定义指定具体的
URL
地址,来构造Retrofit
对象; - 使用第一步得到的
Retrofit
实例对象调用create
方法,当然这个方法中传入一个自定义的接口。在这个接口中完成链接返回数据转换为Java
实例对象。 - 类似的将请求加入到请求队列中,然后接收返回结果即可。
而在Retrofit
类中的create
方法中就可以看见动态代理模式:
public <T> T create(final Class<T> service) {
validateServiceInterface(service);
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service},
new InvocationHandler() {
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override
public @Nullable
Object invoke(Object proxy, Method method,
@Nullable Object[] args) throws Throwable {
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
}
比如此时的请求接口还是像Retrofit的使用案例文中定义的一样,即:
public interface RequestInterface {
@GET(value = "/test/1.0/users")
Call<List<User>> listUsers(); // retrofit2.Call;
@GET(value = "/test/1.0/users/{userid}")
Call<User> getUserById(@Path(value = "userid") char userId);
@FormUrlEncoded
@POST(value = "/test/1.0/users")
Call<Void> addUser(@Field(value = "name") String name);
}
那么在构造Retrofit
中的请求对象的时候,就在create
方法中传入这个接口的Class
对象:
RequestInterface request = retrofit.create(RequestInterface.class);
继续回到Retrofit
类的create
方法,可以发现生成的代理对象其实就是代理这个RequestInterface
接口。但是值得注意的是,RequestInterface
接口只是代理模式中的Subject
,而我们这里需要找到真正的被代理对象类。但是很遗憾确实这里没有找到,那么不妨来仿写一下:
interface ISubject {
void doSomething();
}
public class Client {
public static void main(String[] args) {
ISubject subject = (ISubject) Proxy.newProxyInstance(ISubject.class.getClassLoader(),
new Class[]{ISubject.class}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("invoke");
return 0;
}
});
System.out.println("package: \n\t" + subject.getClass().getName());
System.out.println("implemented interface: ");
Class<?>[] interfaces = subject.getClass().getInterfaces();
for (Class<?> anInterface : interfaces) {
System.out.println("\t"+anInterface.getName());
}
System.out.println("fields: ");
Field[] declaredFields = subject.getClass().getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("\t"+declaredField.getName());
}
System.out.println("methods: ");
Method[] declaredMethods = subject.getClass().getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("\t"+declaredMethod.getName());
}
subject.doSomething();
}
}
输出结果为:
在Retrofit2 源码解析之动态代理一文中给出了得到生成的动态代理类的字节码数组并存储为.class
文件的方式,即:
private static void storageClassFile(ISubject subject){
// subject 为上面生成的动态代理对象
String proxyName = subject.getClass().getName() + ".class";
byte[] clazz = ProxyGenerator.generateProxyClass(proxyName, new Class[]{ISubject.class});
try {
OutputStream out = new FileOutputStream(proxyName);
InputStream is = new ByteArrayInputStream(clazz);
byte[] buff = new byte[1024];
int len;
while ((len = is.read(buff)) != -1) {
out.write(buff, 0, len);
}
is.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
那么在这个项目的跟目录中可以看到生成的文件:
直接使用IDEA
来进行打开:
public final class class extends Proxy implements ISubject {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public class(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 doSomething() 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.example.scan.kaoshi.ISubject").getMethod("doSomething");
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());
}
}
}
可以看到这个类确实是实现类ISubject
接口的类,且实现了基本的hashCode
、toString
和equals
方法。但是因为在ProxyGenerator.generateProxyClass
方法存在于sun.misc.ProxyGenerator
包中,而Android
中并不支持这个包所以有必要继续看Retrofit
中的源码:
可以看到其实首先通过loadServiceMethod(method)
这个方法将调用的实际方法传递进去,然后在loadServiceMethod
方法中进行Map<Method, ServiceMethod<?>>
查找看是否已经存在这个方法,存在就直接返回,否则就通过ServiceMethod.parseAnnotations(this, method)
方法来对声明接口中的这个方法的注解进行解析,在这个方法中会继续解析注解,最终会使用HttpServiceMethod.parseAnnotations
方法来进行解析,由于代码比较多这里就不贴出来了。在这个方法中,首先得到这个方法的返回类型,然后使用Okhttp3
来进行请求的封装,并且得到这个方法的所有注解,并进行对应的解析。最终会返回一个HttpServiceMethod
对象到Retrofit.java
的create
方法。我们之后后续的使用和Okhttp
类似,也就是构建Call
对象以及请求加入到队列中。
所以在Retrofit
中不完全是代理模式,很容易理解,因为在这个过程中确实没有RealSubject
对象,而只存在接口和动态代理Proxy
的对象。也比较好理解,因为在网络请求过程中,我们定义RESTful
风格来进行请求链接和返回参数的定义,中间其实不需要一个真实的被代理类来实现这个请求,而是需要将其注解进行解析,得到实际有意义的请求参数和返回值类型,最终可以动态添加到Okhttp
请求和满足动态封装Bean
即可。
在这个过程中由程序自己来处理注解,以及完成请求API
的解析工作,进而可以在底层使用Okhttp
进行网络请求的时候可以对参数以及返回值进行相关的数据封装。所以说其实在Retrofit
中不完全是代理模式,因为没有(也不需要)实际上的被代理者。
4. 后记
在《Android源码设计模式》一书中提到:不少设计模式中都存在代理模式的影子,且在日常生活中无处不在。作者花了很大的篇幅来介绍这个模式,且在Binder
中也存在代理模式的影子,之后需要再仔细读读。
References