Spring对HibernateSession的管理之OpenSessionInViewFilter

　　由于Java EE的学习进入到了一个重要的阶段——开始学习SSH框架（Struts2+Spring+Hibernate）了，在初步认识了框架的整合后，我对Spring是如何管理Session（Hibernate）抱有一些疑问。在进行了一些研究后有一些心得，在此记录下来，以便自己日后查询和供后来者作为借鉴。

　　进入正题：

　　首先我们打开org.springframework.orm.hibernate3.support.OpenSessionInViewFilter，看不出什么什么门道，连过滤器的doFilter方法都没有。很明显，它会调用父类的doFilter方法，而我们正是需要研究Spring是怎样通过过滤器来实现Session有效期的延长的（注意：Spring默认将Session与Request进程绑定，Request生命周期即Session能够存在的时长，所以在处理器处理请求后向JSP页面跳转时Session随着Request的生命周期而失效，以致页面无法使用Session）。

　　那么我们马上进入OpenSessionInViewFilter的父类org.springframework.web.filter.OncePerRequestFilter看看（省略注释）：

public abstract class OncePerRequestFilter extends GenericFilterBean {

    public static final String ALREADY_FILTERED_SUFFIX = ".FILTERED";

    public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {
            throw new ServletException("OncePerRequestFilter just supports HTTP requests");
        }
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
        if (request.getAttribute(alreadyFilteredAttributeName) != null || shouldNotFilter(httpRequest)) {
            filterChain.doFilter(request, response);
        }
        else {
            request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
            try {
                doFilterInternal(httpRequest, httpResponse, filterChain);
            }
            finally {
                request.removeAttribute(alreadyFilteredAttributeName);
            }
        }
    }

    protected String getAlreadyFilteredAttributeName() {
        String name = getFilterName();
        if (name == null) {
            name = getClass().getName();
        }
        return name + ALREADY_FILTERED_SUFFIX;
    }

    protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
        return false;
    }

    protected abstract void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException;

}

　　从上面代码的15行到21行左右大家可以看出：这个方法进行了一个判断，看是否需要延长Session存在时间到整个请求响应过程，而实现延长时间的方法就是OpenSessionInViewFilter重写了的方法（省略部分注释）：

package org.springframework.orm.hibernate3.support;

import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
import org.springframework.orm.hibernate3.SessionHolder;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.filter.OncePerRequestFilter;

public class OpenSessionInViewFilter extends OncePerRequestFilter {

    public static final String DEFAULT_SESSION_FACTORY_BEAN_NAME = "sessionFactory";


    private String sessionFactoryBeanName = DEFAULT_SESSION_FACTORY_BEAN_NAME;

    private boolean singleSession = true;

    private FlushMode flushMode = FlushMode.MANUAL;

    public void setSessionFactoryBeanName(String sessionFactoryBeanName) {
        this.sessionFactoryBeanName = sessionFactoryBeanName;
    }

    protected String getSessionFactoryBeanName() {
        return this.sessionFactoryBeanName;
    }

    public void setSingleSession(boolean singleSession) {
        this.singleSession = singleSession;
    }

    protected boolean isSingleSession() {
        return this.singleSession;
    }

    public void setFlushMode(FlushMode flushMode) {
        this.flushMode = flushMode;
    }

    protected FlushMode getFlushMode() {
        return this.flushMode;
    }


    @Override
    protected void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        SessionFactory sessionFactory = lookupSessionFactory(request);
        boolean participate = false;

        if (isSingleSession()) {
            // single session mode
            if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
                // Do not modify the Session: just set the participate flag.
                participate = true;
            }
            else {
                logger.debug("Opening single Hibernate Session in OpenSessionInViewFilter");
                Session session = getSession(sessionFactory);
                TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
            }
        }
        else {
            // deferred close mode
            if (SessionFactoryUtils.isDeferredCloseActive(sessionFactory)) {
                // Do not modify deferred close: just set the participate flag.
                participate = true;
            }
            else {
                SessionFactoryUtils.initDeferredClose(sessionFactory);
            }
        }

        try {
            filterChain.doFilter(request, response);
        }

        finally {
            if (!participate) {
                if (isSingleSession()) {
                    // single session mode
                    SessionHolder sessionHolder =
                            (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
                    logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
                    closeSession(sessionHolder.getSession(), sessionFactory);
                }
                else {
                    // deferred close mode
                    SessionFactoryUtils.processDeferredClose(sessionFactory);
                }
            }
        }
    }

    protected SessionFactory lookupSessionFactory(HttpServletRequest request) {
        return lookupSessionFactory();
    }

    protected SessionFactory lookupSessionFactory() {
        if (logger.isDebugEnabled()) {
            logger.debug("Using SessionFactory '" + getSessionFactoryBeanName() + "' for OpenSessionInViewFilter");
        }
        WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
        return wac.getBean(getSessionFactoryBeanName(), SessionFactory.class);
    }

    protected Session getSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
        Session session = SessionFactoryUtils.getSession(sessionFactory, true);
        FlushMode flushMode = getFlushMode();
        if (flushMode != null) {
            session.setFlushMode(flushMode);
        }
        return session;
    }

    protected void closeSession(Session session, SessionFactory sessionFactory) {
        SessionFactoryUtils.closeSession(session);
    }

}

　　这里面org.springframework.orm.hibernate3.SessionFactoryUtils拥有很重要的地位，其重要一个字段如下：

　　　　ThreadLocal<Map<SessionFactory, Set<Session>>> deferredCloseHolder =
   new NamedThreadLocal<Map<SessionFactory, Set<Session>>>("Hibernate Sessions registered for deferred close")

　　另外org.springframework.transaction.support.TransactionSynchronizationManager也是很为重要：

　　　　ThreadLocal<Map<Object, Object>> resources =
   new NamedThreadLocal<Map<Object, Object>>("Transactional resources") 及其他属性和方法与上面SessionFactoryUtils中的属性和方法一起，在OpenSessionInViewFilter#doFilterInternal方法中将Session绑定到ThreadLocal，在整个请求响应过程完成后关闭Session。

　　

　　也就是说：原本Spring是将Session绑定到Request所在线程里，而使用了OpenSessionInViewFilter过滤器后，会将Session绑定到当前进程中。

　　

　　也是最近越来越烦躁，总是不能将整篇博文做到完整，本文章中的所有内容都可以在网络上搜索得到，扩展的知识却没来得及添加进来。

　　另外，本篇博文所用资源src.zip。

　

 欢迎您移步我们的交流群，无聊的时候大家一起打发时间：

 或者通过QQ与我联系：

 （最后编辑时间2012-10-09 22:59:36）