回调函数

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/linxinghui/archive/2009/10/14/4670818.aspx

 

 java回调机制：

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：

同步调用、回调和异步调用。

同步调用是一种阻塞式调用，调用 方要等待对方执行完毕才返回，它是一种单向调用；

回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口 ；(这就需要把把调用者的实例放到被调者的实例中)

异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。---有点像观察者模式

回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。

这是搜索的一点比较枯燥的理论解释了，算是红体部分让我稍微明白了一点是怎么个回事，然后又看到一个例子，又让我明白不少。

看看在JAVA里的例子:

public class Test{

   public static void main(String[] args){

     FooBar foo=new FooBar();

/**注意下面的这项代码片段，它给foo对象传递了一个实现ICallBack接口的匿名类，这样FooBar类的对象就取

得了一个实现接口的类，因此FooBar可以在任何时候调用接口中的方法*/

     foo.setCallBack(new ICallBack(){

     public void postExec(){System.out.println("我(postExec)是在Test类中实现的，但我不能被Test的对象引用,"+

     "而由FooBar对象调用 ");}

     });

   }

}

public interface ICallBack(){

  void postExec();

}

public class FooBar..{

  private ICallBack callBack;

  public void setCallBack(ICallBack callBack){

    this.callBack=callBack;

  }

/*我没有实现接口，但是我取得了一个实现接口的对象，而这个对象是其他类调用我的方法（ setCallBack ()）

时所赋给我的，因此 我可以在业务需要的地方来调用实现接口的类里面的方法*/

  public void doSth(){

     ....

     callBack.postExec();

  }

  ..

}

上述两个类的描述：

  1.class   A,class   B  

  2.class   A实现接口ICallBack  

  3.class   B拥有一个参数为ICallBack接口类型的函数setCallBack(ICallBack   o)  

  4.class   A运行时调用class   B中setCallBack函数,以自身传入参数  

  5.class   B已取得A，就可以随时回调A所实现的ICallBack接口中的方法

下面在来看看在Hibernate中如何构造自己的HibernateTemplate模版

使用模板模式简化DAO操作Hibernate

 

在使用Spring ＋ Hibernate做开发过时，在写DAO的时候使用过Spring的HibernateDaoSupport类，然后在实现的时候就可以很轻松的使用 getHibernateTemplate()方法之后就可以调用save()、delete()、update()等Hibernate的 Session的操作，很简单。比如：
　　
　　getHibernateTemplate().save(user);

　但是我们在使用Hibernate的时候不一定会使用Spring，所以我们可以模仿Spring的处理方式，做一个Hibernate的模板，使用模板模式来简化我们的开发，其主要的目的就是为了简化开发，使代码达到最大化的重用，另外呢，是帮助自己对回调机制有一个更深层的了解。

1．我们现来实现一个Hibernate模板：
　　
　　package kick.hibernate;
　　
　　import net.sf.hibernate.HibernateException;
　　import net.sf.hibernate.Session;
　　import net.sf.hibernate.Transaction;
　　
　　public class HibernateTemplate{
　　public static Object run(HibernateCallback callback) throws HibernateException{
　　Session session = null;
　　Transaction tx = null;
　　try {
　　session = HibernateSessionutil.currentSession();
　　tx = session.beginTransaction();
　　Object result = callback.execute(session);
　　tx.commit();
　　session.flush();
　　return result;
　　} catch (HibernateException e) {
　　tx.rollback();
　　return null;
　　} finally {
　　HibernateSessionutil.closeSession();
　　}
　　}

这里类很简单，就是使用一个实现HibernateCallBack接口的一个回调类，在调用的时候根据具体的需求实现HibernateCallBack类。

强调一下偶，仔细体会红色部分的代码，其实这部分就是对回调的最好的体现，callbak肯定是一个实现了HibernateCallback 接口的类的对象，而execute(Session s)的具体实现就是在这个实现类中实现的，但是我们没法显示的调用该实现类里面的具体方法，如execute()，而只是通过接口的形式来调用方法，晕，说了一大堆，把我自己都快整糊涂了，算了，还是继续写例子吧，结合例子看，可能明白的更快一些。

2．回掉接口HibernateCallBack：
　　package kick.hibernate;
　　
　　import net.sf.hibernate.HibernateException;
　　import net.sf.hibernate.Session;
　　
　　public interface HibernateCallBack {
　　Object execute(Session session)throws HibernateException;
　　}

好了，到此为止我们就可以使用这个模板了，可以用如下的方式使用：

//调用的时候根据具体的需求实现HibernateCallBack类。 我在这里是实现保存的业务

HibernateTemplate.run(

new HibernateCallback() {
　　public Object execute(Session session) throws HibernateException {
　　session.save(user);
　　return null;
　　}
　　}   //这其实是一个匿名类

);

不过这还没有达到想Spring里面那样简单，不要着急，“面包会有的”呵呵，我们会达到的。

3．实现我们自己的HibernateSupport类：
　　
　　从上面的代码可以看出，我们要自己实现HibernateCallback接口，而每次我们实现的时候又重复代码了。因此我们再抽象，讲这些实现放到我们的 HibernateSupport类里面去。看看我们上面的代码就知道我们实现HibernateCallback接口的目的就是为了调用 session.save()方法，即session的方法。代码如下：
　　
　　package kick.hibernate;
　　
　　import java.io.Serializable;
　　
　　import net.sf.hibernate.HibernateException;
　　import net.sf.hibernate.Session;
　　
　　public class HibernateSupport{
　　
　　public Object save(final Object object) throws HibernateException{
　　return HibernateTemplate.run(new HibernateCallBack(){
　　
　　public Object execute(Session session) throws HibernateException {
　　session.save(object);
　　return null;
　　}
　　
　　});
　　}
　　public Object save(final Object object,final Serializable id) throws HibernateException{
　　return HibernateTemplate.run(new HibernateCallBack(){
　　
　　public Object execute() throws HibernateException {
　　session.save(object,id);
　　return null;
　　}
　　
　　});
　　}
　　
　　public Object saveOrUpdate(final Object object) throws HibernateException{
　　return HibernateTemplate.run(new HibernateCallBack(){
　　
　　public Object execute(Session session) throws HibernateException {
　　session.saveOrUpdate(object);
　　return null;
　　}
　　
　　});
　　}
　　……………………………………………………………………………………
　　……………………………………………………………………………………
　　……………………………………………………………………………………
　　
　　调用一些其他的session的方法。
　　
　　}
　　
　　4．抽象RootDao：
　　
　　该类为抽象类，在实现自己的DAO类的时候继承该类。该类的有一个HibernateSupport的对象，在子类中使用getHibernateTemplate()方法就可以得到该对象，然后调用它对应的方法。实现代码如下：
　　
　　package kick.hibernate.dao;
　　
　　import net.sf.hibernate.Session;
　　import kick.hibernate.HibernateTemplateImpl;
　　
　　public abstract class RootDao {
　　private HibernateSupport temp = null;
　　
　　/**
　　* @return Returns the temp.
　　*/
　　public HibernateTemplateImpl getHibernateTemplate(Session session) {
　　return new HibernateSupport();
　　}
　　}
　　
　　5．使用例子：
　　
　　定义一个自己的DAO类，实现代码如下：
　　
　　public class UserDaoImpl extends RootDao implements UserDaoInterface{
　　public void saveUser(User user) throws KickException {
　　getHibernateTemplate().saveOrUpdate(user);
　　}
　　……………………………………………………………………………………
　　实现其他的方法
　　……………………………………………………………………………………
　　}
　　看到没有？红色的代码，就实现了Spring的HibernateSupport了吧

好了，回调暂时这这里就告一段落了......