设计模式系列:模板方法模式

发表于 | 分类于 ， | |

概念

模板方法模式 在意个方法中定义一个算法的骨架，而将这些具体步骤实现延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中
的某些步骤。

实现

  • 类图：

图片

  • AbstractProjectDesign:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    package com.littlehui.design.templatemethod;

    /**
     * @Description TODO
     * @ClassName AbstractProjectDesign
     * @Author littlehui
     * @Date 2019/10/9 11:12
     * @Version 1.0
     **/
    public abstract class AbstractProjectDesign {

        public final void tempateMethod() {
            //需求分析
            demandAnalysis();
            //架构设计
            architecturalDesign();
            //代码编写
            coding();
        }

        protected abstract void demandAnalysis();

        protected abstract void architecturalDesign();

        protected abstract void coding();

    }

  • PaymentProjectDesign:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28

    package com.littlehui.design.templatemethod;

    /**
     * @Description TODO
     * @ClassName PaymentProjectDesign
     * @Author littlehui
     * @Date 2019/10/9 11:27
     * @Version 1.0
     **/
    public class PaymentProjectDesign extends AbstractProjectDesign {


        @Override
        protected void demandAnalysis() {
            System.out.println("支付项目需求分析");
        }

        @Override
        protected void architecturalDesign() {
            System.out.println("支付项目的架构设计");
        }

        @Override
        protected void coding() {
            System.out.println("支付项目的编码");
        }
    }

  • SearchProjectDesign:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27

    package com.littlehui.design.templatemethod;

    /**
     * @Description TODO
     * @ClassName SearchProjectDesign
     * @Author littlehui
     * @Date 2019/10/9 11:32
     * @Version 1.0
     **/
    public class SearchProjectDesign extends AbstractProjectDesign {

        @Override
        protected void demandAnalysis() {
            System.out.println("搜索项目需求分析");
        }

        @Override
        protected void architecturalDesign() {
            System.out.println("搜索项目架构设计");
        }

        @Override
        protected void coding() {
            System.out.println("搜索项目编码");
        }
    }

  • Client:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20

    package com.littlehui.design.templatemethod;

    /**
     * @Description TODO
     * @ClassName Client
     * @Author littlehui
     * @Date 2019/10/9 11:33
     * @Version 1.0
     **/
    public class Client {

        public static void main(String[] args) {
            AbstractProjectDesign paymentProject = new PaymentProjectDesign();
            AbstractProjectDesign searchProject = new SearchProjectDesign();

            paymentProject.tempateMethod();
            searchProject.tempateMethod();
        }
    }

执行：

1
2
3
4
5
6
7
8
9
10
Connected to the target VM, address: '127.0.0.1:50695', transport: 'socket'
支付项目需求分析
支付项目的架构设计
支付项目的编码
搜索项目需求分析
搜索项目架构设计
搜索项目编码
Disconnected from the target VM, address: '127.0.0.1:50695', transport: 'socket'

Process finished with exit code 0

抽象类里的tempateMethod执行的是具体的业务逻辑。以一个个抽象方法呈现。以上展示的逻辑是顺序执行逻辑。
此外还可以加上分支，利用模板钩子的方式实现分支逻辑。在具体实现类里面进行取舍。

场景

使用模板方法首先将不同业务场景分解成顺序执行的逻辑。将这些具体的逻辑抽出共性，组成抽象方法。如果有
具体的分支的话，利用钩子的方法进行扩展。

总结

模板方法重点在于定义模板类。
注意的点
1:模板类由 基本方法，模板方法，钩子方法构成。
2：基本方法用final修饰。表明不能修改的。其他的模板方法，钩子等用protected修饰，用于子类的集成修改。