回调的妙用

 

     回调一般在java应用中，于window编程比较多，本人在这方面经验比较少，对回调的应用经验几乎是空白，因此对JAVA的回调技术没什么了解。

     后来也就是在使用hibernate的时候，应用了spring包装的hibnerte 的API类HibernateDaoSupport的时候，在分页查询，应用了Criteria的动态查询，HibernateTemplate支持得不是很好，就用了回调的技术

    

java 代码

public PaginationSupport findPageByCriteria(
            final DetachedCriteria detachedCriteria, final int page,
            final int pageSize) {
        return (PaginationSupport) getHibernateTemplate().execute(
                new HibernateCallback() {
                    public Object doInHibernate(Session session)
                            throws HibernateException {
                        Criteria criteria = detachedCriteria
                                .getExecutableCriteria(session);
                        int totalCount = ((Integer) criteria.setProjection(
                                Projections.rowCount()).uniqueResult())
                                .intValue();
                        criteria.setProjection(null);
                        List items = criteria.setFirstResult(page)
                                .setMaxResults(pageSize).list();
                        PaginationSupport ps = new PaginationSupport(items,
                                totalCount, pageSize, page);
                        return ps;
                    }
                }, true);
    }

 

         后来看到有关回调技术的说法：

        当通常大家说的回调函数一般就是按照别人的定好的接口规范写的，等待别人调用的函数，在C语言中，回调函数通常通过函数指针来传递；在Java中，通常就是编写另外一个类或类库的人规定一个接口，然后你来实现这个接口，然后把这个实现类的一个对象作为参数传给别人的程序，别人的程序必要时就会通过那个接口来调用你编写的函数。

        最近在研究jive论坛，在搜索的时候它使用了Ietorator，其中就是使用了回调的技术，忽然眼前一亮，至此，才看到回调的妙用。

        看片断，构造函数：

java 代码

public DatabaseObjectIterator(int type, long [] elements,
           final Object extraObject)
   {
       this.elements = elements;

       // Load the appropriate proxy factory depending on the type of object
       // that we're iterating through.
       switch (type) {
           // FORUM
           case JiveGlobals.FORUM:
               // Create an objectFactory to load forums.
               this.objectFactory = new DatabaseObjectFactory() {
                   ForumFactory factory = (ForumFactory)extraObject;

                   public Object loadObject(long id) {
                       try {
                           Forum forum = factory.getForum(id);
                           return forum;
                       }
                       catch (ForumNotFoundException mnfe) { }
                       catch (UnauthorizedException ue) { }
                       return null;
                   }
               };
               break;

      

//THREAD
           case JiveGlobals.THREAD:
               // Create an objectFactory to load threads. There are two
               // possibilities -- the first is that extraObject is a
               // Forum that we can directly load threads from. The
               // second is that extraObject is a DbForumFactory. The latter
               // case can occur when we need to iterate through a set of
               // threads that come from multiple different forums.
               if (extraObject instanceof Forum) {
                   this.objectFactory = new DatabaseObjectFactory() {
                       Forum forum = (Forum)extraObject;

                       public Object loadObject(long id) {
                           try {
                               ForumThread thread = forum.getThread(id);
                               return thread;
                           }
                           catch (ForumThreadNotFoundException tnfe) { }
                           return null;
                       }
                   };
               }
               else {
                   this.objectFactory = new DatabaseObjectFactory() {
                       DbForumFactory factory = (DbForumFactory)extraObject;

                       public Object loadObject(long id) {
                           try {
                               return factory.cacheManager.threadCache.get(id);
                           }
                           catch (ForumThreadNotFoundException mnfe) { }
                           return null;
                       }
                   };
               }
               break;

 

//MESSAGE
           case JiveGlobals.MESSAGE:
               // Create an objectFactory to load messages. There are two
               // possibilities -- the first is that extraObject is a
               // ForumThread that we can directly load messages from. The
               // second is that extraObject is a DbForumFactory. The latter
               // case can occur when we need to iterate through a set of
               // messages that come from multiple different threads.
               if (extraObject instanceof ForumThread) {
                   this.objectFactory = new DatabaseObjectFactory() {
                       ForumThread thread = (ForumThread)extraObject;

                       public Object loadObject(long id) {
                           try {
                               ForumMessage message = thread.getMessage(id);
                               return message;
                           }
                           catch (ForumMessageNotFoundException mnfe) { }
                           return null;
                       }
                   };
               }
               else {
                   this.objectFactory = new DatabaseObjectFactory() {
                       DbForumFactory factory = (DbForumFactory)extraObject;

                       public Object loadObject(long id) {
                           try {
                               ForumMessage message =
                                       factory.cacheManager.messageCache.get(id);
                               // Now, get the message from its thread so that
                               // filters are applied to the message.
                               message = message.getForumThread().getMessage(id);
                               return message;
                           }
                           catch (ForumMessageNotFoundException mnfe) { }
                           return null;
                       }
                   };
               }
               break;

 

//USER
          case JiveGlobals.USER:
              // Create an objectFactory to load users.
              this.objectFactory = new DatabaseObjectFactory() {
                  UserManager userManager = (UserManager)extraObject;

                  public Object loadObject(long id) {
                      try {
                          User user = userManager.getUser(id);
                          return user;
                      }
                      catch (UserNotFoundException unfe) { }
                      return null;
                  }
              };
              break;
          //GROUP
          case JiveGlobals.GROUP:
              // Create an objectFactory to load groups.
              this.objectFactory = new DatabaseObjectFactory() {
                  GroupManager groupManager = (GroupManager)extraObject;

                  public Object loadObject(long id) {
                      try {
                          Group group = groupManager.getGroup(id);
                          return group;
                      }
                      catch (GroupNotFoundException gnfe) { }
                      return null;
                  }
              };
              break;
          // Otherwise, an invalid value was passed in so throw an exception.
          default:
              throw new IllegalArgumentException("Illegal type specified");
      }
  }

定义回调的方法的接口类：

 

 

interface DatabaseObjectFactory {

    /**
     * Returns the object associated with id or null if the
     * object could not be loaded.
     *
     * @param id the id of the object to load.
     * @return the object specified by id or null if it could not
     *      be loaded.
     */
    public Object loadObject(long id);
}

 

对接口方法的调用

 

java 代码

public Object getNextElement() {
        while (currentIndex+1 < elements.length) {
            currentIndex++;
            Object element = objectFactory.loadObject(elements[currentIndex]);
            if (element != null) {
                return element;
            }
        }
        return null;
    }

 

 继续......