模板模式

模板模式

案例引入

制作豆浆问题

要求：
1.制作豆浆流程 选材->添加配料->浸泡->放到豆浆机打碎。
2.通过添加不同配料，可以制作出不同口味的豆浆。
3.选材，浸泡和放到豆浆机打碎这些步骤对于制作每种口味的豆浆都是一样的。
4.请使用模板模式，完成。(因为模板方法模式，简单，就直接写了)
基本介绍

• 1.模板模式(Template Pattern)，又叫模板方法模式(Template Method Pattern)，在一个抽象类中，定义执行方法的模板，其子类可以按需重写方法实现，但使用将以抽象类中定义的方式执行。
  
• 2.模板模式，就是在抽象类中，定义了一个操作中算法的骨架，将具体的一些步骤，延迟到了子类中实现，使得子类可以不改变一个算法的结构，就可以重新定义算法的某些特定步骤。
  
• 3.这种类型的设计模式属于行为模式。
  

原理类图


对类图的说明
1.AbstractClass抽象类，类中实现了模板方法，定义了算法的骨架，其他的抽象方法由具体子类去实现，如operation2,3,4方法
2.ConcreteClass 实现抽象方法operation2,3,4，以完成算法中子类特定的步骤。
模板模式实现制作豆浆案例

案例uml类图


代码实现

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 豆浆父类，模板类
5. */
6. public abstract class SoyaMilk {
7.     public final void make(){
8.         select();
9.         add();
10.         soak();
11.         beat();
12.     }
14.     /**
15.      * 选材
16.      */
17.     public void select(){
18.         System.out.println("第一步，选择黄豆作为材料");
19.     }
21.     /**
22.      * 添加配料
23.      */
24.     public abstract void add();
26.     /**
27.      * 浸泡
28.      */
29.     public void soak(){
30.         System.out.println("第三步，黄豆和配料开始浸泡，需要3小时");
31.     }
33.     /**
34.      * 打碎
35.      */
36.     public void beat(){
37.         System.out.println("第四步，黄豆和配料放到豆浆机去打碎");
38.     }
39. }
40. /**
41. * @author 长名06
42. * @version 1.0
43. */
44. public class RedBeanSoyaMilk extends SoyaMilk{
45.     @Override
46.     public void add() {
47.         System.out.println("第二步，加入上好的红豆");
48.     }
49. }
50. /**
51. * @author 长名06
52. * @version 1.0
53. */
54. public class PeanutSoyaMilk extends SoyaMilk {
55.     @Override
56.     public void add() {
57.         System.out.println("第二步，加入上好的花生");
58.     }
59. }
60. /**
61. * @author 长名06
62. * @version 1.0
63. */
64. public class Client {
65.     public static void main(String[] args) {
66.         //制作红豆豆浆
67.         SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
68.         redBeanSoyaMilk.make();
70.         System.out.println("----------");
72.         //制作花生豆浆
73.         SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
74.         peanutSoyaMilk.make();
75.     }
76. }

复制代码

模板模式的钩子方法

• 1.在模板模式的抽象类中，可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为"钩子"。
  
• 2.用上面案例做演示，希望制作纯豆浆，不叫任何配料。使用钩子方法，对前面实现做改进。
  

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 豆浆父类，模板类
5. */
6. public abstract class SoyaMilk {
7.     public final void make(){
8.         select();
9.         if(isAdd()){
10.             add();
11.         }
12.         soak();
13.         beat();
14.     }
16.     /**
17.      * 选材
18.      */
19.     public void select(){
20.         System.out.println("第一步，选择黄豆作为材料");
21.     }
23.     /**
24.      * 添加配料
25.      */
26.     public abstract void add();
28.     /**
29.      * 浸泡
30.      */
31.     public void soak(){
32.         System.out.println("第三步，黄豆和配料开始浸泡，需要3小时");
33.     }
35.     /**
36.      * 打碎
37.      */
38.     public void beat(){
39.         System.out.println("第四步，黄豆和配料放到豆浆机去打碎");
40.     }
42.     /**
43.      * 是否需要添加原料，这样设计，可以设置为，子类空实现add步骤，但是不进行添加
44.      * 勾子方法，由这个方法的返回值，判断是否执行那个需要被子类重写的方法，钩子方法
45.      * 是可以被子类继承，由具体子类决定是否执行
46.      * @return
47.      */
48.     public boolean isAdd(){
49.         return true;
50.     }
51. }
52. /**
53. * @author 长名06
54. * @version 1.0
55. */
56. public class RedBeanSoyaMilk extends SoyaMilk {
57.     @Override
58.     public void add() {
59.         System.out.println("第二步，加入上好的红豆");
60.     }
61. }
62. /**
63. * @author 长名06
64. * @version 1.0
65. * 纯豆浆
66. */
67. public class PureBeanSoyaMilk extends SoyaMilk{
68.     @Override
69.     public void add() {
70.         System.out.println("第二步，制作纯豆浆，不加任何配料");
71.     }
73.     @Override
74.     public boolean isAdd() {
75.         return !super.isAdd();//不执行第二步
76.     }
77. }
78. /**
79. * @author 长名06
80. * @version 1.0
81. * 花生豆浆
82. */
83. public class PeanutSoyaMilk extends SoyaMilk {
84.     @Override
85.     public void add() {
86.         System.out.println("第二步，加入上好的花生");
87.     }
88. }
89. /**
90. * @author 长名06
91. * @version 1.0
92. */
93. public class Client {
94.     public static void main(String[] args) {
95.         //制作红豆豆浆
96.         SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
97.         redBeanSoyaMilk.make();
99.         System.out.println("----------");
101.         //制作花生豆浆
102.         SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
103.         peanutSoyaMilk.make();
105.         System.out.println("----------");
107.         //制作纯豆浆
108.         SoyaMilk pureBeanSoyaMilk = new PureBeanSoyaMilk();
109.         pureBeanSoyaMilk.make();
110.     }
111. }

复制代码

注意事项和细节

• 1.基本思想是，算法只存在于一个地方，也就是父类中，容易修改。需要修改算法时，只要修改父类的模板方法，或者已经实现了某些步骤，子类就会继承这些修改。
  
• 2.实现了最大化代码复用，父类的模板方法，和已实现的某些步骤会被子类继承而直接使用。
  
• 3.即统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。
  
• 4.该模式的不足之处，每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大。
  
• 5.一般模板方法都加上final关键字，防止子类重写模板方法。
  
• 6.模板方法，使用场景，当要完成某个过程，该过程要执行一系列步骤，这一系列步骤基本相同，但其个别步骤在实现时 可能不同，通常考虑用模板方法模式做处理。
  

模板模式在Spring框架中的源码分析

1.     //该方法是AbstractApplicationContext类中的方法，类似模板模式中的模板方法(定义骨架的方法)，案例中的make()
2.     @Override
3.         public void refresh() throws BeansException, IllegalStateException {
4.         //定义容器初始化的模板，空方法由子类实现，由子类调用完成，容器的初始化，AbstractApplicationContext的子类有AbstractRefreshableApplicationContext和              
5.         // GenericApplicationContext
6.                 synchronized (this.startupShutdownMonitor) {
7.                         // Prepare this context for refreshing.
8.                         prepareRefresh();
10.                         // Tell the subclass to refresh the internal bean factory.
11.                         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
13.                         // Prepare the bean factory for use in this context.
14.                         prepareBeanFactory(beanFactory);
16.                         try {
17.                                 // Allows post-processing of the bean factory in context subclasses.
18.                                 postProcessBeanFactory(beanFactory);
20.                                 // Invoke factory processors registered as beans in the context.
21.                                 invokeBeanFactoryPostProcessors(beanFactory);
23.                                 // Register bean processors that intercept bean creation.
24.                                 registerBeanPostProcessors(beanFactory);
26.                                 // Initialize message source for this context.
27.                                 initMessageSource();
29.                                 // Initialize event multicaster for this context.
30.                                 initApplicationEventMulticaster();
32.                                 // Initialize other special beans in specific context subclasses.
33.                                 onRefresh();
35.                                 // Check for listener beans and register them.
36.                                 registerListeners();
38.                                 // Instantiate all remaining (non-lazy-init) singletons.
39.                                 finishBeanFactoryInitialization(beanFactory);
41.                                 // Last step: publish corresponding event.
42.                                 finishRefresh();
43.                         }
45.                         catch (BeansException ex) {
46.                                 if (logger.isWarnEnabled()) {
47.                                         logger.warn("Exception encountered during context initialization - " +
48.                                                         "cancelling refresh attempt: " + ex);
49.                                 }
51.                                 // Destroy already created singletons to avoid dangling resources.
52.                                 destroyBeans();
54.                                 // Reset 'active' flag.
55.                                 cancelRefresh(ex);
57.                                 // Propagate exception to caller.
58.                                 throw ex;
59.                         }
61.                         finally {
62.                                 // Reset common introspection caches in Spring's core, since we
63.                                 // might not ever need metadata for singleton beans anymore...
64.                                 resetCommonCaches();
65.                         }
66.                 }
67.         }
68.     //该方法是AbstractApplicationContext类中的方法
69.     protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
70.                 refreshBeanFactory();//这个方法，在本类中是抽象方法，由子类去实现
71.                 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
72.                 if (logger.isDebugEnabled()) {
73.                         logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
74.                 }
75.                 return beanFactory;
76.         }
77.     //该方法是AbstractApplicationContext类中的方法 类似模板模式中的抽象方法，需要子类实现，案例中的add()方法
78.     protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

复制代码

只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！