Java基础汇总（二十一）——结构型模式

墨蓝 2024-04-03 10:36 52阅读 0赞

**一、代理模式**

*  最常使用的模式之一
 *  **用一个代理来隐藏具体实现类的实现细节，通常还用于在真实的实现的前后添加一部分逻辑**
 *  **代理：对客户端隐藏真实实现，由代理来负责客户端的所有请求。当然，代理只是个代理，它不会完成实际的业务逻辑，而是一层皮而已，但是对于客户端来说，它必须表现得就是客户端需要的真实实现**
 *  **代理模式就是做 “方法包装” 或做 “方法增强”**

public interface FoodService {
        Food makeChicken();
        Food makeNoodle();
    }
    
    public class FoodServiceImpl implements FoodService {
        public Food makeChicken() {
              Food f = new Chicken()
            f.setChicken("1kg");
              f.setSpicy("1g");
              f.setSalt("3g");
            return f;
        }
        public Food makeNoodle() {
            Food f = new Noodle();
            f.setNoodle("500g");
            f.setSalt("5g");
            return f;
        }
    }
    
    // 代理要表现得“就像是”真实实现类，所以需要实现 FoodService
    public class FoodServiceProxy implements FoodService {
    
        // 内部一定要有一个真实的实现类，当然也可以通过构造方法注入
        private FoodService foodService = new FoodServiceImpl();
    
        public Food makeChicken() {
            System.out.println("我们马上要开始制作鸡肉了");
    
            // 如果我们定义这句为核心代码的话，那么，核心代码是真实实现类做的，
            // 代理只是在核心代码前后做些“无足轻重”的事情
            Food food = foodService.makeChicken();
    
            System.out.println("鸡肉制作完成啦，加点胡椒粉"); // 增强
              food.addCondiment("pepper");
    
            return food;
        }
        public Food makeNoodle() {
            System.out.println("准备制作拉面~");
            Food food = foodService.makeNoodle();
            System.out.println("制作完成啦")
            return food;
        }
    }

客户端调用，注意，我们要用代理来实例化接口：

// 这里用代理类来实例化
    FoodService foodService = new FoodServiceProxy();
    foodService.makeChicken();

![d3e5f13ddf3f4b2d947a490fe7975b09.png][]

**在面向切面编程中（AOP） 中，其实就是动态代理的过程。**

**如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。**

**Spring 中实现动态代理有两种：**

*  **一种是如果我们的类定义了接口，如 UserService 接口和 UserServiceImpl 实现，那么采用 JDK 的动态代理（具体看 java.lang.reflect.Proxy 类的源码）**
 *  **另一种是我们自己没有定义接口的，Spring 会采用 CGLIB 进行动态代理，它是一个 jar 包，性能还不错**

**二、适配器模式**

*  **有一个接口需要实现，但是我们现成的对象都不满足，需要加一层适配器来进行适配**
 *  **适配器模式总体来说分三种：**
    
     *  **默认适配器模式**
     *  **对象适配器模式**
     *  **类适配器模式**

**1.默认适配器模式（Default Adapter）**

用Appache commons-io 包中的 FileAlterationListener做例子 ，此接口定义了很多的方法，用于对文件或文件夹进行监控，一旦发生了对应的操作，就会触发相应的方法

public interface FileAlterationListener {
        void onStart(final FileAlterationObserver observer);
        void onDirectoryCreate(final File directory);
        void onDirectoryChange(final File directory);
        void onDirectoryDelete(final File directory);
        void onFileCreate(final File file);
        void onFileChange(final File file);
        void onFileDelete(final File file);
        void onStop(final FileAlterationObserver observer);
    }

**此接口的一大问题是抽象方法太多了，如果我们要用这个接口，意味着我们要实现每一个抽象方法，如果我们只是想要监控文件夹中的文件创建和文件删除事件，可是我们还是不得不实现所有的方法，很明显，这不是我们想要的**

**所以，我们需要下面的一个适配器，它用于实现上面的接口，但是所有的方法都是空方法，这样，我们就可以转而定义自己的类来继承下面这个类即可**

//适配器
    
    public class FileAlterationListenerAdaptor implements FileAlterationListener {
    
        public void onStart(final FileAlterationObserver observer) {
        }
    
        public void onDirectoryCreate(final File directory) {
        }
    
        public void onDirectoryChange(final File directory) {
        }
    
        public void onDirectoryDelete(final File directory) {
        }
    
        public void onFileCreate(final File file) {
        }
    
        public void onFileChange(final File file) {
        }
    
        public void onFileDelete(final File file) {
        }
    
        public void onStop(final FileAlterationObserver observer) {
        }
    }

**自己定义类继承上述类（仅实现我们需要的方法就可以了）：**

public class FileMonitor extends FileAlterationListenerAdaptor {
        public void onFileCreate(final File file) {
            // 文件创建
            doSomething();
        }
    
        public void onFileDelete(final File file) {
            // 文件删除
            doSomething();
        }
    }

**2.对象适配器模式**

来看一个例子，看看怎么将鸡适配成鸭，这样鸡也能当鸭来用。因为，现在鸭这个接口，我们没有合适的实现类可以用，所以需要适配器。

public interface Duck {
        public void quack(); // 鸭的呱呱叫
          public void fly(); // 飞
    }
    
    public interface Cock {
        public void gobble(); // 鸡的咕咕叫
          public void fly(); // 飞
    }
    
    public class WildCock implements Cock {
        public void gobble() {
            System.out.println("咕咕叫");
        }
          public void fly() {
            System.out.println("鸡也会飞哦");
        }
    }

鸭接口有 fly() 和 quack() 两个方法，鸡 Cock 如果要冒充鸭，fly() 方法是现成的，但是鸡不会鸭的呱呱叫，没有 quack() 方法。这个时候就需要适配了：

// 毫无疑问，首先，这个适配器肯定需要 implements Duck，这样才能当做鸭来用
    public class CockAdapter implements Duck {
    
        Cock cock;
        // 构造方法中需要一个鸡的实例，此类就是将这只鸡适配成鸭来用
          public CockAdapter(Cock cock) {
            this.cock = cock;
        }
    
        // 实现鸭的呱呱叫方法
          @Override
          public void quack() {
            // 内部其实是一只鸡的咕咕叫
            cock.gobble();
        }
    
          @Override
          public void fly() {
            cock.fly();
        }
    }

客户端调用：

public static void main(String[] args) {
        // 有一只野鸡
          Cock wildCock = new WildCock();
          // 成功将野鸡适配成鸭
          Duck duck = new CockAdapter(wildCock);
          ...
    }

**由上述过程可知，适配器就是当我们想要实现某一类却没有时（如我们想实现鸭这一类，却没有具体实现方法时），用适配器来充当想要实现的类，然后适配器中用现有的类的实现方法（如鸡类）实现**

**即无非是我们需要一只鸭，但是我们只有一只鸡，这个时候就需要定义一个适配器，由这个适配器来充当鸭，但是适配器里面的方法还是由鸡来实现的**

![e6890cd3975f4cda85ea5e0bbc749c00.png][]

**3.类适配器模式**

![8cf4c5148bae4c098b96f67e12ac51fd.png][]

**类适配器是通过类继承方法，使得适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 `Target t = new SomeAdapter();` 就可以了**

**4.适配器模式总结**

**类适配器和对象适配器的异同：**

*  **一个采用继承，一个采用组合；**
 *  **类适配属于静态实现，对象适配属于组合的动态实现，对象适配需要多实例化一个对象**
 *  **总体来说，对象适配用得比较多**

**适配器模式和代理模式的异同（比较这两种模式，其实是比较对象适配器模式和代理模式）：**

*  **代码结构上，它们很相似，都需要一个具体的实现类的实例**
 *  **目的不一样：**
    
     *  **代理模式做的是增强原方法的活**
     *  **适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系**

![a7c3c7c7ae604744aecacb15b7e09b13.png][]

**三、桥梁模式**

*  **其实就是理解代码抽象和解耦**
 *  **桥梁模式的优点就是非常容易进行扩展**

首先需要一个桥梁，它是一个接口，定义提供的接口方法：

public interface DrawAPI {
       public void draw(int radius, int x, int y);
    }

然后是一系列实现类：

public class RedPen implements DrawAPI {
       @Override
       public void draw(int radius, int x, int y) {
          System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
       }
    }
    public class GreenPen implements DrawAPI {
       @Override
       public void draw(int radius, int x, int y) {
          System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
       }
    }
    public class BluePen implements DrawAPI {
       @Override
       public void draw(int radius, int x, int y) {
          System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
       }
    }

定义一个抽象类，此类的实现类都需要使用 DrawAPI：

public abstract class Shape {
       protected DrawAPI drawAPI;
    
       protected Shape(DrawAPI drawAPI){
          this.drawAPI = drawAPI;
       }
       public abstract void draw();    
    }

定义抽象类的子类：

// 圆形
    public class Circle extends Shape {
       private int radius;
    
       public Circle(int radius, DrawAPI drawAPI) {
          super(drawAPI);
          this.radius = radius;
       }
    
       public void draw() {
          drawAPI.draw(radius, 0, 0);
       }
    }
    // 长方形
    public class Rectangle extends Shape {
        private int x;
          private int y;
    
          public Rectangle(int x, int y, DrawAPI drawAPI) {
            super(drawAPI);
              this.x = x;
              this.y = y;
        }
          public void draw() {
          drawAPI.draw(0, x, y);
       }
    }

最后，客户端演示：

public static void main(String[] args) {
        Shape greenCircle = new Circle(10, new GreenPen());
          Shape redRectangle = new Rectangle(4, 8, new RedPen());
    
          greenCircle.draw();
          redRectangle.draw();
    }

![9d3f68a62d8e40cd986f26d21195aee3.png][]

**四、装饰模式**

*  从名字来简单解释下装饰器：**装饰，往往就是添加小功能这种**，而且，我们要满足可以添加多个小功能。最简单的，**代理模式就可以实现功能的增强，但是代理不容易实现多个功能的增强，当然你可以说用代理包装代理的方式，但是那样的话代码就复杂了**

![543fa3bae4f24d42ad954737eda3c865.png][]

**从图中可以看到，****接口Component其实已经有了ConcreteComponentA和ConcreteComponentB两个实现类了****，但是，如果我们要****增强这两个实现类的话，我们就可以采用装饰模式****，用具体的****装饰器来装饰实现类，以达到增强的目的****。**

**所有的****具体装饰者们 ConcreteDecorator\_ 都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口****。它们和** **Component 实现类 ConcreteComponent\_ 的区别是，它们只是装饰者，起装饰作用****，也就是即使它们看上去牛逼轰轰，但是****它们都只是在具体的实现中加了层皮来装饰而已****。**

**注意这段话中混杂在各个名词中的 Component 和 Decorator，别搞混了！！！**

下面来看看一个例子，先把装饰模式弄清楚，然后再介绍下 java io 中的装饰模式的应用。

最近大街上流行起来了“快乐柠檬”，我们把**快乐柠檬的饮料分为三类：红茶、绿茶、咖啡**，在这三大类的基础上，又增加了许多的口味，什么金桔柠檬红茶、金桔柠檬珍珠绿茶、芒果红茶、芒果绿茶、芒果珍珠红茶、烤珍珠红茶、烤珍珠芒果绿茶、椰香胚芽咖啡、焦糖可可咖啡等等，每家店都有很长的菜单，但是仔细看下，其实原料也没几样，但是可以搭配出很多组合，如果顾客需要，很多没出现在菜单中的饮料他们也是可以做的。

在这个例子中，**红茶、绿茶、咖啡是最基础的饮料**，其他的像**金桔柠檬、芒果、珍珠、椰果、焦糖等都属于装饰用的**。当然，在开发中，我们确实可以像门店一样，开发这些类：

LemonBlackTea、LemonGreenTea、MangoBlackTea、MangoLemonGreenTea......但是，很快我们就发现，这样子干肯定是不行的，这会导致我们需要组合出所有的可能，而且如果客人需要在红茶中加双份柠檬怎么办？三份柠檬怎么办？万一有个变态要四份柠檬，所以这种做法是给自己找加班的。

首先，定义饮料抽象基类：

public abstract class Beverage {
          // 返回描述
          public abstract String getDescription();
          // 返回价格
          public abstract double cost();
    }

然后是三个基础饮料实现类，红茶、绿茶和咖啡：

public class BlackTea extends Beverage {
          public String getDescription() {
            return "红茶";
        }
          public double cost() {
            return 10;
        }
    }
    public class GreenTea extends Beverage {
        public String getDescription() {
            return "绿茶";
        }
          public double cost() {
            return 11;
        }
    }
    ...// 咖啡省略

定义调料，也就是装饰者的基类，此类必须继承自 Beverage：

// 调料
    public abstract class Condiment extends Beverage {
    
    }

然后我们来定义柠檬、芒果等具体的调料，它们属于装饰者，毫无疑问，这些调料肯定都需要继承 Condiment 类：

public class Lemon extends Condiment {
        private Beverage bevarage;
          // 这里很关键，需要传入具体的饮料，如需要传入没有被装饰的红茶或绿茶，
          // 当然也可以传入已经装饰好的芒果绿茶，这样可以做芒果柠檬绿茶
          public Lemon(Beverage bevarage) {
            this.bevarage = bevarage;
        }
          public String getDescription() {
            // 装饰
            return bevarage.getDescription() + ", 加柠檬";
        }
          public double cost() {
              // 装饰
            return beverage.cost() + 2; // 加柠檬需要 2 元
        }
    }
    public class Mango extends Condiment {
        private Beverage bevarage;
          public Mango(Beverage bevarage) {
            this.bevarage = bevarage;
        }
          public String getDescription() {
            return bevarage.getDescription() + ", 加芒果";
        }
          public double cost() {
            return beverage.cost() + 3; // 加芒果需要 3 元
        }
    }
    ...// 给每一种调料都加一个类

客户端调用：

public static void main(String[] args) {
          // 首先，我们需要一个基础饮料，红茶、绿茶或咖啡
        Beverage beverage = new GreenTea();
          // 开始装饰
          beverage = new Lemon(beverage); // 先加一份柠檬
          beverage = new Mongo(beverage); // 再加一份芒果
    
          System.out.println(beverage.getDescription() + " 价格：￥" + beverage.cost());
          //"绿茶, 加柠檬, 加芒果 价格：￥16"
    }

如果我们需要芒果珍珠双份柠檬红茶：

Beverage beverage = new Mongo(new Pearl(new Lemon(new Lemon(new BlackTea()))));

![980f0005b8974e098517574ae9dee4cc.png][]

**1. java IO 中的装饰模式**

*  **InputStream 派生出来的部分类**

![65afa64eafc24f8c8251af08a51e0caf.png][]

**InputStream 代表了输入流，具体的输入来源可以是文件（FileInputStream）、管道（PipedInputStream）、数组（ByteArrayInputStream）等，这些就像前面奶茶的例子中的红茶、绿茶，属于基础输入流。**

**FilterInputStream 承接了装饰模式的关键节点，其实现类是一系列装饰器，比如 BufferedInputStream 代表用缓冲来装饰，也就使得输入流具有了缓冲的功能，LineNumberInputStream 代表用行号来装饰，在操作的时候就可以取得行号了，DataInputStream 的装饰，使得我们可以从输入流转换为 java 中的基本类型值。**

当然，在 java IO 中，如果我们使用装饰器的话，就不太适合面向接口编程了，如：

InputStream inputStream = new LineNumberInputStream(new BufferedInputStream(new FileInputStream("")));

这样的结果是，InputStream 还是不具有读取行号的功能，因为读取行号的方法定义在 LineNumberInputStream 类中

我们应该像下面这样使用：

DataInputStream is = new DataInputStream(
                                  new BufferedInputStream(
                                      new FileInputStream("")));

**五、门面模式**

**门面模式（也叫外观模式，Facade Pattern）在许多源码中有使用，比如 slf4j 就可以理解为是门面模式的应用**

首先，我们定义一个接口：

public interface Shape {
       void draw();
    }

定义几个实现类：

public class Circle implements Shape {
    
       @Override
       public void draw() {
          System.out.println("Circle::draw()");
       }
    }
    
    public class Rectangle implements Shape {
    
       @Override
       public void draw() {
          System.out.println("Rectangle::draw()");
       }
    }

客户端调用：

public static void main(String[] args) {
        // 画一个圆形
          Shape circle = new Circle();
          circle.draw();
    
          // 画一个长方形
          Shape rectangle = new Rectangle();
          rectangle.draw();
    }

以上是我们常写的代码，我们需要画圆就要先实例化圆，画长方形就需要先实例化一个长方形，然后再调用相应的 draw() 方法。

下面，我们看看怎么用门面模式来让客户端调用更加友好一些。

我们先定义一个门面：

public class ShapeMaker {
       private Shape circle;
       private Shape rectangle;
       private Shape square;
    
       public ShapeMaker() {
          circle = new Circle();
          rectangle = new Rectangle();
          square = new Square();
       }
    
      /**
       * 下面定义一堆方法，具体应该调用什么方法，由这个门面来决定
       */
    
       public void drawCircle(){
          circle.draw();
       }
       public void drawRectangle(){
          rectangle.draw();
       }
       public void drawSquare(){
          square.draw();
       }
    }

客户端调用：

public static void main(String[] args) {
      ShapeMaker shapeMaker = new ShapeMaker();
    
      // 客户端调用现在更加清晰了
      shapeMaker.drawCircle();
      shapeMaker.drawRectangle();
      shapeMaker.drawSquare();        
    }

**门面模式的优点显而易见，客户端不再需要关注实例化时应该使用哪个实现类，直接调用门面提供的方法就可以了，因为门面类提供的方法的方法名对于客户端来说已经很友好了**

**六、组合模式**

*  **组合模式用于表示具有层次结构的数据，使得我们对单个对象和组合对象的访问具有一致性**

一个例子，个员工都有姓名、部门、薪水这些属性，同时还有下属员工集合（虽然可能集合为空），而下属员工和自己的结构是一样的，也有姓名、部门这些属性，同时也有他们的下属员工集合。

public class Employee {
       private String name;
       private String dept;
       private int salary;
       private List<Employee> subordinates; // 下属
    
       public Employee(String name,String dept, int sal) {
          this.name = name;
          this.dept = dept;
          this.salary = sal;
          subordinates = new ArrayList<Employee>();
       }
    
       public void add(Employee e) {
          subordinates.add(e);
       }
    
       public void remove(Employee e) {
          subordinates.remove(e);
       }
    
       public List<Employee> getSubordinates(){
         return subordinates;
       }
    
       public String toString(){
          return (
                    "Employee :[ Name : " + name + ", dept : " + dept 
                    + ", salary :" + salary+" ]");
       }   
    }

通常，这种类需要定义 add(node)、remove(node)、getChildren() 这些方法。

**七、享元模式（ Flyweight Pattern）**

Flyweight 是轻量级的意思，享元分开来说就是 共享 元器件，也就是复**用已经生成的对象**，这种做法当然也就是轻量级的了。

**复用对象最简单的方式是，用一个 HashMap 来存放每次新生成的对象。每次需要一个对象的时候，先到 HashMap 中看看有没有，如果没有，再生成新的对象，然后将这个对象放入 HashMap 中。**

**八、结构型模式总结**

*  **代理模式是做方法增强的**
 *  **适配器模式是把鸡包装成鸭这种用来适配接口的**
 *  **桥梁模式做到了很好的解耦**
 *  **装饰模式适合于装饰类或者说是增强类的场景**
 *  **门面模式的优点是客户端不需要关心实例化过程，只要调用需要的方法即可**
 *  **组合模式用于描述具有层次结构的数据**
 *  **享元模式是为了在特定的场景中缓存已经创建的对象，用于提高性能**

参考文章：

[Java-Tutorial/初探Java设计模式2：结构型模式（代理模式，适配器模式等）.md at master · h2pl/Java-Tutorial · GitHub][Java-Tutorial_Java_2_.md at master _ h2pl_Java-Tutorial _ GitHub]

[d3e5f13ddf3f4b2d947a490fe7975b09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/eaefb5bac1a3438480795f1fb782fe33.png
[e6890cd3975f4cda85ea5e0bbc749c00.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7198bf8f2f994417b3c6a53559b13301.png
[8cf4c5148bae4c098b96f67e12ac51fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/ea639bae5b53419aacba5038143c645d.png
[a7c3c7c7ae604744aecacb15b7e09b13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/c093046fde2c415da71eb430e039867b.png
[9d3f68a62d8e40cd986f26d21195aee3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/e15d7f48df2f4e41afbe45386be39936.png
[543fa3bae4f24d42ad954737eda3c865.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/89090e7bcdf4499bb10714d23ebd6801.png
[980f0005b8974e098517574ae9dee4cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/2830ea7712d340199aebf069012fa4a8.png
[65afa64eafc24f8c8251af08a51e0caf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/43698dd74a0d4384a05022c84f852cd2.png
[Java-Tutorial_Java_2_.md at master _ h2pl_Java-Tutorial _ GitHub]: https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/design-parttern/%E5%88%9D%E6%8E%A2Java%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F2%EF%BC%9A%E7%BB%93%E6%9E%84%E5%9E%8B%E6%A8%A1%E5%BC%8F%EF%BC%88%E4%BB%A3%E7%90%86%E6%A8%A1%E5%BC%8F%EF%BC%8C%E9%80%82%E9%85%8D%E5%99%A8%E6%A8%A1%E5%BC%8F%E7%AD%89%EF%BC%89.md