Informa的hibernate包提供的是基于Hibernate的接口实现，这意味着从这个包获取的任意对象必须都是持久化的状态或者可以被持久化的。其中的关键就是ChannelBuilder类和SessionHandler类

与impl.basic包中的ChannelBuilder类不同，impl.hibernate包中的ChannelBuilder依赖于Hibernate来完成对象的构建和访问。对于这个类必须注意的是“它是线程不安全的”

Factory for the creation of the channel object model with the hibernate persistent store.

NOT THREAD SAFE

Hibernate Multi-threading notes: ChannelBuilder has some subtleties as it relates to threading. The specifics of the way it is supported still need to be proven. Certainly the error handling here and in UpdateChannelTask and in ChannelRegistry is incomplete. It seems to work, but I would consider it incomplete still.

The key facts are
 (1) Sessions are not thread safe and
 (2) Sessions should have relatively short lifespans.

原因作者在上面已经提到了因为ChannelBuilder依赖于Hibernate的Session，而Session又是线程不安全的。如果在创建出ChannelBuilder后不小心传递给不恰当的对象，就会造成不恰当的持久化。针对此问题，作者提出了自己的解决方法：

To support this, there is a mode of using ChannelBuilder where it holds on to a SessionHandler and manages the creation and destruction of Sessions on behalf of the caller. When you supply a SessionHandler to ChannelBuilder, you may use the beginTransaction() and endTransaction() calls to take all the steps needed before and after a transaction. At the end of endTransaction() the transaction will be closed and the session will be flushed and closed. To use this mode, you should
 (1) Create a SessionHandler ,
 (2) Create a JDBC Connection to the database,
 (3) sessionHandler.setConnection(connection), and 
 (4) use new ChannelBuilder(sessionHandler).

根据作者的说法，我们应该首先创建一个SessionHandler对象，那么这个SessionHandler又是什么东西？其实SessionHandler类似于Hibernate提供的HibernateUtil类，用于获取session对象，也是一个单例模式。但和HibernateUtil不同，SessionHandler不会把session保存到ThreadLocal中，而是交由ChannelBuilder保存。

★SessionHandler

在SessionHandler中维护了以下变量

    private static SessionHandler myInstance;

    private Configuration cfg;
    private SessionFactory sessFactory;
    private Connection conn;
    private Session curSession;

SessionHandler可以根据外界传递的java.sql.Connection对象参数来动态创建session，也可以根据初始化时从hibernate.cfg.xml文件中读入的信息来默认创建并返回

  public void setConnection(Connection connection) {
        conn = connection;
    }

  public Session getSession() throws HibernateException {
        if (conn != null)
               // use specific connection information
            curSession = sessFactory.openSession(conn);
        else
              // use connection information from xml file
            curSession = sessFactory.openSession();
        return curSession;
    }

    public Session getSession(Connection conn) {
        this.conn = conn;
        curSession = sessFactory.openSession(conn);
        return curSession;
    }

    public ChannelBuilder(Session session) {
        logger.info("New Channel Builder for: " + session);
        this.session = session;
        this.handler = null;
    }

    /** *//**
     * ChannelBuilder constructor. ChannelBuilder will manage sessions and
     * transactions. Supplied SessionHandler needs to have a live JDBC connection
     * available.
     */
    public ChannelBuilder(SessionHandler handler) {
        logger.debug("New Channel Builder for: " + handler);
        this.handler = handler;
        this.session = null;
    }

/** *//**
     * Processing needed at the start of a transaction. - creating a session -
     * beginning the transaction
     */
    public void beginTransaction() throws ChannelBuilderException {
        logger.info("beginTransaction");
          // Session should be create by handler
        if (session != null || handler == null)              
            throw new IllegalStateException(
                    "Session != null || handler == null");
        try {
              // Get Session from handler and open transaction
            session = handler.getSession();
            transaction = session.beginTransaction();
        } catch (HibernateException e) {
            e.printStackTrace();
            transaction = null;
            throw new ChannelBuilderException(e);
        }
    }

上面的方法有2个需要注意的地方：
 A.Session必须由SessionHandler来获取，如果使用第一种构造方法此时调用会出错
 B.Session只能在Transaction开始时才打开，在构造函数执行时依然是null的，避免浪费资源

结束事务

    /** *//**
     * Processing needed at the end of a transaction. - commit the transaction -
     * flush the session - close the session TODO: catch the exception so this
     * method doesn't have any throws.
     */
    public void endTransaction() throws ChannelBuilderException {
        logger.info("endTransaction");
        if (handler == null || transaction == null || session == null)
            throw new IllegalStateException(
                    "handler == null || transaction == null || session == null");
        try {
            // Why flush after commit transaction ?
            transaction.commit();
            session.flush();
            session.close();
            session = null;
            transaction = null;

        } catch (HibernateException he) {
            if (transaction != null)
                try {
                    he.printStackTrace();
                    transaction.rollback();
                    transaction = null;
                    if (session.isOpen()) {
                        session.close();
                        session = null;
                    }
                } catch (HibernateException e) {
                    if (session.isOpen()) {
                        session = null;
                    }
                    e.printStackTrace();
                    throw new ChannelBuilderException(e);
                }
            throw new ChannelBuilderException(he);
        }
    }

这个方法我有一个不懂的地方：为什么是commit在先，再flush的？这个需要再和作者探讨。

ChannelBuilder允许我们重设事务，即提交现有事务并刷新缓存，之后注销transaction和session。这一点我认为适合于在一个“长事务”的过程中，切换到不同的事务上下文环境。

重置事务

    public void resetTransaction() {
        logger.debug("Transaction being reset.");
        // Transaction already start, should commit or rollback
        // first, then close the session if it's open
        if (transaction != null) {
            try {
                transaction.commit();
                transaction = null;
            } catch (HibernateException e) {
                // Why don't need to rollback the transation
                transaction = null;
                e.printStackTrace();
            }
        }
        if (session != null) {
            try {
                session.flush();
                session.close();
                session = null;
            } catch (HibernateException e) {
                e.printStackTrace();
                session = null;
            }
        }
    }

    /** *//**
     * Check if we are already in the middle of a transaction. This is needed
     * because as of now begin/endTransactions cannot be nested and in fact give
     * assert errors if you try.
     * 
     * @return - boolean indicating whether we are currently in a transaction.
     */
    public boolean inTransaction() {
        return session != null && transaction != null;
    }

    /** *//**
     * Certain Hibernate calls require the session. Note that this call should
     * only be made between a beginTransaction and endTransaction call which is
     * why we throw an IllegalStateException otherwise.
     */
    public Session getSession() {
        if (handler == null || session == null)
            throw new IllegalStateException(
                    "getSession must be bracketed by begin/endTransaction");
        if (!handler.isSessionOpen())
            throw new IllegalStateException("Hibernate Handler must be open");
        return session;
    }

/** *//**
     * Returns true if session is open.
     */
    public boolean isSessionOpen() {
        return curSession.isOpen();
    }

在ChannelBuilder中提供了三个持久化的方法，分别用于持久化各种channel object。

 protected void save(Object dataObject) {
        if (session == null)
            throw new IllegalStateException("Session == null");
        try {
            session.save(dataObject);
        } catch (HibernateException he) {
            throw new RuntimeException(he.getMessage());
        }
    }

    public void update(Object o) throws ChannelBuilderException {
        try {
            session.update(o);
        } catch (HibernateException e) {
            e.printStackTrace();
            throw new ChannelBuilderException("update() Failed");
        }
    }

    public void delete(Object o) throws ChannelBuilderException {
        try {
            session.delete(o);
        } catch (HibernateException e) {
            e.printStackTrace();
            throw new ChannelBuilderException("delete() Failed");
        }
    }

请注意这里：如果采用构造方法一，那么你将需要在执行这些方法后手动提交事务。如果你认为你的操作不需要事务那么当然可以不用。

★创建channel object

在ChannelBuilder里面，数量最多的方法就是creatXxx(Param1, Param2...)这一类的方法。例如下面的createChannel方法

    /** *//**
     * Try to get unique object from database if any record matches the 
     * location string. Otherwise create it at memory first and then save
     * to database.
     * 
     * Channel returned by this method will be synchronized by Hibernate
     * automatically since now it's persistent state 
     * 
     * May throw runtime HibernateException
     */
    public ChannelIF createChannel(Element channelElement, String title,
            String location) {
        ChannelIF obj = null;
        if (location != null) {
            Query query = session
                    .createQuery("from Channel as channel where channel.locationString = ? ");
            query.setString(0, location);
            obj = (ChannelIF) query.uniqueResult();
        }
        if (obj == null) {
            obj = new Channel(channelElement, title, location);
            session.save(obj);
        } else {
            logger
                    .info("Found already existing channel instance with location "
                            + location);
        }
        return obj;
    }

ChannelBuilder对channel object的创建原则就是：
 A.如果能够从持久层中找到对应的记录，那么从持久层返回
 B.如果找不到，则创建它并持久化它，然后返回该对象(已持久化)

只要记得的一点就是：从ChannelBuilder返回的对象都是已经持久化的。比如channel，此时我们甚至可以通过channel.getItems()来获得其下属的各个news item。