图解设计模式------Proxy（代理）模式

╰半橙微兮° 2022-10-13 12:49 175阅读 0赞

## 一、Proxy模式 ##

Proxy是“代理人”的意思，它指的是代替别人进行工作的人。当不一定需要本人亲自进行工作时，就可以寻找代理人去完成工作。但代理人毕竟只是代理人，能代替本人做的事情终究是有限的。因此，当代理人遇到无法自己解决的事情时就会去找本人解决该问题。  
    在面向对象编程中，“本人”和“代理人”都是对象。如果“本人”对象太忙了，有些工作无法自己亲自完成，就将其交给“代理人”对象负责。

## 二 、示例程序 ##

下面我们来看一段使用了 Proxy模式的示例程序。这段示例程序实现了一个“带名字的打印机”。说是打印机，其实只是将文字显示在界面上而已。在Main类中会生成Printerproxy类的实例（即“代理人首先我们会给实例赋予名字Alice并在界面中显示该名字。接着会将实例名字改为Bob,然后显示该名字。在设置和获取名字时，都不会生成真正的Printer类的实例（即本人），而是由PrinterProxy类代理。最后，直到我们调用print方法，开始进入实际打印阶段后，Printerproxy类才会生成Printer类的实例。示例程序的类图请参见图2E ,时序图请参见图21-2o  
    为了让PrinterProxy类与Printer类具有一致性，我们定义了 Printable接口。示例程序的前提是“生成Printer类的实例”这一处理需要花费很多时间。为了在程序中体现这一点,我们在Printer类的构造函数中调用了 heavyJob方法，让它干一些“重活”（虽说是重活，也不过是让程序睡眠5秒钟）

<table> 
 <thead> 
  <tr> 
   <th>名字</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Printer</td> 
   <td>表示带名字的打印机的类（本人）</td> 
  </tr> 
  <tr> 
   <td>Printable</td> 
   <td>Printer和Printable的共同接口</td> 
  </tr> 
  <tr> 
   <td>Printerproxy</td> 
   <td>表示带名字的打印机类（代理人）</td> 
  </tr> 
  <tr> 
   <td>Main</td> 
   <td>测试程序行为的类</td> 
  </tr> 
 </tbody> 
</table>

类和接口的一览表

示例程序类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center]  
示例程序的时序图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center 1]  
**Pronter类**

*  Printer类是表示“本人”的类。
 *  在之前的学习中我们也了解到了，在它的构造函数中，我们让它做一些所谓的“重活“（heavyJob）。
 *  setPrinterName方法用于设置打印机的名字；getPrinterName用于获取打印机的名字。
 *  print方法则用于显示带一串打印机名字的文字。
 *  heavyJob是一个干5秒钟“重活”的方法，它每秒（ 1000毫秒）以点号（.）显示一次干活的进度。
 *  Proxy模式的核心是Printerproxy类。Printer类自身并不难理解。

代码：

public class Printer implements Printable { 
        private String name;
        public Printer() { 
            heavyJob("正在生成Printer的实例");
        }
        public Printer(String name) {                    // 构造函数
            this.name = name;
            heavyJob("正在生成Printer的实例(" + name + ")");
        }
        public void setPrinterName(String name) {        // 设置名字
            this.name = name;
        }
        public String getPrinterName() {                 // 获取名字
            return name;
        }
        public void print(String string) {               // 显示带打印机名字的文字
            System.out.println("=== " + name + " ===");
            System.out.println(string);
        }
        private void heavyJob(String msg) {              // 重活
            System.out.print(msg);
            for (int i = 0; i < 5; i++) { 
                try { 
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                }
                System.out.print(".");
            }
            System.out.println("结束。");
        }
    }

**Printable 接口**

*  Printable接口用于使PrinterProxy类和Printer类具有一致性。
 *  setPrinterName方法用于设置打印机的名字
 *  getPr interName用于获取打印机的名字
 *  print用于显示文字(打印输出)0

代码：

public interface Printable { 
        public abstract void setPrinterName(String name);   // 设置名字
        public abstract String getPrinterName();            // 获取名字
        public abstract void print(String string);          // 显示文字（打印输出）
    }

**PrinterProxy 类**

Printerproxy类是扮演“代理人”角色的类，它实现了 Printable接口。  
    name字段中保存了打印机的名字，而real字段中保存的是“本人”。  
    在构造函数中设置打印机的名字（此时还没有生成“本人” ）。  
    setPrinterName方法用于设置新的打印机名字。如果real 不为null（也就是已经生成了 “本人”），那么会设置“本人”的名字气 但是当real字段为null时（即还没有生成“本人”），那么只会设置自己（PrinterProxy的实例）的名字。  
    getPrinterName会返回自己的name字段。  
    print方法已经超出了代理人的工作范围，因此它会调用realize方法来生成本人。 Realize有“实现”（使成为真的东西）的意思。在调用realize方法后，real字段中会保存本人（Print类的实例），因此可以调用real.print方法。这就是“委托”。  
     **不论setPrinterName方法和getPrinterName方法被调用多少次，都不会生成Printer类的实例。** 只有当真正需要本人时，才会生成Printer类的实例（PrinterProxy类的调用者完全不知道是否生成了本人，也不用在意是否生成了本人）。  
    realize方法很简单，当real字段为null时，它会使用new Printer来生成Printer类的实例；如果real字段不为null （即已经生成了本人），则什么都不做。  
    这里希望大家记住的是，\*\*Printer类并不知道PrinterProxy类的存在。\*\*即，Printer类并不知道自己到底是通过PrinterProxy被调用的还是直接被调用的。  
    但反过来，PrinterProxy类是知道Printer类的。这是因为PrinterProxy类的real字段是Printer类型的。在PrinterProxy类的代码中，显式地写出了 Printer这个类名。因此，PrinterProxy类是与Printer类紧密地关联在一起的组件（关于它们之间的解耦方法，请  
参见习题21-l）o  
    相信有人应该已经发现了 Printer类的setPrinterName方法和realize方法都是synchronized方法。

代码：

public class PrinterProxy implements Printable { 
        private String name;            // 名字
        private Printer real;           // “本人”
        public PrinterProxy() { 
        }
        public PrinterProxy(String name) {       // 构造函数
            this.name = name;
        }
        public synchronized void setPrinterName(String name) {   // 设置名字
            if (real != null) { 
                real.setPrinterName(name);  // 同时设置“本人”的名字
            }
            this.name = name;
        }
        public String getPrinterName() {     // 获取名字
            return name;
        }
        public void print(String string) {   // 显示
            realize();
            real.print(string);
        }
        private synchronized void realize() {    // 生成“本人”
            if (real == null) { 
                real = new Printer(name);
            }
        }
    }

**Main类**  
    Main类通过Printer Proxy类使用Printer类。Main类首先会生成PrinterProxy，然后调用getPrinterName方法获取打印机名并显示它。之后通过setPrinterName方法重新设置打印机名。最后，调用print方法输出"Hello.world. "。  
    示例程序的运行结果如图所示。请注意，在设置名字和显示名字之间并没有生成Printer的实例(本人)，直至调用print方法后，Printer的实例才被生成。

代码：

public class Main { 
        public static void main(String[] args) { 
            Printable p = new PrinterProxy("Alice");
            System.out.println("现在的名字是" + p.getPrinterName() + "。");
            p.setPrinterName("Bob");
            System.out.println("现在的名字是" + p.getPrinterName() + "。");
            p.print("Hello, world.");
        }
    }

## 三、Proxy模式中的登场角色 ##

在Proxy模式中有以下登场角色。

**1. Subject （主体）**

> Subject角色定义了使Proxy角色和RealSubject角色之间具有一致性的接口。由于存在Subject角色，所以Client角色不必在意它所使用的宪竟是Proxy角色还是RealSubject角色o在示例程序中，由Printable接口扮演此角色。

**2. Proxy （代理人）**

> Proxy角色会尽量处理来自Client角色的请求。只有当自己不能处理时，它才会将工作交给RealSubject角色。Proxy角色只有在必要时才会生成RealSubject角色。Proxy角色实现了在Subject角色中定义的接口（ API）。在示例程序中，由PrinterPmxy类扮演此角色。

**3. RealSubject （实际的主体）**

> “本人”RealSubject角色会在“代理人"Proxy角色无法胜任工作时出场。它与Proxy角色一样，也实现了在Subject角色中定义的接口（ API）0在示例程序中，由Printer类扮演此角色。

**4. Client （请求者）**

> 使用Proxy模式的角色。在GoF书（请参见附录E［GoF］）中，Client角色并不包含在Proxy模式中。在示例程序中，由Main类扮演此角色。

**5. 类图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center 2]

## 四、各种Proxy模式 ##

Proxy模式有很多种变化形式。

1.  Virtual Proxy （虚拟代理）  
    Virtual Proxy就是本章中学习的Proxy模式。只有当真正需要实例时，它才生成和初始化实例。
2.  Remote Proxy （远程代理） Remote  
    Proxy可以让我们完全不必在意RealSubject角色是否在远程网络上，可以如同它在自己身边一样（透明性地）调用它的方法。Java的RMI  
    （ RemoteMethodInvocation :远程方法调用）就相当于Remote Proxy 。
3.  Access Proxy Access Proxy用于在调用RealSubject角色的功能时设置访问限制。例如，这种代理可以只允许  
    指定的用户调用方法，而当其他用户调用方法时则报错。

## 五、应用实例： ##

具体要求：  
1、定义一个接口：ITeacherDao  
2、目标对象TeacherDao实现接口ITeacherDao  
3、使用静态代理模式就需要在代理对象TeacherDaoProxy中也实现ITeacherDao  
4、调用的时候通过调用代理对象的方法来调用目标对象  
5、特别提醒：代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

**静态代理**

静态代理模式的基本介绍：静态代理在使用时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现相同的接口或者是继承父类

//接口
    public interface ITeacherDao { 
        void teach();
    }

public class TeacherDao implements ITeacherDao{ 
        @Override
        public void teach(){ 
            System.out.println("老师授课中。。。");
        }
    }

//代理对象，静态代理
    public class TeacherDaoProxy implements ITeacherDao{ 
    
        private ITeacherDao target;//目标对象，通过接口来聚合
    
        //构造器
        public TeacherDaoProxy(ITeacherDao target){ 
            this.target = target;
        }
        @Override
        public void teach(){ 
            System.out.println("开始代理。。。");
            target.teach();
            System.out.println("结束代理。。。");
        }
    }

public class Client { 
        public static void main(String[] args) { 
            //创建目标对象
            TeacherDao teacherDao =  new TeacherDao();
    
            //创建代理对象
            TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
    
            //通过代理对象，调用到被代理对象的方法
            //即：执行的是代理对象的方法，代理对象再去调用目标对象的方法
            teacherDaoProxy.teach();
        }
    }

**动态代理**

动态代理模式基本介绍

*  1、代理对象，不需要实现接口，但是目标对象要实现接口，否则不能用动态代理
 *  2、代理对象的生成，是利用JDK的API，动态的在内存中后见代理对象
 *  3、动态代理也叫做：JDK代理、接口代理

JDK中生成代理对象的API

*  1、代理类所在的包：java.lang.reflect.Proxy
 *  2、JDK实现代理只需要使用newProxylnstance方法，但是该方法需要接受三个参数，完成的写法是 public static Object newProxyInstance(ClassLoader loader, Class<?>\[\] interface, InvocationHandler h)

将上述实例改为动态代理：

public interface ITeacherDao { 
    
        void teach();
    }

public class TeacherDao implements ITeacherDao{ 
    
        @Override
        public void teach(){ 
            System.out.println("老师正在授课中。。");
        }
    }

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class Proxyfactory { 
    
        //维护一个目标对象，Object
        private Object target;
    
        //构造器，对target目标对象进行初始化
        public Proxyfactory(Object target){ 
            this.target = target;
        }
    
        //给目标对象生成一个代理对象
        public Object getProxyInstance(){ 
    
            /*说明： public static Object newProxyInstance(ClassLoader loader, Class<?>[] interface, InvocationHandler h) 1、ClassLoader loader:指定当前目标对象使用的类加载器，获取加载器的方法固定 2、Class<?>[] interface：目标对象实现的接口类型，使用泛型方法确认类型 3、InvocationHandler h：事情处理，执行目标对象的方法时，会触发事情处理器方法，会把当前执行的目标对象方法作为参数传入 */
    
    
            return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() { 
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    System.out.println("JDK代理开始~~~");
                    //反射机制调用目标对象的方法
                    Object returnVal = method.invoke(target, args);
                    System.out.println("JDK代理结束");
                    return returnVal;
                }
            });
        }
    
    
    }

public class Client { 
        public static void main(String[] args) { 
            //创建目标对象
            ITeacherDao target = new TeacherDao();
    
            //给目标对象，创建代理对象,可以转成ITeacherDao
            ITeacherDao proxyInstance = (ITeacherDao) new Proxyfactory(target).getProxyInstance();
    
           // proxyInstanceclass com.sun.proxy.$Proxy0内存动态生成了代理对象
            System.out.println("proxyInstance" + proxyInstance.getClass());
    
            //通过代理对象，调用目标对象的方法
            proxyInstance.teach();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/00d36c636b2d4d33a376b32c23b408cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221005/628766774bfa4a178a7d21ddc4d3fbf4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5NjM1Mw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221005/774cf64a66e7492998fd8b4d3831435e.png