public class HibernateFilter
      implements
      Filter {

   private static Log log = LogFactory.getLog(HibernateFilter.class);

   public void destroy() {}

   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
         throws IOException,
         ServletException {
      try {
         // We don't start the database transaction here, but when first needed
         chain.doFilter(request, response);

         // Commit any pending database transaction.
         HibernateUtil.commitTransaction();
      }
      finally {
         // No matter what happens, close the Session.
         HibernateUtil.closeSession();
      }
   }

   public void init(FilterConfig filterConfig) throws ServletException {
      log.info("Servlet filter init, now opening/closing a Session for each request.");
   }

}

public class HibernateUtil {

   private static Configuration configuration;

   private static Log log = LogFactory.getLog(HibernateUtil.class);
   private static SessionFactory sessionFactory;
   private static final ThreadLocal threadSession = new ThreadLocal();
   private static final ThreadLocal threadTransaction = new ThreadLocal();

   // Create the initial SessionFactory from the default configuration files
   static {
      try {
         configuration = new Configuration().configure();
         configuration.addResource("wiki/model/WikiPage.hbm.xml");
         sessionFactory = configuration.buildSessionFactory();
      }
      catch (Throwable ex) {
         // We have to catch Throwable, otherwise we will miss
         // NoClassDefFoundError and other subclasses of Error
         log.error("Building SessionFactory failed.", ex);
         throw new ExceptionInInitializerError(ex);
      }
   }

   /**
    * Start a new database transaction.
    */
   public static void beginTransaction() {
      // Would be written as a no-op in an EJB container with CMT
      Transaction tx = (Transaction) threadTransaction.get();
      if (tx == null) {
         log.debug("Starting new database transaction in this thread.");
         tx = getSession().beginTransaction();
         threadTransaction.set(tx);
      }
   }

   /**
    * Closes the Session local to the thread.
    */
   public static void closeSession() {
      // Would be written as a no-op in an EJB container with CMT
      Session s = (Session) threadSession.get();
      threadSession.set(null);
      if (s != null && s.isOpen()) {
         log.debug("Closing Session of this thread.");
         s.close();
      }
   }

   /**
    * Commit the database transaction.
    */
   public static void commitTransaction() {
      // Would be written as a no-op in an EJB container with CMT
      Transaction tx = (Transaction) threadTransaction.get();
      try {
         if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
            log.debug("Committing database transaction of this thread.");
            tx.commit();
         }
         threadTransaction.set(null);
      }
      catch (HibernateException ex) {
         rollbackTransaction();
         throw ex;
      }
   }

   /**
    * Retrieves the current Session local to the thread. <p/> If no Session is
    * open, opens a new Session for the running thread.
    *
    * @return Session
    */
   public static Session getSession() {
      // With CMT, this should return getSessionFactory().getCurrentSession()
      // and do nothing else
      Session s = (Session) threadSession.get();
      if (s == null) {
         log.debug("Opening new Session for this thread.");
         s = getSessionFactory().openSession();
         threadSession.set(s);
      }
      return s;
   }

   /**
    * Returns the SessionFactory used for this static class.
    *
    * @return SessionFactory
    */
   public static SessionFactory getSessionFactory() {
      /*
       * Instead of a static variable, use JNDI: SessionFactory sessions =
       * null; try { Context ctx = new InitialContext(); String jndiName =
       * "java:hibernate/HibernateFactory"; sessions =
       * (SessionFactory)ctx.lookup(jndiName); } catch (NamingException ex) {
       * throw new RuntimeException(ex); } return sessions;
       */
      return sessionFactory;
   }

   /**
    * Rollback the database transaction.
    */
   public static void rollbackTransaction() {
      // Would be written as a no-op in an EJB container with CMT (maybe
      // setRollBackOnly...)
      Transaction tx = (Transaction) threadTransaction.get();
      try {
         threadTransaction.set(null);
         if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
            log.debug("Tyring to rollback database transaction of this thread.");
            tx.rollback();
         }
      }
      finally {
         closeSession();
      }
   }

}

   public WikiPage editPage(WikiPage page) throws DAOException {
      log.debug("entered editPage "
            + "\nid: " + page.getId()
            + "\nname: " + page.getName()
            + "\ncontents: " + page.getContents()
            + "\ncreated: " + page.getDateCreated()
            + "\nmodified: " + page.getDateModified());
      try {
         HibernateUtil.getSession().lock(page, LockMode.NONE);
         HibernateUtil.getSession().update(page);
         return page;
      }
      catch (HibernateException e) {
         String msg = "The DAO could not update page.";
         log.error(msg, e);
         throw new DAOException(msg, e);
      }
   }

log.debug("starting a transaction");
HibernateUtil.beginTransaction();
wikiPage.setDateModified(new Date());
wdao.editPage(wikiPage);