//фильтр
public class HibernateFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("Servlet Фильтр init, теперь Сеанс открытия/закрытия для каждого реквеста.");
    }
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        // получит текущую сессию.
        try {
            chain.doFilter(request, response);
            HibernateSessionController.commitTransaction();// Завершить любые транзакции, если открыты
        } catch (SessionManagementException sme) {
             log.error(sme);
        } finally { // закрыть по любому
            try {
                HibernateSessionController.closeSession();
            } catch (SessionManagementException sme) {
                 log.error(sme);
            }
        }
    }
    public void destroy() {}
}

//менеджер-класс:
public class HibernateSessionController {
    private static Log logger = LogFactory.getLog(HibernateSessionController.class);
    private static Configuration configuration;
    private static SessionFactory sessionFactory;
    private static final ThreadLocal threadSession = new ThreadLocal();
    private static final ThreadLocal threadTransaction = new ThreadLocal();
    private static final ThreadLocal threadInterceptor = new ThreadLocal();
    // создать Default SessionFactory 
    static {
        try {
            configuration = new Configuration();
            sessionFactory = configuration.configure().buildSessionFactory();
        } catch (Throwable ex) {
            logger.error("Building SessionFactory failed.", ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
    /**
     * 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 InfrastructureException(ex);
        }
        return sessions;
        */
        return sessionFactory;
    }

    /**
     * Returns the original Hibernate configuration.
     *
     * @return Configuration
     */
    public static Configuration getConfiguration() {
        return configuration;
    }

    /**
     * Rebuild the SessionFactory with the static Configuration.
     *
     */
     public static void rebuildSessionFactory()
        throws SessionManagementException {
        synchronized(sessionFactory) {
            try {
                sessionFactory = getConfiguration().buildSessionFactory();
            } catch (Exception ex) {
                throw new SessionManagementException(ex);
            }
        }
     }

    /**
     * Rebuild the SessionFactory with the given Hibernate Configuration.
     *
     * @param cfg
     */
     public static void rebuildSessionFactory(Configuration cfg)
        throws SessionManagementException {
        synchronized(sessionFactory) {
            try {
                sessionFactory = cfg.buildSessionFactory();
                configuration = cfg;
            } catch (Exception ex) {
                throw new SessionManagementException(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 getCurrentSession()
        throws SessionManagementException {
        Session s = (Session) threadSession.get();
        try {
            if (s == null) {
                logger.debug("Opening new Session for this thread.");
                if (getInterceptor() != null) {
                    if (logger.isDebugEnabled())
                        logger.debug("Using interceptor: " + getInterceptor().getClass());
                    s = getSessionFactory().openSession(getInterceptor());
                } else {
                    s = getSessionFactory().openSession();
                }
                threadSession.set(s);
            }
        } catch (HibernateException ex) {
            throw new SessionManagementException(ex);
        }
        return s;
    }

    /**
     * Closes the Session local to the thread.
     */
    public static void closeSession()
        throws SessionManagementException {
        try {
            Session s = (Session) threadSession.get();
            threadSession.set(null);
            if (s != null && s.isOpen()) {
                if (logger.isDebugEnabled())
                    logger.debug("Closing Session of this thread.");
                s.close();
            }
        } catch (HibernateException ex) {
            throw new SessionManagementException(ex);
        }
    }
}