Android设计模式—代理模式

我就是我 2022-09-14 09:57 187阅读 0赞

1.代理模式  
代理模式也是平时比较常用的设计模式之一。所谓代理模式就是在进行交互的时候，不和原本的对象直接交互，而是通过代理的方式，用代理来代替真正的对象进行交互，这样做的好处是降低了耦合性。代理对象起到了中介作用，不涉及功能服务，但可增加额外的服务。  
代理模式其实就是提供了一个新的对象,实现了对真实对象的操作,或成为真实对象的替身。在日常生活中也是很常见的。例如A要租房,为了省麻烦A会去找中介,中介会替代A去筛选房子,A坐享中介筛选的结果,并且交房租也是交给中介,这就是一个典型的日常生活中代理模式的应用。平时打开网页,最先开到的一般都是文字,而图片等一些大的资源都会延迟加载,这里也是使用了代理模式。

代理模式应用场景：  
①当一个对象不能或者不想直接访问另一个对象时，可以通过一个代理对象来间接访问。为保证客户端使用的透明性，委托对象和代理对象要实现同样的接口  
②被访问的对象不想暴露全部内容时，可以通过代理去掉不想被访问的内容。

代理模式中的角色：  
①Client 客户类，即使用代理类的类  
②Subject 抽象主题类，抽象了代理行为  
主要职责是声明真实主题与代理的共同接口关系，该类既可以是一个抽象类也可以是一个接口。  
③RealSubject 实现抽象主题的真实主题类  
被委托类或被代理类，定义了代理所表示的真实对象，由其执行具体的业务逻辑方法，而客户端则通过代理类间接地调用真实主题类中定义的方法。  
④Proxy 委托类或代理类  
持有对真实主题类的引用，可以访问真实实体  
提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体。  
控制对实体的存取，并可能负责创建或者删除它

一句话，代理模式就是给目标对象提供一个代理对象，并由代理对象控制对目标对象的访问。  
代理模式分为静态代理和动态代理（静态代理应用的不多，因为违反了开闭原则，动态代理才是主流）。  
为什么要用代理模式呢？因为代理模式十分符合java开发的开放原则，避免大幅度修改原先的代码，只是在原有的基础上进行扩展。概括起来说有两点：  
①通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来不必要复杂性。  
②通过代理对象可以对原有的业务进行扩展。  
看下面这个类图，一目了然：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70]  
2.静态代理  
代理对象和被代理对象在代理之前都是被确定的，他们都实现相同的接口或者继承相同的抽象类。  
静态代理需要创建一个和真实对象相同的类，将真实的对象当作参数传入到代理中，当外界通过代理进行操作的时候，代理中的真实对象也会进行相应的操作。  
步骤很简单：  
①创建接口，定义共同方法。  
②创建真实类，实现接口  
③创建代理类，实现接口，但是增加一步，在构造方法中将真实对象的引用当作参数，拿到真实对象。在真实对象的方法调用之前和之后可以进行扩展。  
④得到代理对象，通过对代理对象操作，实现对真实对象的相应操作  
举例如下：  
//定义接口  
public interface IHouse \{  
void getHouseInfo();  
void signContract();  
void payFees();  
\}

//接下来定义真实主题,并实现IHouse接口。  
增加房屋名称和价格两个属性,填充接口方法,在获取房屋信息的时候就把房屋名称和价格log出来;签合同的时候log出签合同的时间,付租金的时候log出价格。  
public class House implements IHouse\{  
private String name;  
private double price;

public House(String name, double price)\{  
this.name = name;  
this.price = price;  
\}

@Override  
public void getHouseInfo() \{  
Log.i(TAG, “House Info- name:” + name + " ￥:" + price);  
\}

@Override  
public void signContract() \{  
Log.i(TAG, “Contract:” + name + " signed at" + new SimpleDateFormat(“HH:mm:ss”).format(SystemClock.uptimeMillis()));  
\}

@Override  
public void payFees() \{  
Log.i(TAG, “Bill: name-” + name + " $-" + price);  
\}  
\}

//定义房屋代理,同样需要实现IHouse接口,并持有House的引用。  
可以看到我们在构造方法里创建了一个真实对象House的实现类对象，在调用proxy的getHouseInfo()方法时，实际是调用的真实对象House的getHouseInfo()方法，但是经常我们会附加一些逻辑在里面，比如我们打印一些log，直接在proxy的方法里添加就可以。这样做的好处就是真正实现类的逻辑不用做任何改变即可实现。  
public class ProxyHouse implements IHouse\{  
private IHouse house;  
public ProxyHouse(IHouse house)\{  
this.house = house;  
\}  
@Override  
public void getHouseInfo() \{  
Log.i(TAG, “searching”);  
house.getHouseInfo();  
Log.i(TAG, “search finished”);  
\}

@Override  
public void signContract() \{  
Log.i(TAG, “prepare contract”);  
house.signContract();  
\}

@Override  
public void payFees() \{  
house.payFees();  
\}  
\}

对于客户来说,完全不用跟House进行直接交互,这里先定义一个房子叫唐顿庄园,租金5k,建立一个房屋代理,把唐顿庄园委托给代理.客户要找房子,签合同,付租金直接找代理就行了.  
IHouse house = new House(“Downton Abbey”, 5000);  
IHouse proxyHouse = new ProxyHouse(house);  
Log.i(TAG, “looking for a perfect house”);  
proxyHouse.getHouseInfo();  
Log.i(TAG, “thinking”);  
proxyHouse.signContract();  
proxyHouse.payFees();  
Log.i(TAG, “so easy”);  
整个代理模式的流程可以从下面的时序图展示出来。Client只跟代理进行交互。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 1]  
写到这里可能有人会有疑问，我直接创建House的实现类，调用getHouseInfo()方法和你在代理中再创建调用有啥区别，反而增加了类和代码。但是不要忘记了Android的设计模式有六大原则：单一职责原则、里氏替换原则、依赖倒置原则、接口隔离原则、迪米特原则、开闭原则。因此如果直接用House调用getHouseInfo()方法，就不符合我们设计模式的六大原则。

静态代理都是自己先写好的代理类，这样的代理关系都是固定的，当代理多个真实对象的时候就要写多个代理类，并且会产生冗余的代码，扩展性和可维护性都不高，也就是静态代理违反了设计模式的开闭原则。打个比方，现在又来了一个顾客他想买车位，代理对象是不是现在不能满足这个需求，是不是只有扩展目标对象，代理对象才可以有车位卖，这样一来一共就那么几个文件，全得修改一遍，那要是人家想买一堆杂七杂八的，可想而知。。。。。这时候就要用到动态代理了。

3.动态代理  
动态代理是基于反射实现了在程序运行的过程中才决定代理什么对象。既然是动态代理就不需要ProxyHouse，也不需要IHouse接口了。动态代理有俩个关键的字段，一个是proxy，一个是invocationHandler，前者你可以理解为是是通过这个proxy获取到动态代理对象，后者则可以理解成拓展的需求服务啥啥的。  
先简单介绍一下InvocationHandler类：  
//该类经常称之为事务处理类  
public class xxx implements InvocationHandler \{

@Override  
public Object invoke(Object proxy, Method method, Object\[\] args) throws Throwable \{  
return null;  
\}  
\}  
InvocationHandler是个接口，只有一个抽象方法 invoke(Object proxy, Method method, Object\[\] args)，四个参数的意义：  
param proxy 代理类;  
param method 被代理的方法;  
param args 被代理方法的参数;  
return 方法的返回值;

其次就是我们的Proxy即动态代理类，它当中有个方法：Proxy.newProxyInstance(ClassLoader loader,Class<?>\[ \] interfaces, InvocationHandler h)。

这里写一个ProxyHandler实现InvocationHandler的invoke接口,并且提供一个根据Proxy构建出来的代理实例给Custom.在通过反射调用真实对象具体的方法之前打印出该方法的名字.  
public class ProxyHandler implements InvocationHandler\{  
Object targetObj;

public Object newProxyInstance(Object targetObj)\{  
this.targetObj = targetObj;  
return Proxy.newProxyInstance(targetObj.getClass().getClassLoader(),  
targetObj.getClass().getInterfaces(), this);  
\}

@Override  
public Object invoke(Object proxy, Method method, Object\[\] args) throws Throwable \{  
Object ret;  
Log.i(TAG, “method name:” + method.getName());  
ret = method.invoke(targetObj, args);  
return ret;  
\}  
\}

client类：  
ProxyHandler proxy = new ProxyHandler();  
IHouse house = (IHouse) proxy.newProxyInstance(new House(“Downton Abbey”, 5000));  
Log.i(TAG, “looking for a perfect house”);  
house.getHouseInfo();  
Log.i(TAG, “thinking”);  
house.signContract();  
house.payFees();  
Log.i(TAG, “so easy”);  
从结果可以看出在真正invoke真实对象的方法之前都会打印出方法名,也可以在这里做一些其他的对象控制.  
![在这里插入图片描述][20211010114658967.png]  
这个时候整个过程的时序图就变成下面的样子了,通过JDK的Proxy对象和反射的机制来支撑起来动态代理的核心功能.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 2]  
此时如果需要车位的代理，可以直接定义一个车位的真实类，然后直接在client类中将House改为车位类即可，动态代理类共用一个。

4.动态+保护代理  
这里就以 ProxyA 和 ProxyB 两个代理类为例，一个只能调用 operationA 方法，另一个只能调用 operationB 方法。首先来看看 Subject 和 RealSubject 类：  
Subject.class如下：  
public interface Subject \{  
String operationA();  
String operationB();  
\}

RealSubjct.class如下：  
public class RealSubject implements Subject\{  
@Override  
public String operationA() \{  
return “this is operationA”;  
\}

@Override  
public String operationB() \{  
return “this is operationB”;  
\}  
\}

定义完了抽象主题类和真实主题类之后，开始构造代理类，首先是代理类的虚基类ISubjectProxy.class：  
public abstract class ISubjectProxy implements InvocationHandler \{  
protected Subject subject;  
public ISubjectProxy(Subject subject) \{  
this.subject = subject;  
\}  
\}

然后是 ProxyA 和 ProxyB 这两个代理子类：  
ProxyA.class如下：  
public class ProxyA extends ISubjectProxy\{  
public ProxyA(Subject subject) \{  
super(subject);  
\}

@Override  
public Object invoke(Object proxy, Method method, Object\[\] args) throws Throwable \{  
if (method.getName().equals(“operationB”))\{  
throw new UnsupportedOperationException(“ProxyA can’t invoke operationB”);  
\} else if (method.getName().equals(“operationA”)) \{  
return method.invoke(subject, args);  
\}  
return null;  
\}  
\}

ProxyB.class如下：  
public class ProxyB extends ISubjectProxy\{  
public ProxyB(Subject subject) \{  
super(subject);  
\}

@Override  
public Object invoke(Object proxy, Method method, Object\[\] args) throws Throwable \{  
if (method.getName().equals(“operationA”))\{  
throw new UnsupportedOperationException(“ProxyB can’t invoke operationA”);  
\} else if (method.getName().equals(“operationB”)) \{  
return method.invoke(subject, args);  
\}  
return null;  
\}  
\}

最后是 Client 的代码：  
Subject subject = new RealSubject();  
ISubjectProxy proxy = null;  
switch (v.getId()) \{  
case R.id.proxy\_a:  
proxy = new ProxyA(subject);  
break;  
case R.id.proxy\_b:  
proxy = new ProxyB(subject);  
break;  
\}  
Subject sub = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(),  
subject.getClass().getInterfaces(), proxy);  
try \{  
Log.e(“Shawn”, sub.operationA());  
\}catch (UnsupportedOperationException e)\{  
Log.e(“Shawn”, e.getMessage());  
\}  
try \{  
Log.e(“Shawn”, sub.operationB());  
\}catch (UnsupportedOperationException e)\{  
Log.e(“Shawn”, e.getMessage());  
\}  
运行结果如下：  
com.android.proxypattern E/Shawn: this is operationA  
com.android.proxypattern E/Shawn: ProxyA can’t invoke operationB  
com.android.proxypattern E/Shawn: ProxyB can’t invoke operationA  
com.android.proxypattern E/Shawn: this is operationB  
代码很简单，第一点是使用 InvocationHandler 实现了动态代理，第二点是根据 method 的名字实现了保护代理。

5.静态代理和动态代理比较  
静态代理缺点：  
①静态代理如果接口新增一个方法，除了所有实现类（真实主题类）需要实现这个方法外，所有代理类也需要实现此方法，增加了代码维护的复杂度。  
②代理对象只服务于一种类型的对象，如果要服务多类型的对象，必须要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。

动态代理的优点：  
①可以通过一个代理类完成全部的代理功能。接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。当接口方法数量较多时，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。  
②动态代理的应用使类的职责更加单一，复用性更强。  
动态代理的缺点：  
①不能对类进行代理，只能对接口进行代理，如果我们的类没有实现任何接口，那么就不能使用这种方式进行动态代理。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70]: /images/20220828/dd7ce48a602b472ab25528a4d0915e6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 1]: /images/20220828/917b0dae40494caab3b1062c85dbf5d6.png
[20211010114658967.png]: /images/20220828/7fc053432c6b4820b5d2b455722f6737.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 2]: /images/20220828/122d8fed0227416ab7602f439b94c67f.png