定义
为其他对象提供一种代理以控制对这个对象的访问
使用场景
当无法或不想直接访问某个对象，或者访问某个对象困难时，可以通过某个代理对象间接访问。为了保证客户端使用的透明性，委托对象与代理对象需要实现相同的接口。
角色介绍
Subject：抽象主题类
该类的主要职责是声明真实主题与代理的共同接口方法，该类既可以一个抽象类，也可以是一个抽象接口
RealSubject:真实主题类
该类也称为被委托类或被代理类，该类定义了代理所表示的真实对象，由其执行具体的业务逻辑方法， 而客户类则通过代理类间接地调用真实主题类中定义的方法。
ProxySubject:代理类
该类也称为委托类或代理类，该类持有一个对真实主题类的引用，在其所实现的接口方法中调用真实主题类中相应的接口方法执行，以此起到代理的作用
Client:客户类，即使用代理类的类型
示例代码：
//抽象主题
public interface ILawsuit {
//提交申请
void submit();
//进行举证
void burden();
//开始辩护
void defend();
//诉讼完成
void finish();
}
//真实主题类
public class XiaoMin implements ILawsuit{
@Override
public void submit() {
System.out.println("老板拖欠工资，特此申请仲裁！");
}
@Override
public void burden() {
System.out.println("这是合同书和过去一年的银行工资流水！");
}
@Override
public void defend() {
System.out.println("证据确凿，不需要再说什么了！");
}
@Override
public void finish() {
System.out.println("诉讼成功，判决老板即日起七天结算工资");
}
}
//代理类
public class Lawyer implements ILawsuit{
private ILawsuit mLawsuit;//持有一个具体被代理者的引用
public Lawyer(ILawsuit lawsuit){
mLawsuit = lawsuit;
}
@Override
public void submit() {
mLawsuit.submit();
}
@Override
public void burden() {
mLawsuit.burden();
}
@Override
public void defend() {
mLawsuit.defend();
}
@Override
public void finish() {
mLawsuit.finish();
}
}
//客户类
public class Client {
public static void main(String[] args){
//构造一个小民
ILawsuit xiaomin = new XiaoMin();
//构造一个代理律师，并将小民作为构造参数传递进去
ILawsuit lawyer = new Lawyer(xiaomin);
//律师提交诉讼申请
lawyer.submit();
//律师进行举证
lawyer.burden();
//律师代替小民进行辩护
lawyer.defend();
//完成诉讼
lawyer.finish();
}
}
代理模式分为两种：
- 静态代理：代码运行前代理类的class编译文件就已经存在
- 动态代理：通过反射机制动态地生成代理者的对象，也就是我们在code阶段压根就不需要知道代理谁，代理谁我们将会在执行阶段决定，而Java也给我们提供了一个便捷的动态代理接口InvocationHandler,实现该接口需要重写其调用方法invoke.
public class DynamicProxy implements InvocationHandler{
private Object obj; //被代理的类引用
public DynamicProxy(Object obj){
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(obj,args);
return result;
}
}
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args){
//构造一个小民
ILawsuit xiaomin = new XiaoMin();
// //构造一个代理律师，并将小民作为构造参数传递进去
// ILawsuit lawyer = new Lawyer(xiaomin);
DynamicProxy proxy = new DynamicProxy(xiaomin);
//获取被代理类小民的classLoader
ClassLoader loader = xiaomin.getClass().getClassLoader();
//动态构造一个代理者律师
ILawsuit lawyer = (ILawsuit) Proxy.newProxyInstance(loader,new Class[]{ILawsuit.class},proxy);
//律师提交诉讼申请
lawyer.submit();
//律师进行举证
lawyer.burden();
//律师代替小民进行辩护
lawyer.defend();
//完成诉讼
lawyer.finish();
}
}
我们在Android项目中使用第三方库Retrofit，使用就是代理模式
ApiService service = retrofit.create(ApiService.class); //创建一个代理实例
我们点进去create方法看看
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(service);
}
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
private final Platform platform = Platform.get();
@Override public 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);
}
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
可以看到，也是通过Proxy.newProxyInstance生成了一个代理类。
