Template模板模式

素颜马尾好姑娘i 2022-04-18 02:20 249阅读 0赞

> **文章最前**： 我是Octopus，这个名字来源于我的中文名--章鱼；我热爱编程、热爱算法、热爱开源。所有源码在我的个人[github][] ；这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。

**相关文章：**

1.  [Command命令设计模式][Command]
2.  **[Singleton单例设计模式][Singleton]**
3.  **[Decorator装饰设计模式][Decorator]**
4.  **[Template模板模式][Template]**
5.  **[Strategy策略设计模式][Strategy]**
6.  **[Proxy代理设计模式][Proxy]**
7.  **[Factory工厂类设计模式][Factory]**
8.  **[设计模式的6大基本原则][6]**

--------------------

**文章目录：**

1.定义一个计算程序运行时间的基本骨架：

2.程序执行的主题类1：

3.程序执行的主题类2：

4.测试模板类：

--------------------

定义：一个操作中的算法的骨架，而将一些步骤延迟到子类中；模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。例如计算程序运行时间的类，建立起来基本的骨架，把不变的给子类去实现。

思想：侧重点不是选择，你没得选择，你必须这么做，你 可以不参与某一部分内容的自定义；

--------------------

### **1.定义一个计算程序运行时间的基本骨架：** ###

package templatepattern;
    
    /**
     * @author zhangyu
     **/
    public abstract class ComputeRunTime {
        public final void getTime(){
            long start=System.currentTimeMillis();
            runCode();
            long end=System.currentTimeMillis();
            System.out.println("程序运行时间："+(end-start));
        }
        public abstract void runCode();
    }

### **2.程序执行的主题类1：** ###

package templatepattern;
    
    /**
     * @author zhangyu
     **/
    public class RunTime extends  ComputeRunTime {
        @Override
        public void runCode() {
            for(int i=0;i<Integer.MAX_VALUE;i++){
            }
        }
    }

### **3.程序执行的主题类2：** ###

package templatepattern;
    
    /**
     * @author zhangyu
     **/
    public class RunTime2 extends ComputeRunTime {
        @Override
        public void runCode() {
            for (int i = 0; i < Integer.MAX_VALUE / 2; i++) { }
        }
    }

### **4.测试模板类：** ###

package templatepattern;
    
    /**
     * @author zhangyu
     * @date 2018/11/7 11:21
     **/
    public class ComputeRunTimeTest {
        public static void main(String[] args) {
            RunTime2 rt2 = new RunTime2();
            rt2.getTime();
        }
    }

这个就是典型的模板类，在spring框架中，这种设计模式，在JdbcTempalte中，体现的淋漓尽致；类似于spring中JdbcTemplate的实现方式：

1.Member.java

public class Member {
    
        private String username;
        private String password;
        private String nickName;
    
        private int age;
        private String addr;
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getNickName() {
            return nickName;
        }
    
        public void setNickName(String nickName) {
            this.nickName = nickName;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getAddr() {
            return addr;
        }
    
        public void setAddr(String addr) {
            this.addr = addr;
        }
    }

2.MemberDao.java

public class MemberDao {
    
        //为什么不继承，主要是为了解耦（降低类与类之间的耦合度）
        private JdbcTemplate JdbcTemplate = new JdbcTemplate(null);
    
        public List<?> query(){
            String sql = "select * from t_member";
            return JdbcTemplate.executeQuery(sql,new RowMapper<Member>(){
                @Override
                public Member mapRow(ResultSet rs, int rowNum) throws Exception {
                    Member member = new Member();
                    member.setUsername(rs.getString("username"));
                    member.setPassword(rs.getString("password"));
                    member.setAge(rs.getInt("age"));
                    member.setAddr(rs.getString("addr"));
                    return member;
                }
            },null);
        }
    }

3.JdbcTemplate.java

public class JdbcTemplate {
    
        private DataSource dataSource;
    
        public JdbcTemplate(DataSource dataSource) {
            this.dataSource = dataSource;
        }
    
        private Connection getConnection() throws Exception {
            return this.dataSource.getConnection();
        }
    
        private PreparedStatement createPreparedStatement(Connection conn, String sql) throws Exception {
            return conn.prepareStatement(sql);
        }
    
    
        private ResultSet executeQuery(PreparedStatement pstmt, Object[] values) throws Exception {
            for (int i = 0; i < values.length; i++) {
                pstmt.setObject(i, values[i]);
            }
            return pstmt.executeQuery();
        }
    
        private void closeStatement(Statement stmt) throws Exception {
            stmt.close();
        }
    
        private void closeResultSet(ResultSet rs) throws Exception {
            rs.close();
        }
    
        private void closeConnection(Connection conn) throws Exception {
            //通常把它放到连接池回收
        }
    
    
        private List<?> parseResultSet(ResultSet rs, RowMapper rowMapper) throws Exception {
            List<Object> result = new ArrayList<Object>();
            int rowNum = 1;
            while (rs.next()) {
                result.add(rowMapper.mapRow(rs, rowNum++));
            }
            return result;
        }
    
    
        public List<?> executeQuery(String sql, RowMapper<?> rowMapper, Object[] values) {
            try {
    
                //1、获取连接
                Connection conn = this.getConnection();
                //2、创建语句集
                PreparedStatement pstmt = this.createPreparedStatement(conn, sql);
                //3、执行语句集，并且获得结果集
                ResultSet rs = this.executeQuery(pstmt, values);
                //4、解析语句集
                List<?> result = this.parseResultSet(rs, rowMapper);
    
                //5、关闭结果集
                this.closeResultSet(rs);
                //6、关闭语句集
                this.closeStatement(pstmt);
                //7、关闭连接
                this.closeConnection(conn);
    
                return result;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    }

4.RowMapper.java

public interface RowMapper<T> {
        public T mapRow(ResultSet rs, int rowNum) throws Exception;
    }

5.MemberDaoTest.java

public class MemberDaoTest {
    
        public static void main(String[] args) {
    
            MemberDao memberDao = new MemberDao(null);
            memberDao.query();
    
        }
    }

这就是模拟了Jdbctemplate对连接数据库进行封装，我们只需要写要查询的sql就好了，然后去读取里面的数据就行。至于模板里面是什么东西，那就不是我们考虑的问题。

[github]: https://github.com/zhangyu345293721
[Command]: https://blog.csdn.net/zy345293721/article/details/82429423
[Singleton]: https://blog.csdn.net/zy345293721/article/details/82153881
[Decorator]: https://blog.csdn.net/zy345293721/article/details/81838635
[Template]: https://blog.csdn.net/zy345293721/article/details/83819394
[Strategy]: https://blog.csdn.net/zy345293721/article/details/81290896
[Proxy]: https://blog.csdn.net/zy345293721/article/details/81183998
[Factory]: https://blog.csdn.net/zy345293721/article/details/83716363
[6]: https://blog.csdn.net/zy345293721/article/details/83500802