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

Close the given Session. Note that this just applies in single session mode!

Can be overridden in subclasses, e.g. for flushing the Session before closing it. See class-level javadoc for a discussion of flush handling. Note that you should also override getSession accordingly, to set the flush mode to something else than NEVER.

 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 FlushMode getFlushMode() 
{
		return this.flushMode;
}

Return the Hibernate FlushMode that this filter applies to its org.hibernate.Session (in single session mode).

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

Get a Session for the SessionFactory that this filter uses. Note that this just applies in single session mode!

The default implementation delegates to the SessionFactoryUtils.getSession method and sets the Session's flush mode to "MANUAL".

Can be overridden in subclasses for creating a Session with a custom entity interceptor or JDBC exception translator.

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

Return the bean name of the SessionFactory to fetch from Spring's root application context.

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

Return whether to use a single session for each request.

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

Look up the SessionFactory that this filter should use.

The default implementation looks for a bean with the specified name in Spring's root application context.

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

Look up the SessionFactory that this filter should use, taking the current HTTP request as argument.

The default implementation delegates to the #lookupSessionFactory() variant without arguments.

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

Specify the Hibernate FlushMode to apply to this filter's org.hibernate.Session . Only applied in single session mode.

Can be populated with the corresponding constant name in XML bean definitions: e.g. "AUTO".

The default is "MANUAL". Specify "AUTO" if you intend to use this filter without service layer transactions.

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

Set the bean name of the SessionFactory to fetch from Spring's root application context. Default is "sessionFactory".

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

Set whether to use a single session for each request. Default is "true".

If set to "false", each data access operation or transaction will use its own session (like without Open Session in View). Each of those sessions will be registered for deferred close, though, actually processed at request completion.