代理模式

代理模式的定义

为其他对象提供一种代理以控制对这个对象的访问

代理模式的使用场景

当无法或不想直接访问某个对象或访问某个对象存在困难的时候可以通过一个代理对象来间接访问，为保证客户端使用的透明性，委托对象与代理对象需要实现相同的接口。

UML类图

代理模式的简单实现

代理模式的例子在生活中可以找到很多，比如遇到老板克扣工资的情况，我们可以通过法律手段来解决，那么久需要请一名律师来作为自己的诉讼代理人，我们将诉讼的流程抽象在一个接口类中。

//诉讼接口类
public interface ILawsuit {
	void submit();//提交材料
	
	void burden();//诉讼
	
	void defend();//辩护
	
	void finish();//完成

}

//具体诉讼人
public class Hengly implements ILawsuit {

	public void submit() {
		System.out.println("老板克扣了我2个月工资，申请维护劳动者的利益");

	}

	public void burden() {
		System.out.println("我没有违反公司任何规定，没有理由克扣的工资，这是合同以及过去2个月的考勤记录");
	}

	public void defend() {
		System.out.println("证据确凿，不用多说什么");

	}

	public void finish() {
		System.out.println("诉讼成功，老板需要在7天内结算清工资，否则违反劳动法，追究刑事责任");
	}

}

//代理律师
public class Lawyer implements ILawsuit {
	private ILawsuit mLawsuit;//持有一个具体被代理者的引用
	
	public  Lawyer(ILawsuit  l){
		mLawsuit=l;
	}
	

	public void submit() {
		mLawsuit.submit();
	}

	public void burden() {
		mLawsuit.burden();
	}

	public void defend() {
		mLawsuit.defend();
	}

	public void finish() {
		mLawsuit.finish();
	}

}

律师类和具体的诉讼人都实现了相同的接口，律师所执行的方法就是简单调用被代理者中的方法。下面看看客户类中具体的调用执行关系。

public class Client {
	
	public static void main(String[] args) {
		ILawsuit hengly=new Hengly();
		Lawyer  lawyer=new Lawyer(hengly);
		
		lawyer.submit();
		lawyer.burden();
		lawyer.defend();
		lawyer.finish();
	}

}

运行结果很简单就不用给出了，可以看到其实代理模式很简单，其主要还是一种委托的机制，真实对象将方法的执行委托给代理对象，这其实也就是静态代理：代理者的代码有程序员自己或一些自动化的工具生成固定的代码再进行编译，也就是说在我们代码运行之前代理类的class编译文件就已经存在。而动态代理与静态代理不同，通过反射机制动态的生成代理者的对象，也就是说我们在code阶段压根就不需要知道代理谁，代理谁我们会在执行阶段决定。而Java也给我们提供了一个便捷的动态代理接口InvocationHandler，实现该接口需要重写其调用方法invoke.

public class DynamicProxy implements InvocationHandler {
	private Object tag;//持有被代理类的引用
	
	public DynamicProxy(Object obj){
		tag=obj;
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// 调用被代理类对象的方法
		Object result=method.invoke(tag, args);
		return result;
	}

}

如上代码所诉我们声明了一个Object的引用，该引用指向被代理类，而我们调用被代理类的具体方法则在invoke方法中执行。

public class Client {
	
	public static void main(String[] args) {
		ILawsuit hengly=new Hengly();
		
		DynamicProxy  proxy=new DynamicProxy(hengly);
		
		ClassLoader   loader=hengly.getClass().getClassLoader();
		
		ILawsuit  lawyer=(ILawsuit)Proxy.newProxyInstance(loader, new Class[]{ILawsuit.class}, proxy);
		
		lawyer.submit();
		lawyer.burden();
		lawyer.defend();
		lawyer.finish();
	}

}

运行结果：

老板克扣了我2个月工资，申请维护劳动者的利益
我没有违反公司任何规定，没有理由克扣的工资，这是合同以及过去2个月的考勤记录
证据确凿，不用多说什么
诉讼成功，老板需要在7天内结算清工资，否则违反劳动法，追究刑事责任

Retrofit源码中的动态代理

我们发现使用retrofit需要去定义一个接口，然后通过调用retrofit.create(XXX.class)方法，得到一个接口的实例，最后通过这个实例去实现我们的操作。

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, 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 serviceMethod = loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

到这里，你应该明白retrofit为我们接口生成实例对象并不神奇，仅仅是使用了Proxy这个类的API而已，然后在invoke方法里面拿到足够的信息去构建最终返回的Call而已。

具体的retrofit源码分析，会再讲述，这边就到此结束。