设计模式08—模板方法模式

ゞ浴缸里的玫瑰 2023-10-11 16:24 13阅读 0赞

[上一篇 《适配器模式与外观模式》][Link 1]

## 8.模板方法模式 ##

直到目前，我们的议题都绕着封装转;我们已经封装了对象创建、方法调用、复杂接口、鸭子、比萨……接下来呢我们将要深入封装算法块，好让子类可以在任何时候都可以将自己挂接进运算里。我们甚至会在本章学到一个受到好莱坞影响而启发的设计原则。  
其主要作用就是用于将我们的算法封装起来

### 8.1 通过冲泡茶和冲泡咖啡来引入算法的封装 ###

茶和咖啡的冲泡方式非常相似，大致如下：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

接下来我们看一看冲泡咖啡的代码

/**
     * 煮咖啡
     */
    public class Coffee {
        
        void prepareRecipe() {
        
            boilWater();
            brewCoffeeGrinds();
            pourInCup();
            addSugarAndMilk();
        }
    
        public void boilWater() {
        
            System.out.println("水沸腾了");
        }
    
        public void brewCoffeeGrinds() {
        
            System.out.println("把咖啡加入沸水中");
        }
    
        public void pourInCup() {
        
            System.out.println("把冲泡好的咖啡倒入杯子中");
        }
    
        public void addSugarAndMilk() {
        
            System.out.println("加牛奶和糖");
        }
    }

煮茶类代码

/**
     * 煮茶类
     */
    public class Tea {
        
        void prepareRecipe() {
        
            boilWater();
            steepTeaBag();
            addLemon();
            pourInCup();
        }
    
        public void boilWater() {
        
            System.out.println("水沸腾了");
        }
    
        public void steepTeaBag() {
        
            System.out.println("将茶叶加入沸水中");
        }
    
        public void addLemon() {
        
            System.out.println("添加柠檬");
        }
    
        public void pourInCup() {
        
            System.out.println("将茶水倒入杯子中");
        }
    
    }

注意：由于boilWater(),pourInCup()在两个类中的方法完全一样，所以此处出现了重复代码  
我们接下来的工作就是将共同的部分抽取出来，放在一个基类中。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

但是值得我们注意的是两份冲泡方法都采用了相同的算法  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

下面我们要想尽办法将prepareRecipe()方法抽象化。

### 8.2 抽象prepareRecipe() ###

#### 1.我们所遇到的第一个问题，就是咖啡使用brewCoffeeGrinds()和addSugarAndMilk()方法,而茶使用steepTeaBag()和addLemon()方法。 ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]

让我们来思考这一点:浸泡（steep)和冲泡(brew）差异其实不大。所以我们给它一个新的方法名称，比方说brew()，然后不管是泡茶或冲泡咖啡我们都用这个名称。类似地，加糖和牛奶也和加柠檬很相似:都是在饮料中加入调料。让我们也给它一个新的方法名称来解决这个问题，就叫做addCondiments()好了。这样一来，新的prepareRecipe()方法看起来就像这样:  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]

#### 2.现在我们有了新的prepareRecipe()方法，但是需要让它能够符合代码。要想这么做，我们先从CaffeineBeverage（咖啡因饮料）超类开始: ####

/**
     * 咖啡因饮料是一个抽象类
     */
    public abstract class CaffeineBeverage {
        
        /**
         * 现在．用同一个prepareRecipe()方法来处理茶和咖啡。piepareRecipe()被声明为final．
         * 因为我们不希望子类覆盖这个方法!我们将步骤2和步骤4泛化成为brew()和addCondiments()。
         */
        final void prepareRecipe() {
        
            boilWater();
            brew();
            pourInCup();
            addCondiments();
        }
    
        /**
         * 为咖啡和茶处理这些方法的做法不同，所以这两个方法必须被声明为抽象，剩余余的东西留给子类去操心。
         */
        abstract void brew();
    
        abstract void addCondiments();
    
        void boilWater() {
        
            System.out.println("将水煮沸");
        }
    
        void pourInCup() {
        
            System.out.println("将音频倒入杯中");
        }
    }

#### 3.最后，我们需要处理咖啡和茶类了。这两个类现在都是依赖超类（咖啡因饮料）来处理冲泡法，所以只需要自行处理冲泡和添加调料部分: ####

##### Tea #####

/**
     * 茶和咖啡都是继承自咖啡因饮料
     */
    public class Tea extends CaffeineBeverage {
        
        @Override
        public void brew() {
        
            System.out.println("将茶叶放入沸水中");
        }
    
        @Override
        public void addCondiments() {
        
            System.out.println("添加柠檬");
        }
    }

##### Coffee #####

public class Coffee extends CaffeineBeverage {
        
        @Override
        public void brew() {
        
            System.out.println("将咖啡粉放入沸水中");
        }
    
        @Override
        public void addCondiments() {
        
            System.out.println("添加糖和牛奶");
        }
    }

我们在上面的操作中做了些什么，下面我用一张图就很直观的显示了我们做了什么  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]

### 8.3 认识模板方法 ###

其实我们刚刚实现的就是模板方法模式，让我们看看咖啡因饮料的结构  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]

下面我们通过模板方法来冲泡茶和咖啡

public class BeverageTestDrive {
        
        public static void main(String[] args) {
        
            Tea tea = new Tea();
            Coffee coffee = new Coffee();
            System.out.println("开始制作茶");
            System.out.println("----------------------------");
            tea.prepareRecipe();
            System.out.println("----------------------------");
            System.out.println("开始制作咖啡");
            System.out.println("----------------------------");
            coffee.prepareRecipe();
            System.out.println("----------------------------");
    
        }
    }

输出结果如下：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_19_color_FFFFFF_t_70_g_se_x_16_pic_center]

**模板方法定义了一个算法的步骤，并允许子类为一个或多个步骤提供实现。**  
我们为什么要引入模板方法？  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]

### 8.4 定义模板方法模式 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]

这个模式是用来创建一个算法的模板。什么是模板?  
其实模板就是一个方法。更具体地说，这个方法将算法定义成一组步骤，其中的任何步骤都可以是抽象的，由子类负责实现。这可以确保算法的结构保持不变，同时由子类提供部分实现。  
让我们细看抽象类是如何被定义的

/**
     * 这就是我们的抽象类，他被声明为抽象，用来作为基类
     * 其子类必须实现其操作
     */
    public abstract class AbstractClass {
        
        /**
         * 这就是模板方法。
         * 他被声明为final，以免子类改变这个算法的顺序
         */
        final void templateMethod() {
        
            /**模板方法定义了一连串的步骤，每一个步骤由一个方法代表。**/
            primitiveOperation1();
            primitiveOperation2();
            concreteOperation();
        }
    
        /**
         * 在这个范例中有两个原语操作，具体子类必须实现他们
         */
        abstract void primitiveOperation1();
    
        abstract void primitiveOperation2();
    
        void concreteOperation() {
        
            //这里是实现
        }
    }

接下来我们在靠近一点详细看看抽象类可以有哪些类型的方法

/**
     * 我们加入了一个新方法调用，改变了templateMethod
     */
    public abstract class AbstractClassHook {
        
        /**
         * 这就是模板方法。
         * 他被声明为final，以免子类改变这个算法的顺序
         */
        final void templateMethod() {
        
            /**模板方法定义了一连串的步骤，每一个步骤由一个方法代表。**/
            primitiveOperation1();
            primitiveOperation2();
            concreteOperation();
            hook();
        }
    
        /**
         * 在这个范例中有两个原语操作，具体子类必须实现他们
         */
        abstract void primitiveOperation1();
    
        abstract void primitiveOperation2();
    
        void concreteOperation() {
        
            //这里是实现
        }
    
        /**
         *这是一个具体的方法，但他什么都不做
         * 我们也可以有“默认不做事的方法”，我们称这种方法为“hook”(钩子）。
         * 子类可以视情况决定要不要覆盖它们。
         */
        void hook() {
        
    
        }
    }

### 8.5 对模板方法进行挂钩 ###

钩子是一种被声明在抽象类中的方法,但只有空的或者默认的实现。钩子的存在,可以让子类有能力对算法的不同点进行挂钩。要不要挂钩，由子类自行决定。  
钩子有好几种用途，让我们先看其中一个，稍后再看其他几个:

public abstract class CaffeinBeverageWithHook {
        
        void prepareRecipe() {
        
            boilWater();
            brew();
            pourInCup();
            /**
             * 我们加上了一个的条件语句，而该条件是否成立，是由一个具体方法
             * customWantsCondiments决定的。如果顾客“想要”调料，只有这时我们才调用
             * addCondiments
             */
            if (customWantsCondiments()) {
        
                addCondiments();
            }
        }
    
        abstract void brew();
    
        abstract void addCondiments();
    
        void boilWater() {
        
            System.out.println("把水煮沸");
        }
    
        void pourInCup() {
        
            System.out.println("将饮料倒入杯子中");
        }
    
        /**
         * 我们在这里定义了一个方法，通常是空的缺省实现。这个方法只会返回true，不做别的事
         * 这就是一个钩子，子类可以覆盖这个，但不见得一定要去覆盖
         *
         * @return
         */
        boolean customWantsCondiments() {
        
            return true;
        }
    }

### 8.6 使用钩子 ###

为了测试钩子，我们在子类中覆盖它。钩子的作用是咖啡因饮料是否执行了某部分算法，说的更明确一些，就是饮料中是否要加进调料。

public class CoffeeWithHook extends CaffeinBeverageWithHook {
        
        @Override
        void brew() {
        
            System.out.println("将咖啡粉放入沸水中");
        }
    
        @Override
        void addCondiments() {
        
            System.out.println("加入牛奶和糖");
        }
    
        /**
         * 让用户输入他们对调料的决定，根据用户的输入返回true或false
         *
         * @return
         */
        @Override
        public boolean customWantsCondiments() {
        
            String answer = getUserInput();
            if (answer.toLowerCase().startsWith("y")) {
        
                return true;
            } else {
        
                return false;
            }
        }
    
        private String getUserInput() {
        
            String answer = null;
            System.out.println("您需要咖啡里面加糖和牛奶吗？");
            InputStream in;
            BufferedReader inputt = new BufferedReader(new InputStreamReader(System.in));
            try {
        
                answer = inputt.readLine();
            } catch (IOException ioe) {
        
                System.out.println("IO error tring to read your answer");
            }
            if (answer == null) {
        
                return "no";
            }
            return answer;
        }
    }

自己尝试一下模仿着CoffeeWithHook将TeaWithHook写出来  
接下来我们开始进行测试

public class BeverageTestDriver {
        
        public static void main(String[] args) {
        
            TeaWithHook teaHook = new TeaWithHook();//创建一杯茶
            CoffeeWithHook coffeeHook = new CoffeeWithHook();//创建一杯咖啡
            System.out.println("开始制茶");
            teaHook.prepareRecipe();
            System.out.println("开始制作咖啡");
            coffeeHook.prepareRecipe();
        }
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]

学到此处，我们可能会有些疑问

*  1.在使用模板方法时,怎么才能知道什么时候该使用抽象方法,什么时候使用钩子呢?

> 答:当你的子类“必须”提供算法中某个方法或步骤的实现时,就使用抽象方法。如果算法的这个部分是可选的，就用钩子。如果是钩子的话,子类可以选择实现这个钩子，但并不强制这么做。

*  2.子类必须实现抽象类中的所有方法吗？

> 答:是的，每一个具体的子类都必须定义所有的抽象方法,并为模板方法算法中未定义步骤提供完整的实现。

*  3.似平我应该保持抽象方法的数目越少越好,否则,在子类中实现这些方法将会很麻烦?

> 答:当你在写模板方法的时候,心里要随时记得这一点。想要做到这一点,可以让算法内的步骤不要切割得太细,但是如果步骤太少的话,会比较没有弹性,所以要看情况折衷。也请记住,某些步骤是可选的,所以你可以将这些步骤实现成钩子,而不是实现成抽象方法这样就可以让抽象类的子类的负荷减轻。

### 8.7 好莱坞原则 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]

好莱坞原则可以给我们一种防止“依赖腐败”的方法。当高层组件依赖低层组件,而低层组件又依赖高层组件,而高层组件又依赖边侧组件,而边侧组件又依赖低层组件时，依赖腐败就发生了。在这种情况下，没有人可以轻易地搞懂系统是如何设计的。  
在好菜坞原则之下，我们允许低层组件将自己挂钩到系统上，但是高层组件会决定什么时候和怎样使用这些低层组件。换句话说，高层组件对待低层组件的方式是“别调用我们，我们会调用你”  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]

#### 好莱坞原则和模板方法 ####

好菜坞原则和模板方法之间的连接其实还算明显:当我们设计模板方法模式时，我们告诉子类，“不要调用我们，我们会调用你”。怎样才能办到呢?让我们再看一次咖啡因饮料的设计:  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 12]

*  1.好莱坞原则和[依赖倒置原则][Link 2]之间的关系如何?

> 答:依赖倒置原则教我们尽量避免使用具体类，而多使用抽象。而好莱坞原则是用在创建框架或组件上的一种技巧，好让低层组件能够被挂钩进计算中，而且又不会让高层组件依赖低层组件。两者的目标都是在于解耦,但是依赖倒置原则更加注重如何在设计中避免依赖。  
> 好莱坞原则教我们一个技巧,创建一个有弹性的设计,允许低层结构能够互相操作,而又防止其他类太过依赖它们。

*  2.低层组件不可以调用高层组件中的方法吗?

> 答:并不尽然。事实上,低层组件在结束时，常常会调用从超类中继承来的方法。我们所要做的是,避免让高层和低层组件之间有明显的环状依赖。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 13]

### 8.8 用模板方法排序 ###

Java数组类的设计者提供给我们一个方便的模板方法用来排序。让我们看看这个方法如何运行:

public class SortUtils {
        
        /**
         * 第一个方法sort()只是一个辅助(helper)方法、用来创建一个数组的拷贝，然后将其传
         * 递给mergeSort()方法当作目标数组。同时传入mergeSort()的参数，还包括数组的长度、以及从
         * (0)开始排序。
         *
         * @param a
         */
        public static void sort(Object[] a) {
        
            Object aux[] = (Object[]) a.clone();
            mergeSort(aux, a, 0, a.length, 0);
        }
    
        /**
         * mergeeSort()方法包含排序算，此算法依赖于compareTo()方法实现
         *
         * @param src
         * @param dest
         * @param low
         * @param high
         * @param off
         */
        private static void mergeSort(Object[] src, Object dest[], int low, int high, int off) {
        //此处可以看成是一个模板方法
            for (int i = low; i < high; i++) {
        
                for (int j = i; j > low && ((Comparable) dest[j - 1]).compareTo((Comparable) dest[j]) > 0; j--) {
        
                    swap(dest, j, j - 1);
                }
            }
            return;
        }
    
        /**
         * 交换i,j的值
         *
         * @param src
         * @param i
         * @param j
         */
        private static void swap(Object[] src, int i, int j) {
        
            Object temp = src[i];
            src[i] = src[j];
            src[j] = temp;
        }
    
    }

### 8.9 排序鸭子 ###

假如我们有一个鸭子的数组需要排序，你要怎么做？  
数组的排序模板方法已经提供了算法,但是你必须让这个模板方法知道如何比较鸭子。  
而sort()的设计者希望这个方法能使用于所有的数组，所以他们把sort()变成是静态的方法,这样一来，任何数组都可以使用这个方法。但是没关系，它使用起来和它被定义在超类中是一样的。  
现在,还有一个细节要告诉你:因为sort()并不是真正定义在超类中,所以sort()方法需要知道你已经实现了这个compareTo方法,否则就无法进行排序。  
要达到这一点,设计者利用了Comparable接口。你须实现这个接口，提供这个接口所声明的方法,也就是compareTo()。

#### 什么是compareTo()? ####

这个compareTo()方法将比较两个对象，然后返回其中一个是大于、等于还是小于另一个。sort()只要能够知道两个对象的大小,当然就可以进行排序。

#### 比较鸭子 ####

好了，现在你知道了如果要排序鸭子，就必须实现这个compareTo()方法:然后,数组就可以被正常地排序了。  
鸭子的实现如下：

/**
     * 我们之所以需要让鸭子类实现Compareable接口，因为我们无法真的让鸭子数组去继承数组。
     */
    public class Duck implements Comparable {
        
        String name;
        int weight;
    
        public Duck(String name, int weight) {
        
            this.name = name;
            this.weight = weight;
        }
    
        public String toString() {
        
            return name + " 重量:" + weight;
        }
    
        /**
         * compareTo需要被传入另-鸭子。和本身这只鸭子做比较。
         * @param o
         * @return
         */
        @Override
        public int compareTo(Object o) {
        
            Duck otherDuck = (Duck) o;
            if (this.weight < otherDuck.weight) {
        
                return -1;
            } else if (this.weight == otherDuck.weight) {
        
                return 0;
            } else {
        
                return 1;
            }
        }
    }

接下来我们进行一个测试

public class DuckSortTestDrive {
        
        public static void main(String[] args) {
        
            Duck[] ducks = {
        
                    new Duck("Daffy", 8),
                    new Duck("Dewey", 2),
                    new Duck("Howard", 7),
                    new Duck("Louie", 2),
                    new Duck("Donald", 10),
                    new Duck("Huey", 2)
            };
            System.out.println("未排序时的鸭子数组：");
            display(ducks);
            System.out.println("排序之后的鸭子数组：");
            Arrays.sort(ducks);
            display(ducks);
        }
    
        public static void display(Duck[] ducks) {
        
            for (int i = 0; i < ducks.length; i++) {
        
                System.out.println(ducks[i]);
            }
        }
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 14]

#### 下面我们分析一下鸭子排序的内部是怎么实现的 ####

*  1.首先我们需要一个鸭子数组

Duck[] ducks = {
        
                    new Duck("Daffy", 8),
                    new Duck("Dewey", 2),
                    new Duck("Howard", 7),
                    new Duck("Louie", 2),
                    new Duck("Donald", 10),
                    new Duck("Huey", 2)
            };

*  2.然后调用Array类的sort()模板方法，并传入鸭子数组

Arrays.sort(ducks);

这个sort()方法控制排序过程

*  3.想要排序一个数组，你需要一次又一次地比较两个对象，直到整个数组都排序完毕。  
    当比较两只鸭子的时候,排序方法需要依赖鸭子的compareTo()方法，以得知谁大谁小。第一只鸭子的compareTo()方法被调用，并传入另一只鸭子当成比较对象:

ducks[0].compareTo(ducks[1])

*  4.如果鸭子的次序不对，就用Array的具体swap0方法将两者对调:

swap();

*  5.排序方法会持续比较并对调鸭子,直到整个数组的次序是正确的!

看到此处你可能会认为我是想象力太丰富，这些和模板方法有什么联系

> 这个模式的重点在于提供一个算法,并让子类实现某些步骤而数组的排序做法很明显地并非此如此  
> 但是，我们都知道,荒野中的模式并非总是如同教科书例子一般地中规中矩。为了符合当前的环境和实理的约束,它们总是要被适当地修改。  
> 这个Array 类sort()方法的设计者受到一些约束。  
> 通常我们无法设计一个类继承java数组，而sort()方法希望能够适用于所有的数组（每个数组都是不同的类）。所以它们定义了一个静态方法,而由被排序的对象内的每个元素自行提供比较大小的算法部分。所以,这虽然不是教科书上的模板方法,但它的实现仍然符合模板方法模式的精神。再者,由于不需要继承数组就可以使用这个算法,这样使得排序变得更有弹性、更有用。

在Java API中还有其他模板方法的例子吗？

> 答:是的，你可以在一些地方看到它们。比方说，java.io的InputStream类有一个read()方法,是由子类实现的、而这个方法又会被read(byte b\[\], int off,int len)模板方法使用。

接下来我们继续丰富我们的OO原则  
**封装变化**  
**多用组合，少用继承**  
**针对接口编程，不针对实现编程**  
**为交互对象之问的松耦合设计而努力**  
**类应该对扩展开放，对修改关闭**  
**依赖抽象，不要依赖具体类**  
**只和朋友交谈**  
**别找我，我会找你**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 15]  
[下一篇 《设计模式09—迭代器与组合模式》][_09]

[Link 1]: https://blog.csdn.net/zhiyikeji/article/details/120644880
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/3398266472ed4fee9104a67dd95de91a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/8dfd3b722d8148349ca83d3974ccba8f.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: https://img-blog.csdnimg.cn/f9e95a0106f7419d82a254d21d931b59.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: https://img-blog.csdnimg.cn/f9afc3c33d894e5abc5038738e363600.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]: https://img-blog.csdnimg.cn/ede3a06a5a604278848e64fab3ec72e3.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]: https://img-blog.csdnimg.cn/b92e02d4f6394546ba95e6cba67e108d.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]: https://img-blog.csdnimg.cn/ea39d9435bc94bda84e5741415c9a4c5.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_19_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/b7eb0a2d53d047898a077cd81f60276a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_19,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]: https://img-blog.csdnimg.cn/b6cd1d7b92714037914db478ef53800e.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]: https://img-blog.csdnimg.cn/9c40b795b6d340c78d9c056f93a635fb.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]: https://img-blog.csdnimg.cn/d140e5006d4c4779bc58de21c3a4be1e.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]: https://img-blog.csdnimg.cn/3ef9df872d3744be9cb11610d5dd57f0.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]: https://img-blog.csdnimg.cn/8177406f51554313bf73b964fb8b19cc.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 12]: https://img-blog.csdnimg.cn/b308c6252f7445ba850c39217fe1cd6b.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[Link 2]: https://blog.csdn.net/zhiyikeji/article/details/118554940
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 13]: https://img-blog.csdnimg.cn/fb4829c2403a4336b55f3bbef312298e.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 14]: https://img-blog.csdnimg.cn/14215ec230d8423da1cf41352c1b55ce.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 15]: https://img-blog.csdnimg.cn/f8f0789656234dd999f51295477fde73.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[_09]: https://blog.csdn.net/zhiyikeji/article/details/121617440