java设计模式之模板模式

约定不等于承诺〃 2023-10-08 10:23 5阅读 0赞

### 一、概述 ###

模板模式从字面上理解就是，定义一个模板，然后被后续的各个业务中使用，定义模板，就是定义框架、结构、原型，也就是大家共同遵守的某个约定，有了模板，在具体的使用中，就可以对它进行后续的完善、充实

在java中，模板采用抽象类定义，公共的结构化逻辑在抽象类中完成，非公共的部分或逻辑抽象出去，留给子类去实现

总的来说，模板模式就是通过抽象类来定义一个逻辑模板，逻辑框架、逻辑原型，然后将无法决定的部分抽象成抽象类交由子类来实现，一般这些抽象类的调用逻辑还是在抽象类中完成的。这么看来，模板就是定义一个框架，比如造汽车，我们定义一个模板：使用什么样的车门，什么样的把手，挡风玻璃等等，但是要什么样的门，什么样的把手，这些并不在模板中描述，这个交给子类来完善

### 二、代码实现 ###

下面使用一个简单的代码演示一下

**1、抽象模板类**

/**
     * 造房的模板
     */
    public abstract class HouseTemplate {
        
    
        protected String name;
    
        protected HouseTemplate(String name){
        
            this.name = name;
        }
    	
    	//建门模板
        protected abstract void buildDoor();
    
    	//建窗模板
        protected abstract void buildWindow();
    
        //公共逻辑
        public final void buildHouse(){
        
            buildDoor();
            buildWindow();
        }
    
    }

**2、具体实现类**

/**
     *第一个创建房屋的标准类
     */
    public class HouseOne extends HouseTemplate{
        
    
        HouseOne(String name){
        
            super(name);
        }
    
        @Override
        protected void buildDoor() {
        
            System.out.println(name +"的门要采用安全防盗门");
        }
    
        @Override
        protected void buildWindow() {
        
            System.out.println(name + "的窗户要面向北方，采光好");
        }
    
    }

/**
     * 第二个创建房屋的标准类
     */
    public class HouseTwo extends HouseTemplate{
        
    
        HouseTwo(String name){
        
            super(name);
        }
    
        @Override
        protected void buildDoor() {
        
            System.out.println(name + "的门采用传统木门");
        }
    
        @Override
        protected void buildWindow() {
        
            System.out.println(name + "的窗户要向南，光线不要太强");
        }
    
    }

测试类：

public class Test1 {
        
    
        public static void main(String[] args) {
        
    
            HouseTemplate houseOne = new HouseOne("房子1");
            HouseTemplate houseTwo = new HouseOne("房子2");
            houseOne.buildHouse();
            houseTwo.buildHouse();
        }
    
    }

运行一下这段代码：可以看到，具体的业务实现类可以根据自己的实际需要得到自己的业务效果  
![在这里插入图片描述][20191206123438421.png]

### 三、项目中的实际运用 ###

那么，怎样在实际项目或业务中使用模板设计模式呢？其实按我个人理解，设计模式就是一种设计思想，通过使用设计模式，可以让代码的逻辑实现更加优雅、封装性更好、可维护性更强，在spring框架中，多处都有设计模式的体现，下面通过一个简单的场景来演示一下

**需求说明：**  
我们需要根据不同的数据库连接类型获取数据库的连接信息，同时，在很多业务类中都需要执行数据库的CRUD的操作，下面以原生的jdbc连接为例进行说明：

**1、数据库CRUD操作模板类**

在这个模板中，crud的操作方法留给具体的业务实现类实现，更多的方法可以继续扩展，定义连接数据库的类型，根据传入的不同的数据库类型得到connetion

import java.sql.Connection;
    import java.sql.DriverManager;
    
    /**
     * 定义公共的查询模板，基本数据库连接信息
     */
    public abstract class AbstarctDao {
        
    
        protected String connectionType;
        protected String host;
        protected String port;
        protected String dbName;
        protected String userName;
        protected String passWord;
    
        AbstarctDao(String connectionType, String host, String port, String dbName, String userName, String passWord) {
        
            this.connectionType = connectionType;
            this.host = host;
            this.port = port;
            this.dbName = dbName;
            this.userName = userName;
            this.passWord = passWord;
        }
    
        /**
         * 获取数据库连接
         *
         * @return
         */
        public Connection getConnection() {
        
            Connection connection = null;
            switch (connectionType) {
        
    
                case "MYSQL":
                    try {
        
                        Class.forName("com.mysql.cj.jdbc.Driver");
                        String prefixName = "?autoReconnect=true&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false";
                        String jdbcUrl = "jdbc:mysql://" + host + ":" + port + "/" + dbName + prefixName;
                        System.out.println(jdbcUrl);
                        connection = DriverManager.getConnection(jdbcUrl, userName, passWord);
                        break;
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
    
                case "Oracle":
                    try {
        
                        Class.forName("oracle.jdbc.OracleDriver");
                        String jdbcUrl = "jdbc:oracle:thin@" + host + ":" + port + ":" + dbName;
                        connection = DriverManager.getConnection(jdbcUrl, userName, passWord);
                        break;
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
    
                case "DB2":
                    try {
        
                        Class.forName("com.ibm.db2.jcc.DB2Driver");
                        String jdbcUrl = "jdbc:db2" + host + ":" + port + ":" + dbName;
                        connection = DriverManager.getConnection(jdbcUrl, userName, passWord);
                        break;
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
    
                case "Access2003":
                    try {
        
                        String jdbcUrl = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=" + host;
                        connection = DriverManager.getConnection(jdbcUrl, userName, passWord);
                        break;
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
            }
            return connection;
        }
    
        //查询
        public abstract Object handleqQuery(String sql);
    
        //修改
        public abstract int handleUpdate(String sql, String[] args);
    
        //删除
        public abstract void handleDelete(String sql);
    
        // ......
    
    }

**2、具体的实现类**

/**
     * 具体操作的业务类
     */
    public class ServiceImplOne extends AbstarctDao{
        
    
        ServiceImplOne(String connectionType,String host,String port,String dbName,String userName,String passWord){
        
            super(connectionType,host,port,dbName,userName,passWord);
        }
    
        /**
         * 数据查询逻辑
         * @param sql
         * @return
         */
        @Override
        public Object handleqQuery(String sql) {
        
            List<Map<String,String>> resMap = new ArrayList<>();
            Connection connection = null;
            PreparedStatement ps = null;
            ResultSet result = null;
            try {
        
                connection = getConnection();
                ps = connection.prepareStatement(sql);
                result = ps.executeQuery(sql);
    
                while (result.next()){
        
                    Map<String,String> oneMap = new HashMap<>();
                    String id = result.getString("id");
                    String loginName = result.getString("login_name");
                    System.out.println("id:" + id);
                    System.out.println("loginName:" +loginName);
                    oneMap.put("id",id);
                    oneMap.put("loginName",loginName);
                    resMap.add(oneMap);
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }finally {
        
                CloseUtils.closeResult(result);
                CloseUtils.closeStatement(ps);
                CloseUtils.closeConnection(connection);
            }
            return resMap;
        }
    
        @Override
        public int handleUpdate(String sql, String[] args) {
        
            return 0;
        }
    
        @Override
        public void handleDelete(String sql) {
        
    
        }
    
        public static void main(String[] args){
        
    
            String connectionType = MysqlEnum.CONNECTION_TYPE.getMessage();
            String host = MysqlEnum.HOST.getMessage();
            String port = MysqlEnum.PORT.getMessage();
            String dbName = MysqlEnum.DBNAME.getMessage();
            String userName = MysqlEnum.USER_NAME.getMessage();
            String passWord = MysqlEnum.PASS_WORD.getMessage();
            ServiceImplOne one = new ServiceImplOne(connectionType,host,port,dbName,userName,passWord);
            String sql = "select * from sys_user limit 2";
            Map resMap = (Map)one.handleqQuery(sql);
            System.out.println(resMap);
        }

在这个类中，我这里只实现了查询的方法，实际项目中，可以根据业务需求进行实现，下面我们运行一下，可以看到可以正常查询到数据了，使用起来是不是很方便？  
![在这里插入图片描述][20191206124356250.png]

**3、配合的工具类**  
关闭数据库连接

import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class CloseUtils {
        
    
        public static void closeConnection(Connection connection) {
        
            try {
        
                if (connection != null) {
        
                    connection.close();
                }
            } catch (SQLException se) {
        
                se.printStackTrace();
            }
        }
    
        public static void closeResult(ResultSet res) {
        
            try {
        
                if (res != null) {
        
                    res.close();
                }
            } catch (SQLException se) {
        
                se.printStackTrace();
            }
        }
    
        public static void closeStatement(PreparedStatement pstmt) {
        
            try {
        
                if (pstmt != null) {
        
                    pstmt.close();
                }
            } catch (SQLException se) {
        
                se.printStackTrace();
            }
        }
    
    }

数据库连接信息维护枚举类

public enum MysqlEnum {
        
    
        CONNECTION_TYPE(1, "MYSQL"),
        HOST(2, "IP"),
        PORT(3, "端口号"),
        DBNAME(4, "dbName"),
        USER_NAME(5, "用户名"),
        PASS_WORD(6, "密码"),
        ;
    
        private Integer code;
        private String message;
    
        private MysqlEnum(Integer code, String message) {
        
            this.code = code;
            this.message = message;
        }
    
        public Integer getCode() {
        
            return this.code;
        }
    
        public String getMessage() {
        
            return this.message;
        }
    }

下面附上通过JDBC的方式获取数据库表名、字段名等元数据信息工具类，方便后续查阅

import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.sql.*;
    import java.util.ArrayList;
    import java.util.List;
    
    public class DatabaseMetaDataUtils {
        
    
        private static final Logger logger = LoggerFactory.getLogger(DatabaseMetaDataUtils.class);
    
        private static final String DRIVER = "com.mysql.jdbc.Driver";
        private static final String DATABASE_URL = "jdbc://mysql:3306 .......";
        private static final String USERNAME = "username";
        private static final String PASSWORD = "password";
        private static final String SQL = "SELECT * FROM ";// 数据库操作
    
        static {
        
            try {
        
                Class.forName(DRIVER);
            } catch (ClassNotFoundException e) {
        
                logger.error("can not load jdbc driver", e);
            }
        }
    
        /**
         * 获取数据库连接
         *
         * @return
         */
        public static Connection getConnection() {
        
            Connection conn = null;
            try {
        
                conn = DriverManager.getConnection(DATABASE_URL, USERNAME, PASSWORD);
            } catch (SQLException e) {
        
                logger.error("get connection failure", e);
            }
            return conn;
        }
    
        /**
         *     * 关闭数据库连接
         *     * @param conn
         *    
         */
        public static void closeConnection(Connection conn) {
        
            if (conn != null) {
        
                try {
        
                    conn.close();
                } catch (SQLException e) {
        
                    logger.error("close connection failure", e);
                }
            }
        }
    
        /**
         *     * 获取数据库下的所有表名
         *    
         */
        public static List<String> getTableNames() {
        
            List<String> tableNames = new ArrayList<>();
            Connection conn = getConnection();
            ResultSet rs = null;
            try {
        
                //获取数据库的元数据
                DatabaseMetaData db = conn.getMetaData();
                //从元数据中获取到所有的表名
                rs = db.getTables(null, null, null, new String[]{
        "TABLE"});
                while (rs.next()) {
        
                    tableNames.add(rs.getString(3));
                }
            } catch (SQLException e) {
        
                logger.error("getTableNames failure", e);
            } finally {
        
                try {
        
                    rs.close();
                    closeConnection(conn);
                } catch (SQLException e) {
        
                    logger.error("close ResultSet failure", e);
                }
            }
            return tableNames;
        }
    
    
        /**
         *     * 获取表中所有字段名称
         *     * @param tableName 表名
         *     * @return
         *    
         */
        public static List<String> getColumnNames(String tableName) {
        
            List<String> columnNames = new ArrayList<>();
            //与数据库的连接
            Connection conn = getConnection();
            PreparedStatement pStemt = null;
            String tableSql = SQL + tableName;
            try {
        
                pStemt = conn.prepareStatement(tableSql);
                //结果集元数据
                ResultSetMetaData rsmd = pStemt.getMetaData();
                //表列数
                int size = rsmd.getColumnCount();
                for (int i = 0; i <size ;i++){
        
                    columnNames.add(rsmd.getColumnName(i + 1));
                }
            } catch (SQLException e) {
        
                logger.error("getColumnNames failure", e);
            } finally {
        
                if (pStemt != null) {
        
                    try {
        
                        pStemt.close();
                        closeConnection(conn);
                    } catch (SQLException e) {
        
                        logger.error("getColumnNames close pstem and connection failure", e);
                    }
                }
            }
            return columnNames;
        }
    
        public static void main(String[] args) {
        
           List<String> tableNames = getTableNames();
            for (String single : tableNames) {
        
                System.out.println(single);
            }
            System.out.println(getColumnNames("sys_dict"));
        }
    
    }

**本篇简要介绍了java中模板设计模式的简单使用以及在实际工作中的应用场景，关于模板模式还有更深入的大家可以继续研究，比如模板中的钩子函数都是很实用的知识点，本篇到此结束，最后感谢观看！**

[20191206123438421.png]: https://img-blog.csdnimg.cn/20191206123438421.png
[20191206124356250.png]: https://img-blog.csdnimg.cn/20191206124356250.png