设计模式-模版方法模式

 
  • 文章目录
    • 一、模版方法模式的简介;
    • 二、代码实例;

一、模版方法模式的简介

  1. 原型模式:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。Template Method 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤
  2. 归类:行为型

二、代码实例

  1. 反面例子我就不举了,就举一个常用的JDBC封装吧;
  2. 创建实体类 BookDO.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     package com.demo.template.entity;

    import lombok.Data;

    /**
    * 书籍DO
    */
    @Data
    public class BookDO {
    private Long id;
    private String name;
    }
  3. 创建SQL常量帮助类 SQLCommon.java

    1
    2
    3
    4
    5
    6
    7
    8
     package com.demo.template.common;

    public class SQLCommon{
    public static final String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT";
    public static final String driver = "com.mysql.cj.jdbc.Driver";
    public static final String user = "root";
    public static final String password = "root";
    }
  1. 创建数据库链接抽象类 JdbcTemplate.java

    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
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    package com.demo.template.common;

    import com.demo.template.entity.BookDO;

    import java.sql.*;
    import java.util.ArrayList;
    import java.util.List;

    public abstract class JdbcTemplate {

    private Connection conn = null;
    private PreparedStatement pst = null;
    private ResultSet rst = null;

    /**
    * 1、加载驱动
    * 2、获取连接
    * @return 数据库连接
    */
    private Connection getConnection() {
    try {
    // 加载数据库驱动程序
    try {
    Class.forName(SQLCommon.driver);
    } catch (ClassNotFoundException e) {
    System.out.println("加载驱动错误");
    }
    // 获取连接
    conn = DriverManager.getConnection(SQLCommon.url, SQLCommon.user, SQLCommon.password);
    } catch (SQLException e) {
    System.out.println(e.getMessage());
    }
    return conn;
    }

    /**
    * 3、获得PreparedStatement
    * @return 数据库连接
    */
    private PreparedStatement getStatement(String sql) {
    try {
    pst = conn.prepareStatement(sql);
    } catch (SQLException e) {
    System.out.println("创建语句集错误");
    }
    return pst;
    }

    /**
    * 4.1 ----->insert update delete SQL语句的执行的统一方法
    * @param sql SQL语句
    * @return 执行是否成功
    */
    public boolean executeUpdate(String sql) {
    try {
    conn = this.getConnection();
    pst = conn.prepareStatement(sql);
    return pst.executeUpdate() > 0;
    } catch (SQLException e) {
    System.out.println(e.getMessage());
    } finally {
    // 释放资源
    close();
    }
    return false;
    }

    /**
    * 4.2---->SQL 查询将查询结果:一行
    * @param sql SQL语句
    * @return 结果集
    */
    public <T> T findOne(String sql) {
    try {
    conn = this.getConnection();
    pst = conn.prepareStatement(sql);
    rst = pst.executeQuery();
    T t = null;
    if(rst.next()){
    t=rowMapper(rst);
    }
    return t;
    } catch (SQLException e) {
    System.out.println(e.getMessage());
    } finally {
    close();
    }
    return null;
    }

    /**
    * 4.3---->返回一个List
    * @param <T>
    * @param sql
    * @return
    */
    public <T> List<T> list(String sql) {
    try {
    conn = this.getConnection();
    pst = conn.prepareStatement(sql);
    rst = pst.executeQuery();
    T t = null;
    List<T> list = new ArrayList<T>();
    while (rst.next()) {
    t = rowMapper(rst);
    list.add(t);
    }
    return list;
    } catch (SQLException e) {
    System.out.println(e.getMessage());
    } finally {
    close();
    }
    return null;
    }

    /**
    * 5.关闭结果集、关闭语句集、关闭连接
    */
    private void close() {
    // 关闭结果集对象
    if (rst != null) {
    try {
    rst.close();
    } catch (SQLException e) {
    System.out.println(e.getMessage());
    }
    }

    // 关闭PreparedStatement对象
    if (pst != null) {
    try {
    pst.close();
    } catch (SQLException e) {
    System.out.println(e.getMessage());
    }
    }
    // 关闭Connection 对象
    if (conn != null) {
    try {
    conn.close();
    } catch (SQLException e) {
    System.out.println(e.getMessage());
    }
    }
    }

    abstract protected <T> T rowMapper(ResultSet rs) throws SQLException;
    }
  2. 创建底层数据处理类BookMapper.java

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
29
package com.demo.template.mapper;


import com.demo.template.entity.BookDO;
import com.demo.template.common.JdbcTemplate;

import java.sql.ResultSet;
import java.sql.SQLException;

/**
* 底层数据处理
*/
public class BookMapper extends JdbcTemplate {

public BookDO findById(Long id){
String sql = "SELECT * FROM book WHERE id ="+id;
BookDO bookDO=super.findOne(sql);
return bookDO;
}


@Override
protected BookDO rowMapper(ResultSet rs) throws SQLException {
BookDO bookDO = new BookDO();
bookDO.setId(rs.getLong("id"));
bookDO.setName(rs.getString("name"));
return bookDO;
}
}
  1. 创建测试类(包含了分析)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import com.fasterxml.jackson.databind.ObjectMapper;

public class TemplateTest {
public static void main(String[] args) throws JsonProcessingException {
//数据库操作步骤
/**
* 1、加载驱动Class.forName
* 2、获取连接Connection
* 3、获得PreparedStatement
* 4、执行语句集,获得结果
* 5、关闭结果集、关闭语句集、关闭连接
* 我们分析下,这几个步骤在所有操作的地方 有区别的地方就在于 4
*/
BookMapper bookMapper=new BookMapper();
BookDO bookDO=bookMapper.findById(1L);
System.out.println(new ObjectMapper().writeValueAsString(bookDO));
}
}

总结:其实模板模式很简单,一句话总结就是:在相同的流程下,某个细节实现不一致的情况下,抽取共同的方法,抽象话该细节方法,让子类处理。


 评论