Java设计模式--回调模式
回调模式概念
上一节我们讲了一下模板模式的作用，模板模式可以将实现步骤延迟到子类中进行，其实在Java开发中，还有另外一个方法可以实现同样的功能，那就是Java回调技术，通过回调在接口中定义的方法，调用到具体的实现类中的 方法，其本质是利用Java的动态绑定技术，在这种实现中，可以不把实现类写成单独的类，而使用内部类或匿名内部类来实现回调方法。
还是拿上一节的模板模式代码举例，如果我每次需要使用jdbcTemplate时，都要继承一下父类，是不是有些不方便呢？ 毕竟一个类只能继承一个父类，但是接口就不一样了，我们可以实现很多接口。
那就让我们甩掉abstract这顶帽子吧，这时，就该callback（回调）上场了
所谓回调，就是在方法参数中传递一个接口，在调用此方法时，必须调用方法中传递的接口的实现类。
回调模式一般满足如下条件：
1.类A持有类B的一个引用，并且类A实现了一个接口CallBack;
2.类B有一个方法method(CallBack callBack)，接收一个参数callBack，参数类型为CallBack，在方法method中()调用了callBack接口的实现类的方法。
一个示例代码如下所示：
interface CallBack {
public void doSomething();
}
class A implements CallBack {
private B b;
A(B b) {
this.b = b;
}
public void test() {
b.testB(this);
}
public void doSomething() {
System.out.println("do something...");
}
}
class B {
public void testB(CallBack callBack) {
System.out.println("========================");
callBack.doSomething();
}
}
public class CallBackDemo {
public static void main(String[] args) {
B b = new B();
A a = new A(b);
a.test();
}
}
上述代码分析：
这是一个最简单的回调模式的实现代码。A实现饿了CallBack接口，并且在A中有一个B的引用，B的testB(CallBack callBack)方法接收一个CallBack的实现类作为参数，并且在testB()方法中代用callback的doSomething()方法，这个方法为CallBack接口的实现类doSomething()方法，在之前实现接口的时候根据自己的需要自定义功能代码，而公共的代码部分放在testB()方法中实现。
接下来我们结合前一节模板模式的代码进行修改，采用回调的方式来实现：
首先，我们定义一个回调接口：
public interface StatementCallback {
Object doInStatement(Statement stmt) throws SQLException;
}
接下来我们重新定义JDBCtemplate类：
public class JdbcTemplate {
public final Object execute(StatementCallback action) throws SQLException{
Connection con = HsqldbUtil.getConnection();
Statement stmt = null;
try {
stmt = con.createStatement();
Object result = action.doInStatement(stmt);
return result;
}
catch (SQLException ex) {
ex.printStackTrace();
throw ex;
}
finally {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
if(!con.isClosed()){
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//这是是为了看着更整齐添加的方法
public Object query(StatementCallback stmt) throws SQLException{
return execute(stmt);
}
}
至此，我们已经成功了将模板模式改为了采用回调模式。接下来我们创建一个test.java来测试一下，在前面我们也说过，回调模式有两种调用方式，我们可以使用内部类或匿名内部类来实现回调方法：
内部类：
public Object query(final String sql) throws SQLException {
class QueryStatementCallback implements StatementCallback {
public Object doInStatement(Statement stmt) throws SQLException {
ResultSet rs = stmt.executeQuery(sql);
List<User> userList = new ArrayList<User>();
User user = null;
while (rs.next()) {
user = new User();
user.setId(rs.getInt("id"));
user.setUserName(rs.getString("user_name"));
user.setBirth(rs.getDate("birth"));
user.setCreateDate(rs.getDate("create_date"));
userList.add(user);
}
return userList;
}
}
JdbcTemplate jt = new JdbcTemplate();
return jt.query(new QueryStatementCallback());
}
在调用jdbcTemplate.query()方法时，将内部类StatementCallBack()的实例传过去。
匿名内部类：
//匿名类方式
public Object query2(final String sql) throws Exception{
JdbcTemplate jt = new JdbcTemplate();
return jt.query(new StatementCallback() {
public Object doInStatement(Statement stmt) throws SQLException {
ResultSet rs = stmt.executeQuery(sql);
List<User> userList = new ArrayList<User>();
User user = null;
while (rs.next()) {
user = new User();
user.setId(rs.getInt("id"));
user.setUserName(rs.getString("user_name"));
user.setBirth(rs.getDate("birth"));
user.setCreateDate(rs.getDate("create_date"));
userList.add(user);
}
return userList;
}
});
}
在平时的代码中，我们使用匿名内部类的方式也更加多一些。
综上两种回调方式可以发现，回调模式相比于模板模式更简洁也更灵活一些。
通过对比模板模式与回调模式我们可以发现模板模式有一些弊端：
当流程中包含抽象函数，子类继承父类并实现父类的抽象函数，这样父类的流程这个流程是不变的，变的只是子类的抽象方法的实现。但是这个的基础是继承，如果你变化的部分太多，你要实现很多很多类，而且如果父类的流程有多个，那子类要实现自己并不需要的抽象函数，这是一个弊端。
这也是为什么spring不单一的使用传统的模板方法，而加之以Callback进行配合的原因。
试想，如果父类中有10个抽象方法，而继承它的所有子类则要将这10个抽象方法全部实现，子类显得非常臃肿。而有时候某个子类只需要定制父类中的某一个方法该怎么办呢？这个时候就要用到Callback回调了。
在文章编写过程中，参照了一些前人的文章：
http://www.360doc.com/content/18/0714/22/56263195_770418578.shtml
https://blog.csdn.net/zhang23242/article/details/9305925
