概念：

固定的流程已经写好了，变化的流程定义成了抽象方法，被子类重写。
模板设计就是一种编码风格，把抽象类看作是一个模板，模板中不能决定的东西定义成抽象方法，让使用模板的去重写抽象方法实现需求
简单来说：模板设计就是提前搭建好了一些框架，但是更细节的东西需要实现类再去实现

设计模式：

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

模板设计模式：

把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法，让使用模板的类（继承抽象类的类）去重写抽象方法实现需求，模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可

模板设计模式的优势：

1.只需要关注不同的流程，相同交给父类(模板类)去做。
2.解耦：各司其职，一个类只关注自己的事情

• 模块化：是解耦这种思维的实现方法方式。
• getter/setter就是模块化

演示：

作文模板类

  public abstract class CompositionTemplate {

      public final void write(){
          System.out.println("<<我的爸爸>>");

          body();

          System.out.println("啊~ 这就是我的爸爸");

      }

      public abstract void body();
  }

实现类A

 public class Tom extends CompositionTemplate {

      @Override
      public void body() {
          System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " +
                  "那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");
      }
  }

实现类B

  public class Tony extends CompositionTemplate {
      @Override
      public void body() {

      }

      /*public void write(){

      }*/
  }

测试类

  public class Test {
      public static void main(String[] args) {
          Tom t = new Tom();
          t.write();
      }
  }

模板设计模式

模板方法模式（Template Method Pattern），又叫模板模式(Template Pattern)，在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。

该模式的主要优点如下。
1） 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
2） 它在父类中提取了公共的部分代码，便于代码复用。
3） 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

案例

JdbcTemplate uml 图：

1 pom

 <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

    </dependencies>

2 JdbcFactory

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

public class JdbcFactory {

    /**
     * ###########################DB配置########################
     */
    private static final String URL = "jdbc:mysql://localhost:3306/test?charset=utf8mb4&serverTimezone=UTC&useUnicode=true&useSSL=false";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "123456";
    private static final String DRIVER = "com.mysql.jdbc.Driver";


    private static DataSource db;

    static {

        Map<String, String> map = new HashMap<>();
        map.put(DruidDataSourceFactory.PROP_DRIVERCLASSNAME, DRIVER);
        map.put(DruidDataSourceFactory.PROP_URL, URL);
        map.put(DruidDataSourceFactory.PROP_USERNAME, USERNAME);
        map.put(DruidDataSourceFactory.PROP_PASSWORD, PASSWORD);
        try {
            db = DruidDataSourceFactory.createDataSource(map);
        } catch (Exception e) {
            db = null;
            e.printStackTrace();
        }

    }

    private JdbcFactory() {

    }


    public static DataSource getInstance() {
        return db;
    }


}

3 RowMapper

/**
 * ORM 定制化接口
 */
public interface RowMapper<T> {

    T mapRow(ResultSet rs, int rowNum) throws SQLException;

}

4 JdbcTemplate

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public abstract class JdbcTemplate {


    private DataSource dataSource;

    public JdbcTemplate(DataSource dateSource) {

        this.dataSource = dateSource;
    }


    public <T> List<T> executeQuery(String sql, RowMapper<T> rowMapper, Object[] values) {

        try {
            //1 获取连接
            Connection connection = this.getConnection();
            //2 创建语句集
            PreparedStatement pstm = this.createPrepareStatement(connection, sql);
            //3 执行语句集
            ResultSet rs = execute(pstm, values);
            //4 处理结果集
            List<T> list = paresResultSet(rs, rowMapper);
            //5 关闭结果集
            this.closeResultSet(rs);
            //6 关闭语句集
            this.closeStatement(pstm);
            //7 关闭连接
            this.closeConnection(connection);
            //8 返回
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }


        return new ArrayList<>();
    }

    protected void closeConnection(Connection connection) throws SQLException {

        if (connection != null) {
            connection.close();
        }

    }

    protected void closeStatement(PreparedStatement pstm) throws SQLException {
        pstm.close();
    }


    protected void closeResultSet(ResultSet rs) throws SQLException {
        rs.close();
    }

    protected <T> List<T> paresResultSet(ResultSet rs, RowMapper<T> rowMapper) throws SQLException {
        List<T> result = new ArrayList<>();
        int rowNum = 1;
        while (rs.next()) {
            result.add(rowMapper.mapRow(rs, rowNum++));
        }
        return result;

    }

    private ResultSet execute(PreparedStatement pstm, Object[] values) throws SQLException {

        if (values != null) {
            for (int i = 0; i < values.length; i++) {
                pstm.setObject(i, values[i]);
            }
        }
        return pstm.executeQuery();
    }

    protected PreparedStatement createPrepareStatement(Connection connection, String sql) throws SQLException {


        return connection.prepareStatement(sql);

    }

    private Connection getConnection() throws SQLException {

        return this.dataSource.getConnection();
    }


}

5 业务类

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Student {

    private Integer id;

    private String name;

    private Integer age;


}



public class StudentDao extends JdbcTemplate {

    public StudentDao(DataSource dateSource) {
        super(dateSource);
    }


    public List<Student> selectAll() {
        String sql = "select * from t_student";
        return super.executeQuery(sql, (rs, rowNum) -> {
            Student student = new Student();
            student.setId(rs.getInt("id"));
            student.setAge(rs.getInt("age"));
            student.setName(rs.getString("name"));
            return student;
        }, null);

    }


}

6 测试

public class JdbcTest {


    public static void main(String[] args) throws Exception {

        DataSource instance = JdbcFactory.getInstance();
        StudentDao studentDao=new StudentDao(instance);
        List<Student> students = studentDao.selectAll();
        System.out.println(students.toString());


    }

}

1. 模板模式概述

1.1 模板模式介绍

1.模板方法模式（Template Method Pattern），又叫模板模式（Template Pattern）， 在一个抽象类公开定义了执行它的方法的模板。它的子类可以更需要重写方法实现，但可以成为典型类中定义的方式进行。
2.简单说，模板方法模式定义了一个操作中的算法的核心定义，而将一些步骤迟缓到子类中，模仿子类可以不改变一一个算法的结构，就可以重新定义该算法的部分特定步骤。
3.这些类型的设计模式属于行为型模式。

模板模式适用于通用步骤的操作，比如做菜，不管你是西红柿炒鸡蛋，还是土豆炖牛肉实现步骤都是一样的，备料，做菜，上菜。
再比如投放系统，不管你是投放巨量引擎，广点通还是百度，前期工作实现步骤也都是一样的，配置物料信息，构建投放对象，投放广告。

1.2 模板模式类图

对原理类图的说明-即(模板方法模式的角色及职责)
1.AbstractClass 抽象类, 类中实现了模板方法(template),定义了算法的骨架,具体子类需要去实现 其它的抽象方法。
2.ConcreteClass 实现抽象方法, 以完成算法中特点子类的步骤。

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

1. 基本思想是：算法只存在于一个地方,也就是在父类中,容易修改.需要修改算法时,只要修改父类的模板方 法或者已经实现的某些步骤,子类就会继承这些修改
2. 实现了最大化代码复用.父类的模板方法和已实现的某些步骤会被子类继承而直接使用.
3. 既统一了算法,也提供了很大的灵活性.父类的模板方法确保了算法的结构保持不变,同时由子类提供部分步 骤的实现.
4. 该模式的不足之处：每个不同的实现都需要一个子类实现,导致类的个数增加,使得系统更加庞大
5. 一般模板方法都加上 final 关键字, 防止子类重写模板方法.
6. 模板方法模式使用场景：当要完成在某个过程,该过程要执行一系列步骤 ,这一系列的步骤基本相同,但其 个别步骤在实现时 可能不同,通常考虑用模板方法模式来处理

2. 模板模式实现

模板模式实现案例采用三种方式：
第一案例是做菜，无论做什么菜都是这三个步骤，备料，做菜，上菜，但是三个步骤都不相同，模板定义步骤流程，通过不同的子类继承抽象模板实现模板设计模式。

第二个案例是银行办理业务，无论办理什么业务都是取号，办理业务，评价。这里取号与评价都是相同的，各个子类只需要处理不同业务即可，通过不同的子类继承抽象模板实现模板设计模式。

第三个案例是银行办理业务的Java8函数式编程消费者模式Consumer模式改造，原理相同。

2.1 做菜模板模式

DishEggsWithTomato

package com.zrj.design.template.dish;

/**
 * 西红柿炒鸡蛋
 *
 * @author zrj
 * @since 2022/2/8
 */
public class DishEggsWithTomato extends DishTemplate {
    @Override
    public void preparation() {
        System.out.println("准备西红柿鸡蛋...");
    }

    @Override
    public void doing() {
        System.out.println("开始炒西红柿鸡蛋...");
    }

    @Override
    public void carriedDishes() {
        System.out.println("西红柿鸡蛋装盘...");
    }
}

DishOnionWithTofu

package com.zrj.design.template.dish;


/**
 * 小葱拌豆腐
 *
 * @author zrj
 * @since 2022/2/8
 */
public class DishOnionWithTofu extends DishTemplate {
    @Override
    public void preparation() {
        System.out.println("准备小葱豆腐...");
    }

    @Override
    public void doing() {
        System.out.println("开始炒小葱拌豆腐...");
    }

    @Override
    public void carriedDishes() {
        System.out.println("小葱拌豆腐装盘...");
    }
}

DishTemplate

package com.zrj.design.template.dish;

/**
 * 做菜模板类
 * 用于定义做菜的执行步骤，所有菜都可以按照这种方式做菜
 *
 * @author zrj
 * @since 2022/2/8
 */
public abstract class DishTemplate {
    /**
     * 做菜执行步骤
     */
    public final void doDish() {
        this.preparation();
        this.doing();
        this.carriedDishes();
    }

    /**
     * 备料
     */
    public abstract void preparation();

    /**
     * 做菜
     */
    public abstract void doing();

    /**
     * 上菜
     */
    public abstract void carriedDishes();

}

DishTemplateTest

package com.zrj.design.template.dish;


import org.junit.Test;

/**
 * 模板模式
 * 抽象父类定义方法模板，子类自定义实现方式。
 * 优点： 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。
 * 缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。
 * 使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。
 * 注意事项：为防止恶意操作，一般模板方法都加上 final 关键词。
 *
 * 使用场景很多，只要有相同的执行逻辑，或者重要的复杂的方法，都可以交给父类管理。
 * 比如开发XX系统步骤都是一样的，立项，需求，开发，测试，上线。
 *
 * @author zrj
 * @since 2022/2/8
 */
public class DishTemplateTest {
    @Test
    public void templateTest() {
        System.out.println("----------西红柿炒鸡蛋----------");
        DishTemplate eggsWithTomato = new DishEggsWithTomato();
        eggsWithTomato.doDish();

        System.out.println("----------小葱拌豆腐----------");
        DishTemplate onionWithTofu = new DishOnionWithTofu();
        onionWithTofu.doDish();
    }

}

2.2 银行办理业务模板模式

BankBusinessHandler

package com.zrj.design.template.bank;

import cn.hutool.core.util.RandomUtil;

/**
 * 模板方法设计模式的抽象类
 * 模板设计模式主要用来处理相同处理流程中的不同点，例如银行办理业务，无论什么业务，首先需要取号，其次处理业务，然后评价不同之处在于处理不同的业务使用不同的方式。
 * BankBusinessHandler作为抽象模板
 * BankSaveMoneyHandler作为存钱业务处理类，继承抽象模板BankBusinessHandler
 * BankDrawMoneyHandler作为理财业务处理类，继承抽象模板BankBusinessHandler
 *
 * @author zrj
 * @since 2022/2/8
 **/
public abstract class BankBusinessHandler {

    /**
     * 模板方法，执行器
     */
    public final void execute() {
        getNumber();
        handle();
        judge();
    }

    /**
     * 取号
     */
    private void getNumber() {
        System.out.println("取号：" + RandomUtil.randomNumbers(8));
    }

    /**
     * 办理业务
     */
    public abstract void handle();

    /**
     * 评价
     */
    private void judge() {
        System.out.println("评价：五星好评！");
    }

}

BankBusinessHandlerTest

package com.zrj.design.template.bank;

/**
 * 模板方法测试类
 *
 * @author zrj
 * @since 2022/2/8
 **/
public class BankBusinessHandlerTest {
    public static void main(String[] args) {

        //存钱业务处理
        BankSaveMoneyHandler bankSaveMoneyHandler = new BankSaveMoneyHandler();
        bankSaveMoneyHandler.execute();

        System.out.println("------------------------------");

        //理财业务处理
        BankDrawMoneyHandler bankDrawMoneyHandler = new BankDrawMoneyHandler();
        bankDrawMoneyHandler.execute();

    }
}

BankDrawMoneyHandler

package com.zrj.design.template.bank;

/**
 * 理财业务
 *
 * @author zrj
 * @since 2022/2/8
 **/
public class BankDrawMoneyHandler extends BankBusinessHandler {
    /**
     * 办理业务
     */
    @Override
    public void handle() {
        System.out.println("理财：2000$");
    }
}

BankSaveMoneyHandler

package com.zrj.design.template.bank;

/**
 * 存钱业务
 *
 * @author zrj
 * @since 2022/2/8
 **/
public class BankSaveMoneyHandler extends BankBusinessHandler {
    /**
     * 办理业务
     */
    @Override
    public void handle() {
        System.out.println("存钱：1000$");
    }
}

2.3 银行办理业务函数式编程改造

BankBusinessHandlerCustomer

package com.zrj.design.template.customer;

import cn.hutool.core.util.RandomUtil;

import java.math.BigDecimal;
import java.util.function.Consumer;

/**
 * 模板设计模式的抽象类
 * Java8函数式编程消费者模式Customer实现模板设计模式
 *
 * @author zrj
 * @since 2022/2/8
 **/
public class BankBusinessHandlerCustomer {
    /**
     * 存钱
     */
    public void save(BigDecimal amount) {
        execute(a -> System.out.println("存钱：" + amount));
    }

    /**
     * 理财
     */
    public void draw(BigDecimal amount) {
        execute(a -> System.out.println("理财：" + amount));
    }

    /**
     * 模板方法，执行器
     */
    public void execute(Consumer<BigDecimal> consumer) {
        getNumber();
        consumer.accept(null);
        judge();
    }

    /**
     * 取号
     */
    private void getNumber() {
        System.out.println("取号：" + RandomUtil.randomNumbers(8));
    }

    /**
     * 评价
     */
    private void judge() {
        System.out.println("评价：五星好评！");
    }
}

BankBusinessHandlerCustomerTest

package com.zrj.design.template.customer;

import java.math.BigDecimal;

/**
 * @author zrj
 * @since 2022/2/8
 **/
public class BankBusinessHandlerCustomerTest {
    public static void main(String[] args) {
        //构建银行业务处理对象
        BankBusinessHandlerCustomer businessHandler = new BankBusinessHandlerCustomer();

        //存钱业务处理
        businessHandler.save(new BigDecimal("3000"));

        System.out.println("------------------------------");

        //理财业务处理
        businessHandler.draw(new BigDecimal("6000"));

    }

}