package com.cascadetg.ch12;

import java.util.Iterator;

public class IoCExample
{

    public static void main(String[] args)
    {
        // Need one global configuration
        HibernateSessionWrapper.initialization();

        // Create our task as an anonymous inner class.
        // Note, no exception handling needed, implicit
        // availability of a session.
        HibernateSessionWrapper myTask = new
        HibernateSessionWrapper()
        {

            Object task(Object in) throws Exception
            {
                net.sf.hibernate.Query myQuery = session
                        .createQuery((String) in);

                Iterator result = myQuery.list().iterator();

                session.flush();
                return result;
            }
        };

        // Execute a bit of HQL and get the results
        Iterator result = (Iterator) myTask
                .perform("from Author");
        while (result.hasNext())
        {
            System.out.println(result.next().toString());
            System.out.flush();
        }

        // Create our task as an anonymous inner class.
        // Note, no exception handling needed, implicit
        // availability of a session.
        HibernateSessionWrapper myTask2 = new
        HibernateSessionWrapper()
        {

            Object task(Object in) throws Exception
            {
                throw new Exception();
            }
        };

        // Do the task.
        if (myTask2.perform() == null)
                System.out.println(myTask2.getException());
    }
}

package com.cascadetg.ch12;

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;

public abstract class HibernateSessionWrapper
{

    /** This method must be overridden to actually do anything
    */
    abstract Object task(Object in) throws Exception;

    Session session = null;

    Transaction transaction = null;

    boolean stale = false;

    Exception problem = null;
    /**
     * Used to identify that a stale object was encountered as
     * part of the transaction.
     */
    public boolean isStaleOperation()
    {
        return stale;
    }

    public Exception getException()
    {
        return problem;
    }

    /** We use this session factory to create our sessions */
    public static SessionFactory sessionFactory;

    /**
     * Loads the Hibernate configuration information, sets up the
     * database and the Hibernate session factory.
     *
     * Should be customized for your application.
     */
    public static void initialization()
    {
        try
        {
            Configuration myConfiguration = new
                 Configuration();
            myConfiguration
                    .addClass(com.cascadetg.ch02.Post.class);
            myConfiguration
                    .addClass(com.cascadetg.ch02.Author.class);

            // Sets up the session factory (used in the rest
            // of the application).
            sessionFactory = myConfiguration
                    .buildSessionFactory();
        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public Object perform()
    {
        return perform(null);
    }

    /**
     * Actually does the set-up for the session, as well as
     * execute the task. Handles all of the exceptions (you may
     * wish to customize this per your login preference)
     */
    public Object perform(Object in)
    {
        Object result = null;
        try
        {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            result = task(in);

            transaction.commit();

        } catch (StaleObjectStateException staleException)
        {
            stale = true;
            try
            {
                transaction.rollback();
            } catch (Exception e2)
            {
                e2.printStackTrace();
            }
        } catch (Exception e)
        {
            result = null;
            problem = e;
            e.printStackTrace();
            try
            {
                transaction.rollback();
            } catch (Exception e2)
            {
                // Notify of a failure to roll the transaction
                // back
                e.printStackTrace();
            }
        } finally
        {
            try
            {
                if (session != null) session.close();
            } catch (Exception e)
            {
                // Silent failure of session close
            }
        }
        return result;
    }
}

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;

public class HibernateUtil {

    private static final SessionFactory sessionFactory;

    static {
        try {
            sessionFactory =
                  new Configuration().configure()
                         .buildSessionFactory();
        } catch (HibernateException ex) {
            throw new RuntimeException(
                  "Exception building SessionFactory: "
                        + ex.getMessage(), ex);
        }
    }

    public static final java.lang.ThreadLocal
      session = new java.lang. ThreadLocal();

    public static Session currentSession() throws
    HibernateException {
        Session s = (Session) session.get();
        // Open a new Session, if this Thread has none yet
        if (s == null) {
            s = sessionFactory.openSession();
            session.set(s);
        }
        return s;
    }

    public static void discardSession() throws
    HibernateException {
        Session s = (Session) session.get();
        session.set(null);
        if (s != null)
            s.close();
    }
}