设计模式-代理模式（Proxy Pattern）
定义
为其他对象提供一种代理以控制对这个对象的访问
按照代理的创建时期，代理类可以分为两种：
静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
动态代理：在程序运行时运用反射机制动态创建而成。
使用场景
主要作用：控制对象访问
- 扩展目标对象的功能：例如演员（目标对象），有演戏的功能，找一个经纪人（代理），会额外提供收费的功能，实际上是代理的功能，而不是演员的功能。
- 限制目标对象的功能：例如经纪人对收费不满意，只让演员演一场戏，对演员的功能进行了部分限制。
类图
- Subject：抽象主题角色，主要是声明代理类和被代理类共同的接口方法
- RealSubject：具体主题角色（被代理角色），执行具体的业务逻辑
- Proxy：代理类，持有一个被代理对象的引用，负责在被代理对象方法调用的前后做一些额外操作
4、优点
- 职责清晰，被代理角色只实现实际的业务逻辑，代理对象实现附加的处理逻辑
- 扩展性高，可以更换不同的代理类，实现不同的代理逻辑
静态代理
编译时期就已经存在，一般首先需要定义接口，而被代理的对象和代理对象一起实现相同的接口。
1、接口定义：
public interface Play {
//唱歌
void sing(int count);
//演出
void show();
}
2、演员（被代理对象）：
public class Actor implements Play {
@Override
public void sing(int count) {
System.out.print("唱了" + count + "首歌");
}
@Override
public void show() {
System.out.print("进行演出");
}
}
被代理对象提供了几个具体方法实现
3、经纪人（代理对象）：
public class Agent implements Play {
//被代理对象
private Play player;
private long money;
public void setMoney(long money){
this.money = money;
}
/**
* @param player
* @param money 收费
*/
public Agent(Play player, long money) {
this.player = player;
this.money = money;
}
@Override
public void sing(int count) {
player.sing(count);
}
//控制了被代理对象的访问
@Override
public void show() {
if (money > 100) {
player.show();
} else {
System.out.println("baibai...");
}
}
}
4、使用
public class PlayTest {
public static void main(String[] args){
Actor actor = new Actor();
Agent agent = new Agent(actor, 50);
agent.sing(2);
agent.show();
agent.setMoney(200);
agent.show();
}
}
代理对象通过自身的逻辑处理对目标对象的功能进行控制。
动态代理
动态一般指的是在运行时的状态，是相对编译时的静态来区分，就是在运行时生成一个代理对象帮我们做一些逻辑处理。主要使用反射技术获得类的加载器并且创建实例。
动态代理可以在运行时动态创建一个类，实现一个或多个接口，可以在不修改原有类的基础上动态为通过该类获取的对象添加方法、修改行为。
1、生成动态代理类：
InvocationHandler是动态代理接口，动态代理类需要实现该接口，并在invoke方法中对代理类的方法进行处理
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
参数说明：
- Object proxy：被代理的对象
- Object[] args：要调用的方法
- Object[] args：方法调用所需要的参数
2、创建动态代理类
Proxy类可以通过newProxyInstance创建一个代理对象
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException {
if (h == null) {
throw new NullPointerException();
}
Class<?> cl = getProxyClass0(loader, interfaces);
try {
//通过反射完成了代理对象的创建
final Constructor<?> cons = cl.getConstructor(constructorParams);
return newInstance(cons, h);
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
}
}
参数说明：
- ClassLoader loader：类加载器
- Class<?>[] interfaces：所有的接口
- InvocationHandler h：实现InvocationHandler接口的子类
3、动态代理demo：
（1）定义动态代理类
public class ActorProxy implements InvocationHandler {
private Play player;
public ActorProxy(Play player) {
this.player = player;
}
/**
* 获取动态代理对象
*/
public Object getDynamicProxy() {
return Proxy.newProxyInstance(player.getClass().getClassLoader(), player.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//处理被代理对象的方法实现
if ("show".equals(method.getName())) {
System.out.println("代理处理show....");
return method.invoke(player, null);
} else if ("sing".equals(method.getName())) {
System.out.println("代理处理sing....");
return method.invoke(player, 2);
}
return null;
}
}
代理类实现InvocationHandler接口，在invoke方法中对player（被代理对象）做相应的逻辑处理。
（2）使用
public class ProxyTest {
public static void main(String[] args) {
ActorProxy actorProxy = new ActorProxy(new Actor());
//通过调用Proxy.newProxyInstance方法生成代理对象
Play proxy = (Play) actorProxy.getDynamicProxy();
//调用代理类相关方法
proxy.show();
proxy.sing(3);
}
}
四、Android中的代理模式
Retrofit代理模式
（1）Retrofit使用： 定义接口
public interface MyService {
@GET("users/{user}/list")
Call<String> getMyList(@Path("user") String user);
}
新建retrofit对象，然后产生一个接口对象，然后调用具体方法去完成请求。
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://xxx.com")
.build();
MyService myService = retrofit.create(MyService.class);
Call<String> myList = myService.getMyList("my");
retrofit.create方法就是通过动态代理的方式传入一个接口，返回了一个对象
（2）动态代理分析：
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();
private final Object[] emptyArgs = new Object[0];
@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
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
}
通过Proxy.newProxyInstance，该动态代理对象可以拿到请求接口实例上所有注解，然后通过代理对象进行网络请求。
