本文参考《Android源码设计模式解析与实战第2版》
-
代理模式的定义
代理模式也称为委托模式，是为其他对象提供代理以控制这个对象的访问。
-
代理模式的使用场景
无法或不想直接访问某个对象，或者访问某个对象困难时可以通过代理对象来实现间接访问。
-
代理模式的角色
- Subject：抽象主题-声明真实主题和代理的共同接口方法（事情执行步骤）
- RealSubject：真实主题类-该类表示所代理的真实对象（事情执行步骤的具体实现）
- ProxySubject：代理类-该类持有真实主题类的引用，在其所实现的接口方法中调用真实主题类中相应的接口方法执行，以实现代理的目的
- Client：代理模式的执行逻辑
-
代理模式的简单实现
使用代理模式实现一个诉讼过程，律师极为代理
定义诉讼流程（抽象主题-Subject）可以是接口也可以是抽象方法
/**
* 抽象主题：
* 定义诉讼的流程
*/
interface ILawsuit {
/**
* 提交申请
*/
void submit();
/**
* 进行举证
*/
void burden();
/**
* 开始辩护
*/
void defend();
/**
* 诉讼完成
*/
void finish();
}
定义具体对象(真实主题类-RealSubject)，即被代理对象
/**
* 真实主题类：
* 被代理的真实对象，执行步骤的具体实现
*/
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("诉讼成功！");
}
}
定义代理律师（代理类-ProxySubject）代理类中需要持有真实对象的实现，并且实现诉讼流程接口
/**
* 代理类
* 通过持有的真实对象和实现事件流程接口来实现代理功能
*/
class Lawyer implements ILawsuit{
private XiaoMin xiaoMin;//持有真实对象的引用
public Lawyer(XiaoMin xiaoMin) {
this.xiaoMin = xiaoMin;
}
@Override
public void submit() {
xiaoMin.submit();
}
@Override
public void burden() {
xiaoMin.burden();
}
@Override
public void defend() {
xiaoMin.defend();
}
@Override
public void finish() {
xiaoMin.finish();
}
}
定义代理模式的执行逻辑(具体执行-Client)
class Client {
public static void main(String[] args) {
initStaticProxy();
}
/**
* 静态代理使用
*/
private static void initStaticProxy(){
//构建具体对象
XiaoMin xiaoMin = new XiaoMin();
//构造代理律师对象
ILawsuit lawyer = new Lawyer(xiaoMin);
//通过代理律师执行具体诉讼逻辑
lawyer.submit();
lawyer.burden();
lawyer.defend();
lawyer.finish();
}
}
-
动态代理的实现
动态代理是通过实现InvocationHandler接口，反射调用被代理者方法，使得编译阶段不需要知道具体代理谁，运行时阶段再确定代理谁，实现了代理类的复用。
动态代理类的具体实现：
**
* 动态代理的实现
* 主要是实现InvocationHandler接口
* 通过invoke方法反射调用具体对象（被代理的对象）的方法
*/
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;
}
}
动态代理的具体使用：
class Client {
public static void main(String[] args) {
initDynamicProxy();
}
/**
* 动态代理的使用
*/
private static void initDynamicProxy(){
//构造具体对象
XiaoMin xiaoMin = new XiaoMin();
//构造动态代理
DynamicProxy dynamicProxy = new DynamicProxy(xiaoMin);
//获取被代理类的classLoader
ClassLoader loader = xiaoMin.getClass().getClassLoader();
//构造具体的代理律师
ILawsuit lawyer = (ILawsuit) Proxy.newProxyInstance(loader,new Class[]{ILawsuit.class},dynamicProxy);
//通过代理律师执行具体诉讼逻辑
lawyer.submit();
lawyer.burden();
lawyer.defend();
lawyer.finish();
}
}
静态代理和动态代理的区别：
本质区别：静态代理的代理者一般由程序员手动实现，也就是编译阶段class的的编译文件就已经存在，动态代理是通过反射机制动态地生成代理者对象，所以
编译阶段根本不知道代理谁，到底代理谁是在运行时阶段决定。
具体区别：
1.动态代理代理对象不明确，可以复用，一个代理类可以代理多个被代理类
2.动态代理通过反射调用被代理对象方法，需要实现InvocationHandler接口
总结：
不论是静态代理还是动态代理只是实现手法不同，其思想都是一致的，简单说就是：
真实对象的所有事物，全权交给代理对象去处理。
