本文属于系列文章《设计模式》，附上文集链接
模板方法模式
- 定义： 定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
- 作用： 通过使用模板方法模式，可以将一些复杂流程的实现步骤封装在一系列基本方法中，在抽象父类中提供一个称之为模板方法的方法来定义这些基本方法的执行次序，而通过其子类来覆盖某些步骤，从而使得相同的算法框架可以有不同的执行结果。
- 是一个行为类模式
上例子：
// 抽象模板
public abstract class AbstractCarCreater {
protected void assemblyCar(){
System.out.println("先把车的总体框架搭好");
}
protected abstract void coloring();
protected abstract void assemblyLogo( );
public void createrCar( ){
assemblyCar();
this.coloring();
this.assemblyLogo();
}
}
// 奔驰模板
public class BenzCarCreater extends AbstractCarCreater{
@Override
protected void coloring( ) {
System.out.println("奢华的奔驰得上亮黑色");
}
@Override
protected void assemblyLogo() {
System.out.println("上了一个极致奢华的奔驰Logo");
}
}
// 宝马模板
public class BmwCarCreater extends AbstractCarCreater{
@Override
protected void coloring() {
System.out.println("宝马要上酷炫的银白色");
}
@Override
protected void assemblyLogo() {
System.out.println("上了一个显眼的BMW的Logo");
}
}
// 场景类
public class Client {
public static void main(String[] args) {
BenzCarCreater benzCarCreater = new BenzCarCreater();
benzCarCreater.createrCar();
System.out.println("-------------------------------------");
BmwCarCreater bmwCarCreater = new BmwCarCreater();
bmwCarCreater.createrCar();
}
}
上面的代码，在抽象模板中，我们已经定好了一个算法的框架，组装一辆完整的车的算法，然后算法中的方法是抽象的，交由子类来实现，每多一个字类，就有多一个不同的执行结果，这就是模版方法。
扩展
这个扩展，其实并不是什么知识点或者思想层面的扩展，而是，写了这几篇设计模式，唯一在项目中用到的模式啊！！！！兴奋到爆炸。
做过Java s2sh开发的人其实应该也用到，可能不知道是这种模式而已，下面来简单地上点代码：
// 定义对数据库的增删改查操作
public interface BaseDao<T> {
public Serializable add(T t);
public void update(T t);
public void delete(T t);
public int delete(Serializable id);
public T findDataById(Serializable id);
public List<T> findAllData();
public List<T> findDataByPage(int pageNum, int pageCount);
public List<T> findDataByCondition(String conditionName, String conditionValue,String conditionOperation);
}
// 将数据库的增删改查操作实现
public abstract class HibernateDao<T> implements BaseDao<T>{
@Autowired
private SessionFactory sessionFactory;
public SessionFactory getSessionFactory() {
return sessionFactory;
}
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
@Override
public Serializable add(T t) {
return sessionFactory.getCurrentSession().save(t);
}
@Override
public void update(T t) {
sessionFactory.getCurrentSession().update(t);
}
@Override
public int delete(Serializable id) {
String hql = "delete from "+this.getEntityClass().getSimpleName()+" en where en.id = ?";
return sessionFactory.getCurrentSession().createQuery(hql).setParameter(0, id).executeUpdate();
}
@Override
public void delete(T t) {
sessionFactory.getCurrentSession().delete(t);
}
@Override
public T findDataById(Serializable id) {
return (T) sessionFactory.getCurrentSession().get(getEntityClass(), id);
}
@Override
public List<T> findDataByCondition(String conditionName, String conditionValue, String conditionOperation) {
String hql = "select en from "+getEntityClass().getSimpleName()+" en where en."+conditionName+" "+conditionOperation+"?";
return sessionFactory.getCurrentSession().createQuery(hql).setParameter(0, conditionValue).list();
}
@Override
public List<T> findDataByPage(int pageNum, int pageCount) {
String hql = "from "+getEntityClass().getSimpleName();
return sessionFactory.getCurrentSession().createQuery(hql).setFirstResult((pageNum-1)*pageCount).setMaxResults(pageCount).list();
}
@Override
public List<T> findAllData() {
String hql = "from "+getEntityClass().getSimpleName();
return sessionFactory.getCurrentSession().createQuery(hql).list();
}
// 终极方法
protected abstract Class<T> getEntityClass();
}
// 真正的dao
@Repository
public class BookDao extends HibernateDao<Book>{
@Override
protected Class<Book> getEntityClass() {
return Book.class;
}
}
上面的代码就用到了模版方法模式，BaseDao中，使用了泛型约束Bean的类型，确保实现该接口的Dao都是操作某一个Bean的，然后，它的每个增删改查的方法其实都是相同操作的“算法”，是的，就是算法，唯一的不同点在哪？就是Bean的名字。所以用了一个HibernateDao来继承BaseDao，然后定义了一个终极方法<code>protected abstract Class<T> getEntityClass();</code>,通过这个方法来获取传入的类的class属性，从而获得Bean的名字，从而得到不同的算法结果，这个就是一个活生生的模版方法模式，棒棒哒。
以上就是模版方法模式。
