Informa的hibernate包提供的是基于Hibernate的接口實(shí)現(xiàn)，這意味著從這個(gè)包獲取的任意對(duì)象必須都是持久化的狀態(tài)或者可以被持久化的。其中的關(guān)鍵就是ChannelBuilder類和SessionHandler類

與impl.basic包中的ChannelBuilder類不同，impl.hibernate包中的ChannelBuilder依賴于Hibernate來完成對(duì)象的構(gòu)建和訪問。對(duì)于這個(gè)類必須注意的是“它是線程不安全的”

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.

原因作者在上面已經(jīng)提到了因?yàn)镃hannelBuilder依賴于Hibernate的Session，而Session又是線程不安全的。如果在創(chuàng)建出ChannelBuilder后不小心傳遞給不恰當(dāng)?shù)膶?duì)象，就會(huì)造成不恰當(dāng)?shù)某志没ａ槍?duì)此問題，作者提出了自己的解決方法：

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).

根據(jù)作者的說法，我們應(yīng)該首先創(chuàng)建一個(gè)SessionHandler對(duì)象，那么這個(gè)SessionHandler又是什么東西？其實(shí)SessionHandler類似于Hibernate提供的HibernateUtil類，用于獲取session對(duì)象，也是一個(gè)單例模式。但和HibernateUtil不同，SessionHandler不會(huì)把session保存到ThreadLocal中，而是交由ChannelBuilder保存。

★SessionHandler

在SessionHandler中維護(hù)了以下變量

    private static SessionHandler myInstance;

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

SessionHandler可以根據(jù)外界傳遞的java.sql.Connection對(duì)象參數(shù)來動(dòng)態(tài)創(chuàng)建session，也可以根據(jù)初始化時(shí)從hibernate.cfg.xml文件中讀入的信息來默認(rèn)創(chuàng)建并返回

  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個(gè)需要注意的地方：
 A.Session必須由SessionHandler來獲取，如果使用第一種構(gòu)造方法此時(shí)調(diào)用會(huì)出錯(cuò)
 B.Session只能在Transaction開始時(shí)才打開，在構(gòu)造函數(shù)執(zhí)行時(shí)依然是null的，避免浪費(fèi)資源

結(jié)束事務(wù)

    /** *//**
     * 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);
        }
    }

這個(gè)方法我有一個(gè)不懂的地方：為什么是commit在先，再flush的？這個(gè)需要再和作者探討。

ChannelBuilder允許我們重設(shè)事務(wù)，即提交現(xiàn)有事務(wù)并刷新緩存，之后注銷transaction和session。這一點(diǎn)我認(rèn)為適合于在一個(gè)“長事務(wù)”的過程中，切換到不同的事務(wù)上下文環(huán)境。

重置事務(wù)

    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中提供了三個(gè)持久化的方法，分別用于持久化各種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");
        }
    }

請(qǐng)注意這里：如果采用構(gòu)造方法一，那么你將需要在執(zhí)行這些方法后手動(dòng)提交事務(wù)。如果你認(rèn)為你的操作不需要事務(wù)那么當(dāng)然可以不用。

★創(chuàng)建channel object

在ChannelBuilder里面，數(shù)量最多的方法就是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對(duì)channel object的創(chuàng)建原則就是：
 A.如果能夠從持久層中找到對(duì)應(yīng)的記錄，那么從持久層返回
 B.如果找不到，則創(chuàng)建它并持久化它，然后返回該對(duì)象(已持久化)

只要記得的一點(diǎn)就是：從ChannelBuilder返回的對(duì)象都是已經(jīng)持久化的。比如channel，此時(shí)我們甚至可以通過channel.getItems()來獲得其下屬的各個(gè)news item。