设计模式： 回调模式，剖析与深入探讨····

 

一 回调模式（CallBack）

    1 类A持有一个类B的一个引用，类A并且实现了一个接口CallBack

    2 类B有一个方法f，接收一个参数callBack，参数类型为CallBack，在方法f中调用了callBack的方法

    下面是一个小例子：

 

/*** 
 * @author Jaylon  Huang
 * @date 2018/11/2 11:02 
 */
package com.test.CallbackDesignPattern;


// A 程序员写的A类
public class CallbackDesignPatternDemo {
    CallbackFunInterface callbackClientFun;

     public CallbackDesignPatternDemo( CallbackFunInterface callbackFun){
         this.callbackClientFun = callbackFun;
     }

     public void clientCallback(){
         callbackClientFun.CallbackFun();
     }

    public static void main(String[] args) {
        clientFuc B = new clientFuc();
        CallbackDesignPatternDemo A = new CallbackDesignPatternDemo(B);
        A.clientCallback();
    }
}


interface CallbackFunInterface {

     public void  CallbackFun();

}
// B 程序员写的B类
class clientFuc implements CallbackFunInterface{

    @Override
    public void CallbackFun() {
        System.out.println("This this action of the client callback");
    }
}

一直思考使用CallBack的好处是什么？

 

 

二 Spring CallBack 模式的使用

    在Spring 中大量的使用了回调模式，很多都封装到了源码中，现在我举一个和我们写代码最相关的例子：HibernateCallback

    HibernateCallback：经常使用spring整合hibernate的程序员们都该知道，我们的Dao实现类一般都会继承HibernateDaoSupport，由此我们可以得到HibernateTemplate，spring对hibernate的操作进行了封装，

    HibernateTemplate提供了常规的CRUD操作，但是HibernateTemplate的封装也是程序失去了hibernate中直接使用Session操作的灵活性，所以HibernateTemplate提供了

    execute(CallBack action)等系列方法，允许程序员实现自己的HibernateCallBack，实现具体的逻辑。

    如下代码是HibernateTemplate如何具体使用HibernateCall（即回调的具体实现）：

   

Java代码 

 

1. public  T execute(HibernateCallback action) throws DataAccessException {  
2.     return doExecute(action, false, false);  
3. }  
4.   
5. protected  T doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession)  
6.         throws DataAccessException {  
7.   
8.     Assert.notNull(action, "Callback object must not be null");  
9.   
10.     Session session = (enforceNewSession ?  
11.             SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession());  
12.     boolean existingTransaction = (!enforceNewSession &&  
13.             (!isAllowCreate() || SessionFactoryUtils.isSessionTransactional(session, getSessionFactory())));  
14.     if (existingTransaction) {  
15.         logger.debug("Found thread-bound Session for HibernateTemplate");  
16.     }  
17.   
18.     FlushMode previousFlushMode = null;  
19.     try {  
20.         previousFlushMode = applyFlushMode(session, existingTransaction);  
21.         enableFilters(session);  
22.         Session sessionToExpose =  
23.                 (enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));  
24. span style="color: #ff0000;">                        //在HibernateTemplate中得到实现，然后调用回调函数实现具体的逻辑  
25.         T result = action.doInHibernate(sessionToExpose);  
26.         flushIfNecessary(session, existingTransaction);  
27.         return result;  
28.     }  
29.     catch (HibernateException ex) {  
30.         throw convertHibernateAccessException(ex);  
31.     }  
32.     catch (SQLException ex) {  
33.         throw convertJdbcAccessException(ex);  
34.     }  
35.     catch (RuntimeException ex) {  
36.         // Callback code threw application exception...  
37.         throw ex;  
38.     }  
39.     finally {  
40.         if (existingTransaction) {  
41.             logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");  
42.             disableFilters(session);  
43.             if (previousFlushMode != null) {  
44.                 session.setFlushMode(previousFlushMode);  
45.             }  
46.         }  
47.         else {  
48.             // Never use deferred close for an explicitly new Session.  
49.             if (isAlwaysUseNewSession()) {  
50.                 SessionFactoryUtils.closeSession(session);  
51.             }  
52.             else {  
53.                 SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());  
54.             }  
55.         }  
56.     }  
57. }  

 由此可见，在此处使用回调模式，公共部分的操作都放在了hibernateTemplate的doExcute方法里，具体的实现让程序员来实现HibernateCallback回调接口，从而实现具体的逻辑，本人感觉这是CallBack模式的一大优点