java设计模式之Template Pattern---复习篇

最新推荐文章于 2024-04-20 03:14:18 发布

原创最新推荐文章于 2024-04-20 03:14:18 发布 · 187 阅读

0 ·

CC 4.0 BY-SA版权

编程基础专栏收录该内容

28 篇文章

订阅专栏

目录：

1.模版模式介绍

2.模版模式原理

3.模版模式使用

一.模版模式介绍

定义：定义一个操作中算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。通俗点的理解就是：完成一件事情，有固定的数个步骤，但是每个步骤根据对象的不同，而实现细节不同；就可以在父类中定义一个完成该事情的总方法，按照完成事件需要的步骤去调用其每个步骤的实现方法。每个步骤的具体实现，由子类完成。

模板模式就是通过抽象类来定义一个逻辑模板，逻辑框架、逻辑原型，然后将无法决定的部分抽象成抽象类交由子类来实现，一般这些抽象类的调用逻辑还是在抽象类中完成的。模板就是定义一个框架，例如盖房子，我们定义一个模板：房子要封闭，有门，有窗等等，但是要什么样的门，什么样的窗，这些并不在模板中描述，这个交给子类来完善，比如门使用防盗门，窗使用北向的窗等等。

二.模版模式原理

抽象父类（AbstractClass）：实现了模板方法，定义了算法的骨架。

具体类（ConcreteClass)：实现抽象类中的抽象方法，即不同的对象的具体实现细节。

三.模版模式使用

3.1 实例说明：

做菜可以分为三个步骤（1）备料（2）具体做菜（3）如何盛装菜，这三部就是算法的骨架；然而做不同菜需要的料，做的方法，以及如何盛装菜拿到饭桌的不同的这个就是不同的实现细节。

CookTemplate ：抽象父类；

PotatoesAndEggplant、ColaChickenWings：具体实现的子类；

public abstract class CookTemplate {

	// 做菜整体过程
	protected void cook()  {
		this.preparation();
		this.cooking();
		this.fillDish();
	}
	
	// 备料
	public abstract void preparation();
	// 做菜
	public abstract void cooking();
	// 盛菜
	public abstract void fillDish();
	
}

public class PotatoesAndEggplant extends CookTemplate {

	@Override
    public void preparation() {
        System.out.println("削皮洗并切土豆和茄子。");
        
    }

	@Override
	public void cooking() {
		System.out.println("将土豆和茄子倒入锅中，炖一段时间....");
		
	}

	@Override
	public void fillDish() {
		System.out.println("将炖好的茄子土豆放入小盆中，端到饭桌。");
		
	}

}

public class ColaChickenWings extends CookTemplate{

	@Override
	public void preparation() {
		System.out.println("准备适量可乐和洗净的鸡翅");
		
	}

	@Override
	public void cooking() {
		System.out.println("将可乐和鸡翅加入锅中，炖一段时间...");
		
	}

	@Override
	public void fillDish() {
		System.out.println("将可乐鸡翅放入小盆中，端到饭桌。");
		
	}

	public static void main(String[] args) {
		
		PotatoesAndEggplant potatoesAndEggplant = new PotatoesAndEggplant();
		ColaChickenWings colaChickenWings = new ColaChickenWings();
		
		potatoesAndEggplant.cook();
		System.out.println("-----------------------------");
		colaChickenWings.cook();
		
	}
}

3.2 实例说明2

模板设计模式常在数据库操作中使用，我现在使用模板模式做一个JDBC的查询模板：

public abstract class TemplateDao {
    /**
     * 查询
     * @param sql
     * @param params
     * @return
     */
    protected Object find(String sql, Object[] params) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        Object obj = null;
        try {
            conn = JDBCUtils.getConnection();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
            rs = ps.executeQuery();
            while (rs.next()) {
                obj = rowMapper(rs);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.free(rs, ps, conn);
        }
        return obj;
    }
    
    protected abstract Object rowMapper(ResultSet rs) throws SQLException;
    
    //同时可以添加 insert ，update 等方法
}

public class RoleDao extends TemplateDao {

    public Role findRole(int roleId) {
        String sql = "select * from t_role where roleId = ?";
        Object[] params = new Object[] { roleId };
        Object role = super.find(sql, params);
        System.out.println((Role) role);
        return (Role) role;
    }

    @Override
    protected Object rowMapper(ResultSet rs) throws SQLException {
        Role role = new Role();
        role.setId(rs.getInt("roleId"));
        role.setName(rs.getString("name"));
        .......
        return role;
    }
}

如上就使用模板模式做的查询，父类中做了算法骨架，子类中具体实现算法中的不同部分。

优点
　（1）具体细节步骤实现定义在子类中，子类定义详细处理算法是不会改变算法整体结构。

　（2）代码复用的基本技术，在数据库设计中尤为重要。

　（3）存在一种反向的控制结构，通过一个父类调用其子类的操作，通过子类对父类进行扩展增加新的行为，符合“开闭原则”。

缺点

每个不同的实现都需要定义一个子类，会导致类的个数增加，系统更加庞大。