设计模式——模板模式

更多内容，前往 IT-BLOG

在面向对象程序设计过程中，程序员常常会遇到如下情况：设计一个系统时知道算法所需的关键步骤，且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。例如：去医院看病一般都要经历以下流程：挂号、排队、就诊、取药等，其中挂号和排队对每个客户都是一样的，可以在父类中实现，但是就诊和取药是因人而异的。可以延迟到子类中实现。我们把这些规定了流程或格式的实例定义成模板，允许使用者根据自己的需求去更新它。

一、模板模式的基本介绍

1）、模板方法模式（Template Method Pattern），又叫模板模式（Template Pattern），在一个抽象类公开定义了执行此方法的模板。它的子类可以按照需要重写方法实现，但调用将以抽象类中定义的方式进行。
2）、简单说，模板方法模式定义了一个操作中的算法骨架，而将步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤。
3）、这种类型的设计模式属于行为型模式。

二、模板方式的特点

模板方式的优点：【1】封装了不变的部分，扩展可变部分。将不变部分的算法封装到父类中实现，而把可变部分的算法由各子类实现。便于子类继续扩展。
【2】在父类中提取了公共的部分代码，便于代码复用。
【3】部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。
模板方式的缺点：【1】对每个不同的实现都需要定义一个子类，这个导致类的个数增加，系统更加庞大，设计也更加抽象。
【2】父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，提高了代码的阅读难度。
使用场景：【1】当多个子类具有公用的方法，却执行流程逻辑相同时。
【2】重要的、复杂的方法，可以考虑作为模板方法。
注意事项：为了防止恶意操作，一般模板方法上都加有 final 关键字

三、模板方法模式结构类图

模板方法模式包含以下主要角色：【1】抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成，如下：
    ① 抽象方法：在抽象类中申明，由具体子类实现。
    ② 具体方法：在抽象类中已经实现，再具体子类中可以继承或重写它。
    ③ 钩子方法：在抽象类中已经实现，例如：用于判断的逻辑方法或者定义一个空方法。子类根据情况要不要重写此方法，此方法为钩子方法。例如下面实例中的 isRecipe() 方法。
【2】具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

​

四、 模板方式模式案例分析

【1】抽象类（医院看病时，整个流程的抽象类）真个流程属于不可变的，因此我使用了 final 修饰。

 1 public abstract class AbstractHospital {
 2     //流程
 3     public final void procedure() {
 4         //1、挂号
 5         this.regiest();
 6         //2、排队
 7         this.queue();
 8         //3、看病
 9         this.treat();
10         //4、取药，有点人不用开药，只是小事
11         if(isRecipe()) {
12             this.recipe();
13         }
14     }
15     //挂号
16     public String regiest() {
17         String regiest = "你的订单号为"+((int) (Math.random()*10));
18         System.out.println(regiest);
19         return regiest;
20     }
21     //排队
22     public void queue() {
23         System.out.println("排队中。。。。");
24     }
25     //看病
26     public abstract String  treat();
27     //取药
28     public abstract String recipe();
29     
30     //钩子方法
31     boolean isRecipe() {
32         return true;
33     }
34 }

【2】抽象类的具体实现类（有多个，我们只写一个）

 1 public class Patient_A extends AbstractHospital{
 2     @Override
 3     public String treat() {
 4         String treat = "胃病";
 5         System.out.println("你的病为"+treat);
 6         return treat;
 7     }
 8     @Override
 9     public String recipe() {
10         String recipe = "健胃消食片";
11         System.out.println("药单："+recipe);
12         return recipe;
13     }
14     
15     //重写钩子方法
16     @Override
17     boolean isRecipe() {
18         return false;
19     }
20 }

【3】客户端类：创建子类对象，流程调用的是父类公共的流程方法。

 1 public class Client {
 2     public static void main(String[] args) {
 3         //A 病人看病
 4         Patient_A patient_A = new Patient_A();
 5         //看病的流程
 6         patient_A.procedure();
 7         /**
 8          * 输出如下：
 9          * 你的订单号为2
10          * 排队中。。。。
11          * 你的病为胃病
12          * 药单：健胃消食片 ==== 加了钩子程序则不显示
13          */
14         //B 病人看病，的流程也是一样，只需要实例化B，并调用公共的模板流程即可，提高代码的利用率
15     }
16 }

五、模仿方法模式应用源码分析

模板方法模式在 Spring 框架应用的源码分析：Spring IOC 容器初始化时运用到了模板方法模式；

【1】抽象类：AbstractApplicationContext 继承接口（ConfigurableApplicationContext）其中的 refresh 方法就是模板方法，定义了执行的流程，方法中包含钩子方法、子类需要实现的抽象方法（refreshBeanFactory）、父类已实现的方法等等。

 1 public abstract class AbstractApplicationContext extends DefaultResourceLoader
 2         implements ConfigurableApplicationContext, DisposableBean {
 3     ......
 4     @Override
 5     public void refresh() throws BeansException, IllegalStateException {
 6         synchronized (this.startupShutdownMonitor) {
 7             prepareRefresh();
 8 
 9             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
10 
11             prepareBeanFactory(beanFactory);
12 
13             try {
14                 // 钩子方法，子类自行选择是否重写
15                 postProcessBeanFactory(beanFactory);
16 
17                 invokeBeanFactoryPostProcessors(beanFactory);
18 
19                 registerBeanPostProcessors(beanFactory);
20 
21                 // 父类已实现
22                 initMessageSource();
23 
24                 // 由父类进行实现
25                 initApplicationEventMulticaster();
26 
27                 // 钩子方法
28                 onRefresh();
29 
30                 registerListeners();
31 
32                 finishBeanFactoryInitialization(beanFactory);
33 
34                 // 父类实现
35                 finishRefresh();
36             }
37 
38             catch (BeansException ex) {
39                 
40                 destroyBeans();
41 
42                 cancelRefresh(ex);
43                 
44                 throw ex;
45             }
46         }
47     }
48     ......
49 }

【2】构建 AbstractApplicationContext  类图：
​

六、模板方法模式的注意事项和细节

【1】基本思想是：算法只存在于一个地方，也就是父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改。
【2】实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承且直接使用。
【3】既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构不变，同时由子类提供部分步骤的实现。
【4】该模式的不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增多，使得系统更加庞大。
【5】模板方式的使用场景：存在执行一系列步骤，且一类产品的此步骤基本相同，但其中个别步骤的实现细节不同时，通常可以考虑使用模板方法模式。

posted @ 2020-11-19 14:26  Java程序员进阶  阅读(330)  评论(0)  编辑  收藏  举报