模板模式（Template Pattern） – 设计模式之行为模式：
目录
定义：
定义： Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Mothod lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.
当我们要完成在某一细节层次一致的一个过程或一系列步骤，但其个别步骤在更详细的层次上的实现可能不同时，我们通常考虑用模板方法模式来处理
模板方法模式是通过不变行为搬移到超类，去除子类中的重复代码来体现它的优势。
在软件开发过程中，如果相同的一段代码复制过两次，就需要对设计产生怀疑，要明确地说明为什么相同的逻辑要出现两次或更多次
A,类图
通用模板模式类图：
通常包括三种方法：抽象方法(Abstract Method)、具体方法(Concrete Method)和钩子方法(Hook Method)。
● 抽象方法：一个抽象方法由抽象类声明，由具体子类实现。在Java语言里抽象方法以abstract关键字标示。
● 具体方法：一个具体方法由抽象类声明并实现，而子类并不实现或置换。
● 钩子方法：一个钩子方法由抽象类声明并实现，而子类会加以扩展。通常抽象类给出的实现是一个空实现，作为方法的默认实现。
在创建一个模板方法试，什么时候用抽象方法？ 什么时候用钩子呢？
当子类必须提供算法中某个方法或者步骤的实现是，就使用抽象方法。
如果这个算法是可选的，就使用钩子。如果是钩子的话，子类可以选择实现这个钩子。
注意事项： 为了防止恶意的操作，一般模板方法都加上final关键字，不允许被覆写。
命名规则
钩子方法（hookMethod）的名字应当以do开始，这是熟悉设计模式的Java开发人员的标准做法。在HttpServlet类中，也遵从这一命名规则，如doGet()、doPost()等方法。
例子1：
过程：
需求： 去购物。
流程： 看商品，选中商品，付钱，是否使用优惠券，打印凭条
分析： 固定的操作是：看商品、付钱和打印凭条。 （具体方法）
个性化的操作： 选中什么商品 （抽象方法）
可选的操作： 是否使用优惠券 （钩子方法）
类图：
这边添加了一个收营员的角色。
购物模板类：ShoppingTemplate
public abstract class ShoppingTemplate {
private void look() {// 看物品
System.out.println("看物品");
}
protected abstract void select();
protected boolean doUseTicket() {
return false;
}
private void payMoney() {
System.out.println("付钱");
}
private void printTiket() {
System.out.println("打印凭条");
}
final void kickOff() {
look();
select();
if (doUseTicket()) {
System.out.println("使用优惠券");
}
payMoney();
printTiket();
}
}
顾客1： CustomerOne
public class CustomerOne extends ShoppingTemplate {
@Override
protected void select() {
System.out.println("选择了 LV");
}
}
顾客2： CustomerTwo
public class CustomerTwo extends ShoppingTemplate {
@Override
protected void select() {
System.out.println("选择了 Nike 鞋子");
}
public boolean doUseTicket() {
return true;
}
}
收营员： Receivers
public class Receivers {
private ShoppingTemplate shoppingTemplate;
public Receivers(ShoppingTemplate shoppingTemplate) {
this.shoppingTemplate = shoppingTemplate;
}
public void dealWork(){
shoppingTemplate.kickOff();
}
// 替换下一个用户
public void changeCutomer(ShoppingTemplate customer){
this.shoppingTemplate = customer;
}
}
测试类；
public class ShoppingTemplateTest {
public static void main(String[] args) {
System.out.println(" ============= 自助结营 ==========");
ShoppingTemplate one = new CustomerOne();
one.kickOff();
System.out.println(" ============= ");
ShoppingTemplate two = new CustomerTwo();
two.kickOff();
System.out.println(" ============= 收营员处理 ==========");
Receivers receiverOne = new Receivers(one);
receiverOne.dealWork();
System.out.println(" ============= ");
receiverOne.changeCutomer(two);
receiverOne.dealWork();
}
}
结果：
============= 自助结营 ==========
看物品
选择了 LV
付钱
打印凭条
=============
看物品
选择了 Nike 鞋子
使用优惠券
付钱
打印凭条
============= 收营员处理 ==========
看物品
选择了 LV
付钱
打印凭条
=============
看物品
选择了 Nike 鞋子
使用优惠券
付钱
打印凭条
模板方法模式在Servlet中的应用
使用过Servlet的人都清楚，除了要在web.xml做相应的配置外，还需继承一个叫HttpServlet的抽象类。HttpService类提供了一个service()方法，这个方法调用七个do方法中的一个或几个，完成对客户端调用的响应。这些do方法需要由HttpServlet的具体子类提供，因此这是典型的模板方法模式。下面是service()方法的源代码：
关系图：
方法：
部分代码：HttpServlet
public abstract class HttpServlet extends GenericServlet
{
private static final String METHOD_DELETE = "DELETE";
private static final String METHOD_HEAD = "HEAD";
private static final String METHOD_GET = "GET";
private static final String METHOD_POST = "POST";
private static final String METHOD_PUT = "PUT";
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_get_not_supported");
if (protocol.endsWith("1.1")) {
resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
protected void doHead(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
NoBodyResponse response = new NoBodyResponse(resp);
doGet(req, response);
response.setContentLength();
}
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_post_not_supported");
if (protocol.endsWith("1.1")) {
resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
protected void doPut(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_put_not_supported");
if (protocol.endsWith("1.1")) {
resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
protected void doDelete(HttpServletRequest req,
HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_delete_not_supported");
if (protocol.endsWith("1.1")) {
resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
} else {
resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
}
}
}
代码：EchoServlet
public class EchoServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response) {
Thread currentThread = Thread.currentThread();
String currentThreadName = currentThread.getName();
response.setContentType("text/plain");
try (PrintWriter pwr = response.getWriter()) {
pwr.printf("This request was handled by thread: %s%n", currentThreadName);
pwr.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
EchoServlet置换掉了父类HttpServlet中七个基本方法中的其中一个方法doGet()
总结：
模板模式的关键是：子类可以置换掉父类的可变部分，但是子类却不可以改变模板方法所代表的顶级逻辑。去思考哪些是不变的步骤，哪些是可扩展的
优点：
1、封装不变部分，扩展可变部分。
2、提取公共代码，便于维护。
3、行为由父类控制，子类实现。
缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。
使用场景：
1、有多个子类共有的方法，且逻辑相同。
2、重要的、复杂的方法，可以考虑作为模板方法。
注意事项：为防止恶意操作，一般模板方法都加上 final 关键词。
3688
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
