回调模式概念

上一节我们讲了一下模板模式的作用，模板模式可以将实现步骤延迟到子类中进行，其实在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

Java设计模式--回调模式