模板方法精讲

模板方法是一种行为型模式,执行流程固定，但中间有些步骤有细微差别的。官方的定义是:定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。下面使用穷举法举几个例子:

1.西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。

2.spring 中对 hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 session、关闭 session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。

下面使用一个例子代码演示一下,主要看一下代码的封装的特点:

package pattern.template.entity;
import java.io.serializable;
public class member implements serializable {
    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;
    }
}

package pattern.template.dao;
import pattern.template.jdbctemplate;
import pattern.template.rowmapper;
import pattern.template.entity.member;
import java.sql.resultset;
import java.util.list;

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("username"));
               member.setaddr(rs.getstring("addr"));
               return member;
           }
       },null);
   }
}

package pattern.template;
import javax.sql.datasource;
import java.sql.connection;
import java.sql.preparedstatement;
import java.sql.resultset;
import java.util.arraylist;
import java.util.list;
public class jdbctemplate {
    private datasource datasource;
    public jdbctemplate(datasource datasource){
       this.datasource=datasource;
    }

    private connection getconnection() throws exception{
        return this.datasource.getconnection();
    }

    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 preparedstatement createpreparedstatement(connection conn,string sql) throws exception{
        return conn.preparestatement(sql);
    }

    private void closestatement(preparedstatement pstmt) throws exception{
      pstmt.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<>();
            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;
    }

    //public object processresult(resultset rs,int rownum) throws sqlexception;

}

package pattern.template;
import java.sql.resultset;
public interface rowmapper<t> {

    public t maprow(resultset rs,int rownum) throws exception;

}

package pattern.template;
import pattern.template.dao.memberdao;
public class memberdaotest {
    public static void main(string[] args) {
        memberdao memberdao = new memberdao();
        memberdao.query();
    }
}

主要是通过代码深刻的理解代码的封装的优美。