java 设计模式 回调_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 userList = new ArrayList();

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 userList = new ArrayList();

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回调了。

在文章编写过程中，参照了一些前人的文章：