模板模式

我们在看spring中有部分说到持久层，其中有个类JdbcTemplate，它是利用Template模式。

Template模式就是说：在父类中定义一个操作算法或操作顺序，而将一些步骤的具体实现延迟到子类中。请看列子：

// TemplateTest.java

 

[java]  view plain copy

1. package com.designpattern.template;  
2.   
3. /** 
4.  * 父类 
5.  */  
6. abstract class SuperTemplate {  
7.     public abstract Object doInTransaction();  
8.   
9.     public void execute() {  
10.         try {  
11.             System.out.println("事务开始。。。");  
12.             System.out.println("开始执行业务逻辑代码。。。");  
13.             doInTransaction();  
14.             System.out.println("业务逻辑处理完成，提交事务");  
15.         } catch (Exception e) {  
16.             System.out.println("出现错误，回滚");  
17.         }  
18.     }  
19. }  
20.   
21. /** 
22.  * 子类 
23.  */  
24. class SubTemplate extends SuperTemplate {  
25.   
26.     public Object doInTransaction() {  
27.         System.out.println("正在执行业务逻辑代码。。。");  
28.         // 事务出错代码  
29.         // int i = 1/0;  
30.         return null;  
31.     }  
32. }  
33.   
34. public class TemplateTest {  
35.     public static void main(String[] args) {  
36.         SubTemplate s = new SubTemplate();  
37.         s.execute();  
38.     }  
39. }  

 

首先在父类SuperTemplate中定义两个方法：doInTransaction()和execute()，execute()方法用来执行事务，doInTransaction()是事务的具体操作，但是doInTransaction()是个抽象方法，并没有具体的行为，它把行为交给了它的子类SuperTemplate ，子类中重写这个方法，然后在测试类中调用SubTemplate.execute()方法就行了。

 

出此之外，还有一种回调形式是利用接口回调函数，例子：

// TemplateTest2.java

 

[java]  view plain copy

1. package com.designpattern.template;  
2.   
3. /** 
4.  * 回调接口 
5.  */  
6. interface TestTemplateCallBack {  
7.     Object doSomething();  
8. }  
9.   
10. class Template2 {  
11.   
12.     /** 
13.      * 执行业务逻辑的方法，参数类型为接口对象 
14.      *  
15.      * @param callBack:TestTemplateCallBack接口对象 
16.      */  
17.     public void execute(TestTemplateCallBack callBack) {  
18.         try {  
19.             System.out.println("事务开始。。。");  
20.             System.out.println("开始执行业务逻辑。。。");  
21.             callBack.doSomething();  
22.             System.out.println("业务逻辑执行成功，提交事务");  
23.         } catch (Exception e) {  
24.             System.out.println("出现错误，回滚");  
25.             e.printStackTrace();  
26.         }  
27.     }  
28. }  
29.   
30. public class TemplateTest2 {  
31.     public void insert(final String msg) {  
32.         Template2 t = new Template2();  
33.         // 匿名内部类重写方法  
34.         t.execute(new TestTemplateCallBack() {  
35.             public Object doSomething() {  
36.                 // 事务出错代码  
37.                 // int i = 1 / 0;  
38.                 System.out.println("插入数据:" + msg);  
39.                 return null;  
40.             }  
41.         });  
42.     }  
43.   
44.     public static void main(String[] args) {  
45.         TemplateTest2 t = new TemplateTest2();  
46.         t.insert("Hello");  
47.     }  
48. }  

 

在这里申明一个接口，里面有个方法doSomething()。Template2 这个类中的execute()方法用来执行事务，其中有个参数：execute(TestTemplateCallBack callBack)，参数类型为之前定义的接口对象，然后就可以利用这个对象来调用doSomething()方法。但是doSomething()方法具体的操作内容在哪呢？它在TemplateTest2的insert()方法里面，这里在TemplateTest2类中定义一个insert()方法，接着申明一个Template2对象t，当执行t.execute()方法的时候，这时我们写个匿名类来当传入参数，这匿名类就是之前的接口，在匿名类中重写doSomething()方法就可以实现具体操作了。