《Java设计模式》之模板方法模式

时间：2023-03-09 06:46:14
《Java设计模式》之模板方法模式

模板方法模式是类的行为模式。准备一个抽象类。将部分逻辑以详细方法以及详细构造函数的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类能够以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。这就是模板方法模式的用意。

模板方法模式的结构

　　模板方法模式是全部模式中最为常见的几个模式之中的一个。是基于继承的代码复用的基本技术。

　　模板方法模式须要开发抽象类和详细子类的设计师之间的协作。一个设计师负责给出一个算法的轮廓和骨架，还有一些设计师则负责给出这个算法的各个逻辑步骤。代表这些详细逻辑步骤的方法称做基本方法(primitive method)。而将这些基本方法汇总起来的方法叫做模板方法(template method)，这个设计模式的名字就是从此而来。

　　模板方法所代表的行为称为*行为，其逻辑称为*逻辑。模板方法模式的静态结构图例如以下所看到的：

《Java设计模式》之模板方法模式

　　这里涉及到两个角色：

　　抽象模板(Abstract Template)角色有例如以下责任：

　　■　　定义了一个或多个抽象操作。以便让子类实现。

这些抽象操作叫做基本操作，它们是一个*逻辑的组成步骤。

　　■　　定义并实现了一个模板方法。这个模板方法通常是一个详细方法，它给出了一个*逻辑的骨架。而逻辑的组成步骤在对应的抽象操作中。推迟到子类实现。*逻辑也有可能调用一些详细方法。

　　详细模板(Concrete Template)角色又例如以下责任：

　　■　　实现父类所定义的一个或多个抽象方法。它们是一个*逻辑的组成步骤。

　　■　　每个抽象模板角色都能够有随意多个详细模板角色与之相应，而每个详细模板角色都能够给出这些抽象方法（也就是*逻辑的组成步骤）的不同实现，从而使得*逻辑的实现各不同样。

　　源码

　　抽象模板角色类，abstractMethod()、hookMethod()等基本方法是*逻辑的组成步骤，这个*逻辑由templateMethod()方法代表。

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间：2012-6-28 上午10:30:37
  5. *
  6. * @类说明 ：抽象模板角色类，abstractMethod()、hookMethod()等基本方法是*逻辑的组成步骤，
  7. *            这个*逻辑由templateMethod()方法代表。
  8. */
  9. public abstract class AbstractTemplate {
  10. /**
  11. * 模板方法
  12. */
  13. public void templateMethod() {
  14. // 调用基本方法
  15. abstractMethod();
  16. hookMethod();
  17. concreteMethod();
  18. }
  19. /**
  20. * 基本方法的声明（由子类实现）必须由子类置换
  21. */
  22. protected abstract void abstractMethod();
  23. /**
  24. * 基本方法(空方法)能够由子类置换
  25. */
  26. protected void hookMethod() {
  27. }
  28. /**
  29. * 基本方法（已经实现）子类不能够动
  30. */
  31. private final void concreteMethod() {
  32. // 业务相关的代码
  33. }
  34. }

　　详细模板角色类，实现了父类所声明的基本方法。abstractMethod()方法所代表的就是强制子类实现的剩余逻辑，而hookMethod()方法是可选择实现的逻辑，不是必须实现的。

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间：2012-6-28 上午10:37:45
  5. *
  6. * @类说明 ：详细模板角色类，实现了父类所声明的基本方法，//
  7. *      abstractMethod()方法所代表的就是强制子类实现的剩余逻辑。//
  8. *      而hookMethod()方法是可选择实现的逻辑，不是必须实现的。
  9. */
  10. public class ConcreteTemplate extends AbstractTemplate {
  11. // 基本方法的实现
  12. @Override
  13. public void abstractMethod() {
  14. // 业务相关的代码
  15. }
  16. // 重写父类的方法
  17. @Override
  18. public void hookMethod() {
  19. // 业务相关的代码
  20. }
  21. }

　　模板模式的关键是：子类能够置换掉父类的可变部分，可是子类却不能够改变模板方法所代表的*逻辑。

　　每当定义一个新的子类时，不要依照控制流程的思路去想，而应当依照“责任”的思路去想。

换言之，应当考虑哪些操作是必须置换掉的。哪些操作是能够置换掉的，以及哪些操作是不能够置换掉的。

使用模板模式能够使这些责任变得清晰。

模板方法模式中的方法

　　模板方法中的方法能够分为两大类：模板方法和基本方法。

　　模板方法

　　一个模板方法是定义在抽象类中的，把基本操作方法组合在一起形成一个总算法或一个总行为的方法。

　　一个抽象类能够有随意多个模板方法，而不限于一个。每个模板方法都能够调用随意多个详细方法。

　　基本方法

　　基本方法又能够分为三种：抽象方法(Abstract Method)、详细方法(Concrete Method)和钩子方法(Hook Method)。

　　●　　抽象方法：一个抽象方法由抽象类声明，由详细子类实现。在Java语言里抽象方法以abstractkeyword标示。

　　●　　详细方法：一个详细方法由抽象类声明并实现，而子类并不实现或置换。

　　●　　钩子方法：一个钩子方法由抽象类声明并实现。而子类会加以扩展。通常抽象类给出的实现是一个空实现。作为方法的默认实现。

　　在上面的样例中，AbstractTemplate是一个抽象类。它带有三个方法。当中abstractMethod()是一个抽象方法，它由抽象类声明为抽象方法，并由子类实现。hookMethod()是一个钩子方法，它由抽象类声明并提供默认实现。而且由子类置换掉。concreteMethod()是一个详细方法。它由抽象类声明并实现。

　　默认钩子方法

　　一个钩子方法经常由抽象类给出一个空实现作为此方法的默认实现。这样的空的钩子方法叫做“Do Nothing Hook”。显然。这样的默认钩子方法在缺省适配模式里面已经见过了。一个缺省适配模式讲的是一个类为一个接口提供一个默认的空实现。从而使得缺省适配类的子类不必像实现接口那样必须给出全部方法的实现，由于通常一个详细类并不须要全部的方法。

　　命名规则

　　命名规则是设计师之间赖以沟通的管道之中的一个，使用恰当的命名规则能够帮助不同设计师之间的沟通。

　　钩子方法的名字应当以do開始，这是熟悉设计模式的Java开发者的标准做法。

在上面的样例中。钩子方法hookMethod()应当以do开头；在HttpServlet类中，也遵从这一命名规则，如doGet()、doPost()等方法。

使用场景

　　考虑一个计算存款利息的样例。如果系统须要支持两种存款账号。即货币市场(Money Market)账号和定期存款(Certificate of Deposite)账号。这两种账号的存款利息是不同的。因此。在计算一个存户的存款利息额时，必须区分两种不同的账号类型。

　　这个系统的总行为应当是计算出利息。这也就决定了作为一个模板方法模式的*逻辑应当是利息计算。

由于利息计算涉及到两个步骤：一个基本方法给出账号种类。还有一个基本方法给出利息百分比。这两个基本方法构成详细逻辑，由于账号的类型不同，所以详细逻辑会有所不同。

　　显然，系统须要一个抽象角色给出*行为的实现，而将两个作为细节步骤的基本方法留给详细子类实现。因为须要考虑的账号有两种：一是货币市场账号，二是定期存款账号。系统的类结构例如以下图所看到的。

《Java设计模式》之模板方法模式

　　源码

　　抽象模板角色类

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间：2012-6-28 上午11:13:22
  5. *
  6. * @类说明 ：抽象模板角色类
  7. */
  8. public abstract class Account {
  9. /**
  10. * 模板方法。计算利息数额
  11. *
  12. * @return 返回利息数额
  13. */
  14. public final String calculateInterest() {
  15. double interestRate = doCalculateInterestRate();
  16. String accountType = doCalculateAccountType();
  17. System.out.println(accountType);
  18. double amount = calculateAmount(accountType);
  19. return amount + "*" + interestRate+ "=" + (amount * interestRate);
  20. }
  21. /**
  22. * 基本方法留给子类实现
  23. */
  24. protected abstract String doCalculateAccountType();
  25. /**
  26. * 基本方法留给子类实现
  27. */
  28. protected abstract double doCalculateInterestRate();
  29. /**
  30. * 基本方法，已经实现
  31. */
  32. private double calculateAmount(String accountType) {
  33. /**
  34. * 省略相关的业务逻辑
  35. */
  36. return 7243.00;
  37. }
  38. }

　　详细模板角色类

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间：2012-6-28 上午11:14:13
  5. *
  6. * @类说明 ：详细模板角色类- 定期账号
  7. */
  8. public class CDAccount extends Account {
  9. @Override
  10. protected String doCalculateAccountType() {
  11. return "CDA";
  12. }
  13. @Override
  14. protected double doCalculateInterestRate() {
  15. return 0.06;
  16. }
  17. }
  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间：2012-6-28 上午11:13:49
  5. *
  6. * @类说明 ：详细模板角色类- 货币市场账号
  7. */
  8. public class MoneyMarketAccount extends Account {
  9. @Override
  10. protected String doCalculateAccountType() {
  11. return "MMA";
  12. }
  13. @Override
  14. protected double doCalculateInterestRate() {
  15. return 0.045;
  16. }
  17. }

client类

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间：2012-6-28 上午11:14:30
  5. *
  6. * @类说明 ：client类
  7. */
  8. public class Client {
  9. public static void main(String[] args) {
  10. Account account = new MoneyMarketAccount();
  11. System.out.println("货币市场账号的利息数额为：" + account.calculateInterest());
  12. account = new CDAccount();
  13. System.out.println("定期账号的利息数额为：" + account.calculateInterest());
  14. }
  15. }

执行一下：

  1. MMA
  2. 货币市场账号的利息数额为：7243.0*0.045=325.935
  3. CDA
  4. 定期账号的利息数额为：7243.0*0.06=434.58

模板方法模式在Servlet中的应用

　　使用过Servlet的人都清楚，除了要在web.xml做对应的配置外，还需继承一个叫HttpServlet的抽象类。

HttpService类提供了一个service()方法，这种方法调用七个do方法中的一个或几个。完毕对client调用的响应。这些do方法须要由HttpServlet的详细子类提供。因此这是典型的模板方法模式。以下是service()方法的源码：

  1. protected void service(HttpServletRequest req, HttpServletResponse resp)
  2. throws ServletException, IOException {
  3. String method = req.getMethod();
  4. if (method.equals(METHOD_GET)) {
  5. long lastModified = getLastModified(req);
  6. if (lastModified == -1) {
  7. // servlet doesn't support if-modified-since, no reason
  8. // to go through further expensive logic
  9. doGet(req, resp);
  10. } else {
  11. long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
  12. if (ifModifiedSince < (lastModified / 1000 * 1000)) {
  13. // If the servlet mod time is later, call doGet()
  14. // Round down to the nearest second for a proper compare
  15. // A ifModifiedSince of -1 will always be less
  16. maybeSetLastModified(resp, lastModified);
  17. doGet(req, resp);
  18. } else {
  19. resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
  20. }
  21. }
  22. } else if (method.equals(METHOD_HEAD)) {
  23. long lastModified = getLastModified(req);
  24. maybeSetLastModified(resp, lastModified);
  25. doHead(req, resp);
  26. } else if (method.equals(METHOD_POST)) {
  27. doPost(req, resp);
  28. } else if (method.equals(METHOD_PUT)) {
  29. doPut(req, resp);
  30. } else if (method.equals(METHOD_DELETE)) {
  31. doDelete(req, resp);
  32. } else if (method.equals(METHOD_OPTIONS)) {
  33. doOptions(req,resp);
  34. } else if (method.equals(METHOD_TRACE)) {
  35. doTrace(req,resp);
  36. } else {
  37. //
  38. // Note that this means NO servlet supports whatever
  39. // method was requested, anywhere on this server.
  40. //
  41. String errMsg = lStrings.getString("http.method_not_implemented");
  42. Object[] errArgs = new Object[1];
  43. errArgs[0] = method;
  44. errMsg = MessageFormat.format(errMsg, errArgs);
  45. resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
  46. }
  47. }

　　当然，这个service()方法也能够被子类置换掉。

　　以下给出一个简单的Servlet样例：

《Java设计模式》之模板方法模式

　　从上面的类图能够看出，TestServlet类是HttpServlet类的子类，而且置换掉了父类的两个方法：doGet()和doPost()。

  1. public class TestServlet extends HttpServlet {
  2. public void doGet(HttpServletRequest request, HttpServletResponse response)
  3. throws ServletException, IOException {
  4. System.out.println("using the GET method");
  5. }
  6. public void doPost(HttpServletRequest request, HttpServletResponse response)
  7. throws ServletException, IOException {
  8. System.out.println("using the POST method");
  9. }
  10. }

　　从上面的样例能够看出这是一个典型的模板方法模式。

　　HttpServlet担任抽象模板角色

　　　　模板方法：由service()方法担任。

　　　　基本方法：由doPost()、doGet()等方法担任。

　　TestServlet担任详细模板角色

　　　　TestServlet置换掉了父类HttpServlet中七个基本方法中的当中两个，各自是doGet()和doPost()。

本文借鉴：http://blog.csdn.net/m13666368773/article/details/7677374

书籍：中文版的  java设计模式第二版

相关文章