提前关闭open session in view 模式下的数据库连接 open session in view

背景：

   open session in  view为 懒加载提供了在控制层或者freemarker页面动态访问迟加载数据的功能。但缺点也是显而易见的，那就是 要将页面全部写到浏览器后，数据库连接才能关闭，这对数据库这样的稀缺资源来说，是不可忍受的。那么能否在freemarker等view层获取完毕迟加载的数据后，立即关闭数据库连接呢？

 

方案：

    freemarker模板空写一遍后，模板里的参数已经加载好，提前关闭session。

具体步骤：

    1)将struts-plugin.xml里面ftl的类 改为 ：
<bean type="com.skyon.webframe.core.struts2.ResultProxy" name="ftl" class="com.skyon.opensessioniv.FreemarkerResultProxy" />
 这个新的 FreemarkerResultProxy返回新的Result，Result将模板空写一遍：

 

						nullWrite(template, model);
						template.process(model, parentCharArrayWriter);

 然后关闭连接： 

 

	// 空写一遍模板,并提前关闭OpenSessionInViewAnyCloseFilter的session。这样模板里面的参数将被访问一遍以确保里面的参数可用。
	private void nullWrite(Template template, TemplateModel model) throws TemplateException, IOException {

		template.process(model, NullWriter.NULL_WRITER);
		LOG.debug("nullWrite template ok.");
		OpenSessionInViewAnyCloseFilter instance = OpenSessionInViewAnyCloseFilter.getInstance();
		if(instance!=null && instance.isInFilter()) {
			instance.closeSession();
			LOG.debug("OpenSessionInViewAnyCloseFilter.close() ok.");
		}else {
			LOG.debug("OpenSessionInViewAnyCloseFilter.instance is null.");
		}
	}

 

 

 

2）将web.xml的filter部分改为：
 

<filter>
   <filter-name>opensession</filter-name>
   <filter-class>com.skyon.opensessioniv.OpenSessionInViewAnyCloseFilter</filter-class>
   <init-param>
    <param-name>singleSession</param-name>
    <param-value>false</param-value>
   </init-param> 
  </filter>   
  <filter>
      其他filter
  </filter>
  
  <filter-mapping>
   <filter-name>opensession</filter-name>
   <url-pattern>/params/*</url-pattern>
  </filter-mapping>
  <!-- opensession的多个url-pattern 写多个<filter-mapping> -->
  <!-- <filter-mapping>
   <filter-name>opensession</filter-name>
   <url-pattern>/params/dict/*</url-pattern>
  </filter-mapping> -->

  

  注意：1）opensessioninview 一定要放在最前面
             2）要加 url-pattern，否则每次请求（比如js，图片请求）都要开关session。
 而这个新的 opensessioninview filer，提供了提前关闭数据库连接的方法 closeSession()：

/*
 * Copyright 2002-2009 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.skyon.opensessioniv;

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;

/**
 * Servlet 2.3 Filter that binds a Hibernate Session to the thread for the
 * entire processing of the request. Intended for the "Open Session in View"
 * pattern, i.e. to allow for lazy loading in web views despite the original
 * transactions already being completed.
 *
 * <p>
 * This filter makes Hibernate Sessions available via the current thread, which
 * will be autodetected by transaction managers. It is suitable for service
 * layer transactions via
 * {@link org.springframework.orm.hibernate3.HibernateTransactionManager} or
 * {@link org.springframework.transaction.jta.JtaTransactionManager} as well as
 * for non-transactional execution (if configured appropriately).
 *
 * <p>
 * <b>NOTE</b>: This filter will by default <i>not</i> flush the Hibernate
 * Session, with the flush mode set to <code>FlushMode.NEVER</code>. It assumes
 * to be used in combination with service layer transactions that care for the
 * flushing: The active transaction manager will temporarily change the flush
 * mode to <code>FlushMode.AUTO</code> during a read-write transaction, with the
 * flush mode reset to <code>FlushMode.NEVER</code> at the end of each
 * transaction. If you intend to use this filter without transactions, consider
 * changing the default flush mode (through the "flushMode" property).
 *
 * <p>
 * <b>WARNING:</b> Applying this filter to existing logic can cause issues that
 * have not appeared before, through the use of a single Hibernate Session for
 * the processing of an entire request. In particular, the reassociation of
 * persistent objects with a Hibernate Session has to occur at the very
 * beginning of request processing, to avoid *es with already loaded
 * instances of the same objects.
 *
 * <p>
 * Alternatively, turn this filter into deferred close mode, by specifying
 * "singleSession"="false": It will not use a single session per request then,
 * but rather let each data access operation or transaction 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.
 *
 * <p>
 * A single session per request allows for most efficient first-level caching,
 * but can cause side effects, for example on <code>saveOrUpdate</code> or when
 * continuing after a rolled-back transaction. The deferred close strategy is as
 * safe as no Open Session in View in that respect, while still allowing for
 * lazy loading in views (but not providing a first-level cache for the entire
 * request).
 *
 * <p>
 * Looks up the SessionFactory in Spring's root web application context.
 * Supports a "sessionFactoryBeanName" filter init-param in
 * <code>web.xml</code>; the default bean name is "sessionFactory". Looks up the
 * SessionFactory on each request, to avoid initialization order issues (when
 * using ContextLoaderServlet, the root application context will get initialized
 * <i>after</i> this filter).
 * <p>
 * 在原来基础上，加了 提前关闭session的功能。比如在使用模板情况下，模板参数已经准备好，还整个页面没向浏览器输出的时候，关闭session。
 * 
 * @author Juergen Hoeller
 * @author xinglj
 * 
 * @since 1.2
 * @see #setSingleSession
 * @see #setFlushMode
 * @see #lookupSessionFactory
 * @see OpenSessionInViewInterceptor
 * @see org.springframework.orm.hibernate3.HibernateInterceptor
 * @see org.springframework.orm.hibernate3.HibernateTransactionManager
 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession
 * @see org.springframework.transaction.support.TransactionSynchronizationManager
 */
public class OpenSessionInViewAnyCloseFilter 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;

	private static OpenSessionInViewAnyCloseFilter instance;

	public static OpenSessionInViewAnyCloseFilter getInstance() {
		if (instance == null)
			throw new RuntimeException("it's null,pls call it later!");
		else
			return instance;
	}

	// 是否经过了此filter。处理外部主动调用close session，但并没有session的情况。
	private ThreadLocal<Boolean> inFilter = new ThreadLocal<Boolean>() {
		protected Boolean initialValue() {
			return Boolean.FALSE;
		}
	};

	// session是否已经关闭。防止重复关闭
	private ThreadLocal<Boolean> sessionClosed = new ThreadLocal<Boolean>() {
		protected Boolean initialValue() {
			return Boolean.FALSE;
		}
	};

	public OpenSessionInViewAnyCloseFilter() {
		if (instance != null)
			throw new RuntimeException("pls new it only once!");
		else {
			instance = this;
		}
	}

	/**
	 * Set the bean name of the SessionFactory to fetch from Spring's root
	 * application context. Default is "sessionFactory".
	 * 
	 * @see #DEFAULT_SESSION_FACTORY_BEAN_NAME
	 */
	public void setSessionFactoryBeanName(String sessionFactoryBeanName) {
		this.sessionFactoryBeanName = sessionFactoryBeanName;
	}

	/**
	 * Return the bean name of the SessionFactory to fetch from Spring's root
	 * application context.
	 */
	protected String getSessionFactoryBeanName() {
		return this.sessionFactoryBeanName;
	}

	/**
	 * Set whether to use a single session for each request. Default is "true".
	 * <p>
	 * 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.
	 * 
	 * @see SessionFactoryUtils#initDeferredClose
	 * @see SessionFactoryUtils#processDeferredClose
	 */
	public void setSingleSession(boolean singleSession) {
		this.singleSession = singleSession;
	}

	/**
	 * Return whether to use a single session for each request.
	 */
	protected boolean isSingleSession() {
		return this.singleSession;
	}

	/**
	 * Specify the Hibernate FlushMode to apply to this filter's
	 * {@link org.hibernate.Session}. Only applied in single session mode.
	 * <p>
	 * Can be populated with the corresponding constant name in XML bean
	 * definitions: e.g. "AUTO".
	 * <p>
	 * The default is "MANUAL". Specify "AUTO" if you intend to use this filter
	 * without service layer transactions.
	 * 
	 * @see org.hibernate.Session#setFlushMode
	 * @see org.hibernate.FlushMode#MANUAL
	 * @see org.hibernate.FlushMode#AUTO
	 */
	public void setFlushMode(FlushMode flushMode) {
		this.flushMode = flushMode;
	}

	/**
	 * Return the Hibernate FlushMode that this filter applies to its
	 * {@link org.hibernate.Session} (in single session mode).
	 */
	protected FlushMode getFlushMode() {
		return this.flushMode;
	}

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

		inFilter.set(Boolean.TRUE);
		sessionClosed.set(Boolean.FALSE);
		
		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 &&!sessionClosed.get()) {
				closeSessionIfNeccesary(sessionFactory);
			}
		}
	}
	/**
	 * 是否经过了此filter
	 * @return
	 */
	public Boolean isInFilter() {
		return inFilter.get();
	}
	/**
	 * close thread-bound session
	 */
	public void closeSession() {
		
			closeSessionIfNeccesary(lookupSessionFactory());
	}

	private void closeSessionIfNeccesary(SessionFactory sessionFactory) {
		if (!sessionClosed.get()) {
			logger.debug("close session...");
			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);
			}
			sessionClosed.set(Boolean.TRUE);
		} else {
			logger.debug("has closed session,do nothing.");
		}
	}

	/**
	 * Look up the SessionFactory that this filter should use, taking the current
	 * HTTP request as argument.
	 * <p>
	 * The default implementation delegates to the {@link #lookupSessionFactory()}
	 * variant without arguments.
	 * 
	 * @param request
	 *            the current request
	 * @return the SessionFactory to use
	 */
	protected SessionFactory lookupSessionFactory(HttpServletRequest request) {
		return lookupSessionFactory();
	}

	/**
	 * Look up the SessionFactory that this filter should use.
	 * <p>
	 * The default implementation looks for a bean with the specified name in
	 * Spring's root application context.
	 * 
	 * @return the SessionFactory to use
	 * @see #getSessionFactoryBeanName
	 */
	protected SessionFactory lookupSessionFactory() {
		if (logger.isDebugEnabled()) {
			logger.debug("Using SessionFactory '" + getSessionFactoryBeanName() + "' for OpenSessionInViewFilter");
		}
		WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
		return wac.getBean(getSessionFactoryBeanName(), SessionFactory.class);
	}

	/**
	 * Get a Session for the SessionFactory that this filter uses. Note that this
	 * just applies in single session mode!
	 * <p>
	 * The default implementation delegates to the
	 * <code>SessionFactoryUtils.getSession</code> method and sets the
	 * <code>Session</code>'s flush mode to "MANUAL".
	 * <p>
	 * Can be overridden in subclasses for creating a Session with a custom entity
	 * interceptor or JDBC exception translator.
	 * 
	 * @param sessionFactory
	 *            the SessionFactory that this filter uses
	 * @return the Session to use
	 * @throws DataAccessResourceFailureException
	 *             if the Session could not be created
	 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession(SessionFactory,
	 *      boolean)
	 * @see org.hibernate.FlushMode#MANUAL
	 */
	protected Session getSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
		Session session = SessionFactoryUtils.getSession(sessionFactory, true);
		FlushMode flushMode = getFlushMode();
		if (flushMode != null) {
			session.setFlushMode(flushMode);
		}
		return session;
	}

	/**
	 * Close the given Session. Note that this just applies in single session mode!
	 * <p>
	 * 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.
	 * 
	 * @param session
	 *            the Session used for filtering
	 * @param sessionFactory
	 *            the SessionFactory that this filter uses
	 */
	protected void closeSession(Session session, SessionFactory sessionFactory) {
		SessionFactoryUtils.closeSession(session);
	}

}