4 结构型模式之 - 代理模式

Posted 2020-09-14

代理模式的介绍：代理模式也称为委托模式，在开发中经常用到，是编程的好帮手，在日常生活中也比较常见。比如公司中午让同事帮忙带一份饭，比如我们请一个律师打官司，比如我们用代理服务器上网等等。代理模式真是无处不在。

代理模式的定义：为其它对象提供一种代理以控制对这个对象的访问。

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

 

代理模式一般的写法（静态代理模式）：

代理类和被代理类共同的一个接口：

 1 /**
 2  *
 3  * 抽象角色
 4  *
 5  * 该类的主要职责是声明真实主题与代理的共同接口方法
 6  * 该类既可以是一个抽象类也可以是一个接口
 7  *
 8  */
 9 public abstract class Subject {
10 
11     public abstract void visit();
12 }

 

一个真实的角色，也就是被代理类：

 1 /**
 2  * 真实角色
 3  *
 4  * 该类也称为被委托类或被代理类，该类定义了代理所表示的真实对象
 5  * 由其执行具体的业务逻辑方法，而客户类则通过代理类间接地调用真实主题类中定义的方法
 6  *
 7  */
 8 public class RealSubject extends Subject{
 9     @Override
10     public void visit() {
11 
12     }
13 }

 

实现一个代理类：

 1 /**
 2  *
 3  * 代理类
 4  * 委托对象与代理对象需要实现相同的接口
 5  * 该类也被称为委托类或者代理类，该类持有一个对真实主题的类的引用
 6  * 在其所实现的接口方法中调用真实主题类中相应的接口方法执行，以此起到代理的作用
 7  *
 8  *
 9  */
10 public class ProxySubject extends Subject{
11     Subject realSubject = null;
12 
13     public ProxySubject(Subject realSubject){
14         this.realSubject = realSubject;
15     }
16 
17     @Override
18     public void visit() {
19         preRequest();           //真实角色前
20         realSubject.visit();
21         postRequest();          //真实角色后
22     }
23 
24 
25     private void preRequest(){
26     }
27 
28     private void postRequest(){
29     }
30 
31 }

 

客户端测试类：

/**
 *
 * 客户类，即使用代理类的类型
 */
public class ProxyTest {

    public static void test(){
        //构造一个真实对象
        Subject realSubject = new RealSubject();

        //通过一个真实对象构造一个代理对象
        Subject proxy = new ProxySubject(realSubject);

        //调用代理对象的相关方法
        proxy.visit();

    }

}

上面是静态代理模式的一般实现流程，我们今天讲的都是静态代理模式。

上面的流程不够真实，我们来举一个更具体的例子，比如生活中的打官司。

小明是某一个公司的员工，老板欠了小明半年的工资，无奈之下，小明请了一个律师将老板告上了法庭

首先，需要有一个抽象的接口：

 1 /**
 2  * 诉讼接口类
 3  * 4个方法很简单，诉讼的一般流程
 4  */
 5 public interface ILawsuit {
 6     //提交申请
 7     void submit();
 8     //进行举证
 9     void burden();
10     //开始辨护
11     void defend();
12     //诉讼完成
13     void finish();
14 }

 

需要有一个小明：

 1 /**
 2  *  被代理者,小明
 3  */
 4 public class XiaoMin implements ILawsuit{
 5     @Override
 6     public void submit() {
 7         //老板欠小明一个月工资，小明只好申请仲裁
 8         System.out.println("老板拖欠工资，特此申请仲裁");
 9     }
10 
11     @Override
12     public void burden() {
13         //小明证明充分，不怕告不赢
14         System.out.println("这是合同和过去一年的银行流水");
15     }
16 
17     @Override
18     public void defend() {
19         //铁证如山，辩护也没有什么好说的
20         System.out.println("证据充分，不用再说什么了");
21     }
22 
23     @Override
24     public void finish() {
25         //结果也是肯定的，必赢
26         System.out.println("诉讼成功，判决老板即日起七天内结算工资");
27     }
28 }

需要有一个代理律师来代理小明打官司

 1 /**
 2  * 代理律师
 3  */
 4 public class Lawyer implements ILawsuit{
 5     //持有一个具体的被代理者的引用
 6     private ILawsuit mLawsuit;
 7 
 8     public Lawyer(ILawsuit lawsuit){
 9         mLawsuit = lawsuit;
10     }
11 
12     @Override
13     public void submit() {
14         mLawsuit.submit();
15     }
16 
17     @Override
18     public void burden() {
19         mLawsuit.burden();
20     }
21 
22     @Override
23     public void defend() {
24         mLawsuit.defend();
25     }
26 
27     @Override
28     public void finish() {
29         mLawsuit.finish();
30     }
31 }

客户端怎么用呢？下面是客户端类：

 1 /**
 2  * 客户端类
 3  */
 4 public class Client {
 5 
 6     public static void main(String[] args){
 7         //构造一个小明
 8         ILawsuit xiaomin = new XiaoMin();
 9 
10         //构造一个律师并将小明作为构造参数传递进去
11         ILawsuit lawyer = new Lawyer(xiaomin);
12 
13         //律师提交诉讼
14         lawyer.submit();
15 
16         //律师进行举证
17         lawyer.burden();
18 
19         //律师代替小明进行辩护
20         lawyer.defend();
21 
22         //完成诉讼
23         lawyer.finish();
24     }
25 
26 }

运行结果如下：

老板拖欠工资，特此申请仲裁
这是合同和过去一年的银行流水
证据充分，不用再说什么了
诉讼成功，判决老板即日起七天内结算工资