try {
     BufferedReader in = new BufferedReader(
        new FileReader(path));
     String line;
     while((line = in.readLine()) != null){
       System.out.println(line);
     }
     in.close();
    }catch(IOException e){
      System.err.println("Exception reading");
    }

new File(path).eachLine{ line ->
     println line
}

public static boolean isBlank(String str) {
 int strLen;
 if (str == null || (strLen = str.length()) == 0) {
  return true;
 }
 for (int i = 0; i < strLen; i++) {
  if ((Character.isWhitespace(str.charAt(i)) == false)) {
   return false;
  }
 }
 return true;
}

class String
 def blank?
  empty? || strip.empty?
 end
end

{Integer,Integer=>Integer} plus1 = {Integer x, Integer y => x+y};

plus1 = { x, y -> x+y }

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

<config>
<TCP_NIO
        bind_addr="localhost"
            start_port="7800"
            loopback="true"
            recv_buf_size="20000000"
            send_buf_size="640000"
            discard_incompatible_packets="true"
            max_bundle_size="64000"
            max_bundle_timeout="30"
            use_incoming_packet_handler="true"
            enable_bundling="true"
            use_send_queues="false"
            sock_conn_timeout="300"
            skip_suspected_members="true"
            use_concurrent_stack="true"

            thread_pool.enabled="true"
            thread_pool.min_threads="1"
            thread_pool.max_threads="25"
            thread_pool.keep_alive_time="5000"
            thread_pool.queue_enabled="false"
            thread_pool.queue_max_size="100"
            thread_pool.rejection_policy="Run"

            oob_thread_pool.enabled="true"
            oob_thread_pool.min_threads="1"
            oob_thread_pool.max_threads="8"
            oob_thread_pool.keep_alive_time="5000"
            oob_thread_pool.queue_enabled="false"
            oob_thread_pool.queue_max_size="100"
            oob_thread_pool.rejection_policy="Run"

            reader_threads="3"
            writer_threads="3"
            processor_threads="0"
            processor_minThreads="0"
            processor_maxThreads="0"
            processor_queueSize="100"
            processor_keepAliveTime="9223372036854775807"/>
    <TCPPING timeout="3000"
             initial_hosts="${jgroups.tcpping.initial_hosts:localhost[7800],localhost[7801]}"
             port_range="1"
             num_initial_members="3"/>
    <MERGE2 max_interval="100000"
              min_interval="20000"/>
    <FD_SOCK/>
    <FD timeout="10000" max_tries="5"   shun="true"/>
    <VERIFY_SUSPECT timeout="1500"  />
    <pbcast.NAKACK
                   use_mcast_xmit="false" gc_lag="0"
                   retransmit_timeout="300,600,1200,2400,4800"
                   discard_delivered_msgs="true"/>
    <pbcast.STABLE stability_delay="1000" desired_avg_gossip="50000"
                   max_bytes="400000"/>
    <VIEW_SYNC avg_send_interval="60000"/>
    <pbcast.GMS print_local_addr="true" join_timeout="3000"
                shun="true"
                view_bundling="true"/>
    <FC max_credits="2000000"
        min_threshold="0.10"/>
    <FRAG2 frag_size="60000"  />
    <pbcast.STREAMING_STATE_TRANSFER/>
</config>

<TCPPING timeout="3000"
             initial_hosts="${jgroups.tcpping.initial_hosts: 192.168.1.1 [7800], 192.168.1.2 [7800], 192.168.1.3 [7800], 192.168.1.4 [7800]}"
             port_range="1"
             num_initial_members="4"/>

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

【本文如需转载，请注明作者及出处】

I think a lot of people have misunderstanding about DBCP. What makes them think so?
Cause' DBCP seems don't want to release database connection after use. Finally, all available connections got exhausted, and our application runs out of services.

DBCP is weak and can not bear production pressures, according to them. It’s worse that there are a lot of guys on the internet said so.


In fact, DBCP can absolutely take the job!

Firstly, its release number has reached 1.2.2. Base on the Apache Version Numbering Project's theory, any products whose version number has evolved up to 1, it is eligible to be used in production environment.

Second, I've run into such problem from my previous working experience, and my ex-colleague and I have made extensive tests on various Connection Pool products, such as Proxool, c3p0 and DBCP.
Result shows that DBCP behaves very well not only at responsiveness, stability, but also at performance. Once the network resume, it auto-reconnects instantly even after more than 8 hours network disconnection.


Third, I do the test again, but this time it’s only between DBCP and c3p0. The test starts from running 3000 to 5000 threads, which infinitely execute a query lasting at least 1 second. Effort have been made to let DBCP and C3p0 start equally, like the same initial pool size 0, the same max pool size and the same time out, etc.

Finally, I try to give you a detail introduction on the configurations of DBCP, focusing on the important parameters.

 All information comes from http://commons.apache.org/dbcp/configuration.html



Part1, Besides the Normal parameters:

username                           The connection username to be passed to our JDBC driver to establish a connection.

password                           The connection password to be passed to our JDBC driver to establish a connection.

url                                       The connection URL to be passed to our JDBC driver to establish a connection.

driverClassName                The fully qualified Java class name of the JDBC driver to be used.


Part2, the following are related to performances:

initialSize                            The initial number of connections that are created when the pool is started.

maxActive                           The maximum number of active connections that can be allocated from this pool at the same time, or non-positive for no limit.

maxIdle                              The maximum number of connections that can remain idle in the pool, without extra ones being released, or negative for no limit.

minIdle                               The minimum number of connections that can remain idle in the pool, without extra ones being created, or zero to create none.

maxWait                             The maximum number of milliseconds that the pool will wait (when there are no available connections) for a connection to be returned before throwing an exception, or -1 to wait indefinitely.

poolPreparedStatements    Enable prepared statement pooling for this pool.

maxOpenPreparedStatements  The maximum number of open statements that can be allocated from the statement pool at the same time, or zero for no limit.



Part3, but setting the above parameters or combining only some of the them won’t help you get rid of exhaustion of connection problem due to poorly written code, maybe that's source of problems. The following configuration matters:


validationQuery                        The SQL query that will be used to validate connections from this pool before returning them to the caller. If specified, this query MUST be an SQL SELECT statement that returns at least one row.


timeBetweenEvictionRunsMillis The number of milliseconds to sleep between runs of the idle object evictor thread. When non-positive, no idle object evictor thread will be run.


minEvictableIdleTimeMillis         The minimum amount of time an object may sit idle in the pool before it is eligable for eviction by the idle object evictor (if any).


removeAbandoned Flag to remove abandoned connections if they exceed the removeAbandonedTimout. If set to true a connection is considered abandoned and eligible for removal if it has been idle longer than the removeAbandonedTimeout. Setting this to true can recover db connections from poorly written applications which fail to close a connection.


removeAbandonedTimeout Timeout in seconds before an abandoned connection can be removed. the above two parameter must be set at the same time to make connection pool manageable.If we set


validationQuery="SELECT SYSDATE FROM DUAL"
removeAbandoned=true
removeAbandonedTimeout=30
timeBetweenEvictionRunsMillis=500
minEvictableIdleTimeMillis=60000


then, we should interpreted these as:


1) If there’s poorly written code which forget to close connections after use, and it lasts for 30 seconds, it will be removed from the pool!

2) There’ll be an evictor thread up to monitor connection objects. If one of the connection objects becomes idle and last for 5000 milliseconds, it will be marked as removable. After another short nap of 500 milliseconds, that's at between 60000 and 60500 milliseconds, if the same connection is still found idle, it will be removed from the pool.



So a typical configuration for oracle would be like this:


driverClassName=driverclass
url=dburl
username=user
password=password


maxActive=100
maxWait=-1
defaultAutoCommit=true
minIdle=0
maxIdle=30
poolPreparedStatements=true

validationQuery="SELECT SYSDATE FROM DUAL"
testOnBorrow="true"
testOnReturn="false"
testWhileIdle = "false"
timeBetweenEvictionRunsMillis=500
removeAbandoned=true
removeAbandonedTimeout=30
minEvictableIdleTimeMillis=60000


1) It means when the pool starts up, poolPreparedStatements ability is enabled, transaction will be auto committed and there is no connections in it.

2) Any connections will be created on demand. If a new connection is requested, after creation, the new one will be tested against "SELECT SYSDATE FROM DUAL" before returning it to user, if it failed validation, yielding no result, the connection will be dropped, and another connection will be created and validated again until it pass.

3) If suddenly, floods of requests come in, the pool will create as many connections as it can to serve the request until the size reach 100. If requests continue to arrive, they will have wait before some connections finished the previous serving.

4) If there’s poorly written code which forget to close connections after use, and it lasts for 30 seconds, it will be removed from the pool!

5) When the flood begins to ebb, some of the connections will become idle and have nothing to do. If any connection object becomes idle and last for 60000 milliseconds, it will be marked as removable. After another short nap of 500 milliseconds, that's at between 60000 and 60500 milliseconds, if the same connection is still found idle, it will be removed from the pool.



For commons-dbcp-1.2.2 and commons-pool-1.3 and
we have to set

minIdle=0
testWhileIdle=false

to avoid a potential deadlock as described by
https://issues.apache.org/jira/browse/DBCP-44




Here is the test:

Environment:
Hardware: AMD Turion(TM) 64 X2 Mobile 1.8G    and 1.5G Memory

Operating System: Windows XP

Database:

mysql : 5.0.45-community-nt MySQL Community Edition (GPL)
Max_used_connections 100

Oracle: 10G default settings

Pool implementaions:

1)commons-dbcp-1.2.2(commons-pool-1.3)

2)c3p0-0.9.1.2

database  dbcp/c3p0   concurrent_threads     maxActive/poolSize   10minutes queries executed

mysql        dbcp/c3p0                5000                     100                        16200/1600
oracle       dbcp/c3p0                3000                      10                         3691/1900
oracle       dbcp/c3p0                3000                      50                         20900/6500
oracle       dbcp/c3p0                5000                      50                         8400/2000
oracle       dbcp/c3p0                5000                      80                         8800/1800

oracle       dbcp/c3p0                5000                       100                         ORA-12519/very slow, but no ORA-12519

(ORA-12519, TNS:no appropriate service handler found)


But if you want performance gained from dbcp, you should increase the value of "PROCESSES" parameter in oracle

Jdbc.properties
cabernet.jdbc.driverClassName=com.mysql.jdbc.Driver
cabernet.jdbc.url=jdbc:mysql://g-mobile:3306/jbpm?useUnicode=true&characterEncoding=utf8&autoReconnect=true
cabernet.jdbc.username=root
cabernet.jdbc.password=root

#dbcp
cabernet.jdbc.maxActive=100

##max.Wait means waiting until one is available
cabernet.jdbc.maxWait=-1
cabernet.jdbc.defaultAutoCommit=true
cabernet.jdbc.minIdle=0
cabernet.jdbc.maxIdle=30
cabernet.jdbc.removeAbandoned=true
cabernet.jdbc.removeAbandonedTimeout=30
cabernet.jdbc.poolPreparedStatements=true
cabernet.jdbc.validationQuery=select current_date();
cabernet.jdbc.testOnBorrow=true
cabernet.jdbc.testOnReturn=false
cabernet.jdbc.testWhileIdle=false
cabernet.jdbc.timeBetweenEvictionRunsMillis=500
cabernet.jdbc.minEvictableIdleTimeMillis=16000
cabernet.jdbc.logAbandoned=true

#c3p0
cabernet.jdbc.acquireIncrement=5
cabernet.jdbc.idleConnectionTestPeriod=3000
cabernet.jdbc.maxIdleTime=60

###checkoutTimeout=0 means waiting until one is available
cabernet.jdbc.checkoutTimeout=0
cabernet.jdbc.maxPoolSize=100
cabernet.jdbc.minPoolSize=0
cabernet.jdbc.maxStatements=1000
cabernet.jdbc.maxStatementsPerConnection=1000
cabernet.jdbc.initialPoolSize=0
cabernet.jdbc.autoCommitOnClose=true




Test Code:

package com.cabernet.dbcp;

import java.sql.SQLException;

import javax.sql.DataSource;

import com.cabernet.BaseTestCase;

/**
 * 
 * @author ginge
 *
 */
public class TestPooling extends BaseTestCase
{
	protected DataSource	datasource;

	public void testConnection() throws SQLException, InterruptedException
	{
		for (int i = 1000; i > 0; i--)
		{
			new QueryThread(this.datasource).start();

			log.debug("PoolingThread[" + i + "] is up and running.");
		}

		while (true)
			Thread.sleep(100000);
	}

	public DataSource getDatasource()
	{
		return datasource;
	}

	public void setDatasource(DataSource datasource)
	{
		this.datasource = datasource;
	}

	@Override
	protected String[] getConfigLocations()
	{
		// TODO Auto-generated method stub
		return new String[] { "classpath*:applicationContext-resources.xml", "classpath*:applicationContext-jbpm.xml",
				"classpath*:applicationContext-hibernate.xml" };
	}

}

package com.cabernet.dbcp;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Random;

import javax.sql.DataSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 
 * @author ginge
 *
 */
public class QueryThread extends Thread
{

	private Log		log		= LogFactory.getLog(this.getClass());
	DataSource		datasource;

	private Random	random	= new Random();

	QueryThread(DataSource datasource)
	{
		this.datasource = datasource;
	}

	@Override
	public void run()
	{
		// TODO Auto-generated method stub
		Connection connection = null;

		int i = 0;
		while (true)
		{
			if (i < Integer.MAX_VALUE)
				i++;
			else
				i = 0;

			try
			{
				connection = datasource.getConnection();
			} catch (Exception e)
			{
				log.error("getConnection exception :", e);
			}

			try
			{
				if (connection != null)
				{
					String query = "select * from jbpm_log where id_ = " + i;
					connection.createStatement().execute(query);
					log.debug("Thread[" + this.getId() + "] executeing [" + query + "]");
					sleep(1000);
					this.close(connection);
//					this.forgetToCloseSomeConnections(connection);
				}
			} catch (Exception e)
			{
				log.error("query exception :", e);
			}

		}
	}

	private void close(Connection connection)
	{
		try
		{
			connection.close();
		} catch (SQLException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void forgetToCloseSomeConnections(Connection connection)
	{
		if (random.nextInt(20) != 9)
			try
			{
				connection.close();
			} catch (SQLException e)
			{
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		else
		{
			if (log.isWarnEnabled())
			{
				log.warn("Connection not closed.");
			}
		}
	}
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public void afterCompletion(WebRequest request, Exception ex) throws DataAccessException {
		String participateAttributeName = getParticipateAttributeName();
		Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
		if (count != null) {
			// Do not modify the Session: just clear the marker.
			if (count.intValue() > 1) {
				request.setAttribute(participateAttributeName, new Integer(count.intValue() - 1), WebRequest.SCOPE_REQUEST);
			}
			else {
				request.removeAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
			}
		}
		else {
			if (isSingleSession()) {
				// single session mode
				SessionHolder sessionHolder =
						(SessionHolder) TransactionSynchronizationManager.unbindResource(getSessionFactory());
				logger.debug("Closing single Hibernate Session in OpenSessionInViewInterceptor");
				SessionFactoryUtils.closeSession(sessionHolder.getSession());
			}
			else {
				// deferred close mode
				SessionFactoryUtils.processDeferredClose(getSessionFactory());
			}
		}
	}

总结一下：

OpenSessionInViewFilter首先会确保sessionFactory的存在，

如果启用了session延迟关闭策略，也就是isSingleSession为false，session的创建和打开会在HibernateTemplate的execute里发生，而关闭会统一在OpenSessionInViewFilter返回时。

如果isSingleSession为true时，session的打开会在OpenSessionInViewFilter里或者之前的某个时候，而关闭会在OpenSessionInViewInterceptor里。

这样我们就可用自己在Junit或者其他应用场景使用延迟关闭策略来使我们的程序收益。以下附带前面篇章提及到的BaseTestCase，如果存在SessionFactory，则激活延迟关闭session策略。各位可用参考使用。

package com.cabernet;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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.test.AbstractDependencyInjectionSpringContextTests;
import org.springframework.transaction.support.TransactionSynchronizationManager;

/**
 * Supports OpenSessionInViewFilter like Hibernate Lazy-loading when
 * SessionFactory is present
 * 
 * @author ginge
 * 
 * @see OpenSessionInViewFilter
 */
public class BaseTestCase extends AbstractDependencyInjectionSpringContextTests
{
	protected Log				log			= LogFactory.getLog(this.getClass());

	private FlushMode			flushMode	= FlushMode.MANUAL;

	protected SessionFactory	sessionFactory;

	@Override
	protected void prepareTestInstance() throws Exception
	{
		// TODO Auto-generated method stub
		super.prepareTestInstance();

		if (isSessionFactoryPresent())
		{
			afterSessionFactorySet();
			SessionFactoryUtils.initDeferredClose(sessionFactory);
			TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(this.getSession()));
		}
	}

	@Override
	protected void onTearDown() throws Exception
	{
		// TODO Auto-generated method stub

		if (isSessionFactoryPresent())
		{
			SessionFactoryUtils.processDeferredClose(sessionFactory);
			TransactionSynchronizationManager.unbindResource(sessionFactory);
		}

		super.onTearDown();
	}

	private boolean isSessionFactoryPresent()
	{
		return this.sessionFactory != null;
	}

	protected void afterSessionFactorySet()
	{

	}

	public SessionFactory getSessionFactory()
	{
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory)
	{
		this.sessionFactory = sessionFactory;
	}

	@Override
	protected String[] getConfigLocations()
	{
		return new String[] { "classpath*:applicationContext-resources.xml" };
	}

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

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

到了这个时刻，我们回到Jbpm跟Springmodules, Spring的持久化集成上来，虽然Jbpm本身提供了JbpmContextFilter，它的功能是在Filter开始打开JbpmContext，Filter返回时关闭JbpmContext。但是在前面的篇章中，我们知道JbpmTemplate中会在操作开始前注入session。因此，使用了OpenSessionInViewFilter和JbpmTemplate之后，JbpmContextFilter将会英雄无用武之地。这个OpenSessionInViewFilter必须配置在其他Filter之前以确保在进入其他Filter之前激活延迟关闭策略或者绑定Session到当前线程中。

（完结）

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

不管Jbpm的持久化策略如何，要重用Spring的持久化集成服务，我们要怎么做呢？Jbpm可以是B/S架构中的一部分，也可以是C/S架构的一部分。对于B/S架构，我们都知道有OpenSessionInViewFilter，然而C/S没有“Filter”，该从何入手呢？

我们先来看看OpenSessionInViewFilter是怎样做到的，本篇不讨论它的优缺点。OpenSessionInViewFilter也是一个javax.servlet.Filter，只不过它还是BeanNameAware，ServletContextAware，InitializingBean和DisposableBean的实现。

像所有的Filter一样，Filter的入口都是

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

到了OpenSessionInViewFilter这里，执行的方法就是

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

doFilterInternal做的事情说简单也不简单，我们来看该方法做了什么，请留意注释：

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

		//1，	先把SessionFactory取出来。
		SessionFactory sessionFactory = lookupSessionFactory(request);
		boolean participate = false;

		//2.1	如果是设置了isSingleSession为true，则整个request请求中都会只使用一个session。
		if (isSingleSession()) {
			// single session mode
			//2.2 再看看当前线程是不是已经存在一个可用的session
			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");
				//2.3	没有就创建一个
				Session session = getSession(sessionFactory);
				TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
			}
		}
		else {
			// deferred close mode
			//3.1 如果已经延迟关闭策略已经被激活，则什么事情也不做
			if (SessionFactoryUtils.isDeferredCloseActive(sessionFactory)) {
				// Do not modify deferred close: just set the participate flag.
				participate = true;
			}
			else {
				//3.2  如果为false，则激活延迟关闭session策略
				SessionFactoryUtils.initDeferredClose(sessionFactory);
			}
		}

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

		finally {
			//4.1，	filter返回后，如果在进入该filter之前延迟关闭已经被激活，该filter不负责关闭session，
			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 {
					//4.2  如延迟关闭是该filter激活的，就在此关闭session
					// deferred close mode
					SessionFactoryUtils.processDeferredClose(sessionFactory);
				}
			}
		}
	}

public Object execute(HibernateCallback action, boolean exposeNativeSession) throws DataAccessException {
		Assert.notNull(action, "Callback object must not be null");

		Session session = getSession();
		/*
          *省略一段代码
*/
			Object result = action.doInHibernate(sessionToExpose);
		/*
          *省略一段代码
*/
		SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());

	}

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师

Spring, Springmodules, JBPM持久化集成理解系列二

【本系列如需转载，请注明作者及出处】 

本系列文章假设阅者具备以下知识：
1，ThreadLocal相关知识
2，Spring持久化，事务管理相关知识
3，Hibernate 持久化相关知识
4，Jbpm 持久化相关知识
5，Springmodules项目相关知识
6，相关J2EE知识

且具备以下材料：
1，Spring源代码
2，Hibernate源代码
3，Jbpm源代码
4，Springmodules源代码

第二部分，Session的关闭： 到了这里，我们就到了验证的最后一部分了，JbpmContext的关闭了。


【位置JbpmContext】

public void close() {
    log.debug("closing JbpmContext");
    try {
      if (services!=null) {
        try {
          autoSave();
        } finally {
          services.close();
        }
      }
    } finally {
      if (jbpmConfiguration!=null) {
        jbpmConfiguration.jbpmContextClosed(this);
      }
    }
}

if (mustSessionBeClosed) {
      try {
        if(session.isOpen()) {
          log.debug("closing hibernate session");
          session.close();
        } else {
          log.warn("hibernate session was already closed");
        }
      } catch (Exception e) {
        throw new JbpmPersistenceException("couldn't close hibernate session", e);
      }
    }

    if (mustConnectionBeClosed) {
      try {
        if ( (connection!=null)
            && (! connection.isClosed())
           ) {
          log.debug("closing jdbc connection");
          connection.close();
        } else {
          log.warn("jdbc connection was already closed");
        }
      } catch (Exception e) {
        throw new JbpmPersistenceException("couldn't close jdbc connection", e);
      }
    }

总结：



对于情况一，如果提供了session，mustConnectionBeClosed是false，mustSessionBeClosed也是false，所以这种情况Jbpm不会关闭Connection。


对于情况二mustConnectionBeClosed是true，mustSessionBeClosed也是false，所以Jbpm会调用Session.close()，但是关闭一个使用已有Connection打开的Session，在close时的时候是不会关闭实际的Jdbc 连接的。有兴趣的朋友可用自己继续查看相应的Hibernate代码。



SpringModules集成Jbpm，它向JbpmContext提供了Session，那么它就应该负责Session的创建和关闭了，这些事情Springmodules的核心类JbpmTemplate使用了HibernateTemplate，重用了Spring对Hibernate数据库事务的封装。也就能进一步享受Spring的事务管理和延迟加载，也就是OpenSessionInView的便利。


我后来写了一个Junit测试类来验证，附Junit测试代码：

package com.cabernet;

import java.util.List;

import junit.framework.Assert;

import org.jbpm.taskmgmt.exe.TaskInstance;
import org.springmodules.workflow.jbpm31.JbpmTemplate;

public class TestSetUp extends BaseTestCase
{
	protected JbpmTemplate	jbpmTemplate;

	public void test()
	{
		Assert.assertNotNull(this.jbpmTemplate);

		boolean isDebugEnabled = log.isDebugEnabled();

		if (isDebugEnabled)
		{
			log.debug("findTaskInstances");
		}
		
		List<TaskInstance> tasks = this.jbpmTemplate.findTaskInstances("bert");

		if (tasks != null)
		{
			if (isDebugEnabled)
			{
				log.debug("Tasks found, Swimlane: [" + tasks.get(0).getTask()
						.getSwimlane().getName() + "].");
			}

			return;
		}

		if (isDebugEnabled)
		{
			log.debug("No tasks found.");
		}
	}

	public JbpmTemplate getJbpmTemplate()
	{
		return jbpmTemplate;
	}

	public void setJbpmTemplate(JbpmTemplate jbpmTemplate)
	{
		this.jbpmTemplate = jbpmTemplate;
	}

}

上述Junit 类继承的父类BaseTestCase是AbstractDependencyInjectionSpringContextTests的子类，

 启用了与OpenSessionInView一样的数据LazyLoading和JDBC Connection延迟关闭策略。

附件是测试这个这个流程所发生的Log，首先是SessionFactoryUtils打开了Hibernate Session，最后是SessionFactoryUtils关闭了Hibernate Session，符合Jbpm声称的Context哲学。

2008-03-04 00:14:12 DEBUG (SessionFactoryUtils.java:690)     - Initializing deferred close of Hibernate Sessions
2008-03-04 00:14:12 DEBUG (SessionFactoryUtils.java:316)     - Opening Hibernate Session
2008-03-04 00:14:12 DEBUG (TestSetUp.java:22)     - findTaskInstances
2008-03-04 00:14:12 DEBUG (JbpmContextInfo.java:142)     - creating jbpm context with service factories '[message, scheduler, logging, persistence, authentication]'
2008-03-04 00:14:12 DEBUG (JbpmContext.java:124)     - creating JbpmContext
2008-03-04 00:14:12 DEBUG (HibernateTemplate.java:364)     - Found thread-bound Session for HibernateTemplate
2008-03-04 00:14:12 DEBUG (DbPersistenceServiceFactory.java:55)     - creating persistence service
2008-03-04 00:14:12 DEBUG (DbPersistenceService.java:303)     - injecting a session disables transaction
Hibernate: select taskinstan0_.ID_ as ID1_27_, taskinstan0_.NAME_ as NAME3_27_, taskinstan0_.DESCRIPTION_ as DESCRIPT4_27_, taskinstan0_.ACTORID_ as ACTORID5_27_, taskinstan0_.CREATE_ as CREATE6_27_, taskinstan0_.START_ as START7_27_, taskinstan0_.END_ as END8_27_, taskinstan0_.DUEDATE_ as DUEDATE9_27_, taskinstan0_.PRIORITY_ as PRIORITY10_27_, taskinstan0_.ISCANCELLED_ as ISCANCE11_27_, taskinstan0_.ISSUSPENDED_ as ISSUSPE12_27_, taskinstan0_.ISOPEN_ as ISOPEN13_27_, taskinstan0_.ISSIGNALLING_ as ISSIGNA14_27_, taskinstan0_.ISBLOCKING_ as ISBLOCKING15_27_, taskinstan0_.TASK_ as TASK16_27_, taskinstan0_.TOKEN_ as TOKEN17_27_, taskinstan0_.SWIMLANINSTANCE_ as SWIMLAN18_27_, taskinstan0_.TASKMGMTINSTANCE_ as TASKMGM19_27_ from JBPM_TASKINSTANCE taskinstan0_ where taskinstan0_.ACTORID_=? and taskinstan0_.ISSUSPENDED_<>1 and taskinstan0_.ISOPEN_=1
2008-03-04 00:14:13 DEBUG (HibernateTemplate.java:388)     - Not closing pre-bound Hibernate Session after HibernateTemplate
2008-03-04 00:14:13 DEBUG (JbpmContext.java:133)     - closing JbpmContext
2008-03-04 00:14:13 DEBUG (Services.java:210)     - closing service 'persistence': org.jbpm.persistence.db.DbPersistenceService@1ce663c
Hibernate: select task0_.ID_ as ID1_14_0_, task0_.NAME_ as NAME2_14_0_, task0_.PROCESSDEFINITION_ as PROCESSD3_14_0_, task0_.DESCRIPTION_ as DESCRIPT4_14_0_, task0_.ISBLOCKING_ as ISBLOCKING5_14_0_, task0_.ISSIGNALLING_ as ISSIGNAL6_14_0_, task0_.DUEDATE_ as DUEDATE7_14_0_, task0_.ACTORIDEXPRESSION_ as ACTORIDE8_14_0_, task0_.POOLEDACTORSEXPRESSION_ as POOLEDAC9_14_0_, task0_.TASKMGMTDEFINITION_ as TASKMGM10_14_0_, task0_.TASKNODE_ as TASKNODE11_14_0_, task0_.STARTSTATE_ as STARTSTATE12_14_0_, task0_.ASSIGNMENTDELEGATION_ as ASSIGNM13_14_0_, task0_.SWIMLANE_ as SWIMLANE14_14_0_, task0_.TASKCONTROLLER_ as TASKCON15_14_0_ from JBPM_TASK task0_ where task0_.ID_=?
Hibernate: select swimlane0_.ID_ as ID1_13_0_, swimlane0_.NAME_ as NAME2_13_0_, swimlane0_.ACTORIDEXPRESSION_ as ACTORIDE3_13_0_, swimlane0_.POOLEDACTORSEXPRESSION_ as POOLEDAC4_13_0_, swimlane0_.ASSIGNMENTDELEGATION_ as ASSIGNME5_13_0_, swimlane0_.TASKMGMTDEFINITION_ as TASKMGMT6_13_0_ from JBPM_SWIMLANE swimlane0_ where swimlane0_.ID_=?
2008-03-04 00:14:13 DEBUG (TestSetUp.java:31)     - Tasks found, Swimlane: [buyer].
2008-03-04 00:14:13 DEBUG (SessionFactoryUtils.java:714)     - Processing deferred close of Hibernate Sessions

• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

Spring, Springmodules, JBPM持久化集成理解系列二 

【本系列如需转载，请注明作者及出处】 

本系列文章假设阅者具备以下知识：
1，ThreadLocal相关知识
2，Spring持久化，事务管理相关知识
3，Hibernate 持久化相关知识
4，Jbpm 持久化相关知识
5，Springmodules项目相关知识
6，相关J2EE知识

且具备以下材料：
1，Spring源代码
2，Hibernate源代码
3，Jbpm源代码
4，Springmodules源代码 

  本篇尝试探讨SpringModules集成的背后逻辑，这涉及到JbpmContext持久化的哲学。 

  JbpmContext持久化管理的哲学是，如果用户提供Context数据库连接，那么用户就要管理该数据库的打开与关闭。如果使用JbpmContext自己产生的持久化服务，那么该服务就要管理与持久化相关的操作。很像各人自扫门前雪，哪管他人瓦上霜。

public TaskInstance loadTaskInstance(long taskInstanceId) {
    return getTaskMgmtSession().loadTaskInstance(taskInstanceId);
}

public TaskMgmtSession getTaskMgmtSession() {
    PersistenceService persistenceService = getPersistenceService();
    if (persistenceService==null) return null;
    return (persistenceService!=null ? persistenceService.getTaskMgmtSession() : null);

public TaskMgmtSession getTaskMgmtSession() {
    if (taskMgmtSession==null) {
      Session session = getSession();
      if (session!=null) {
        taskMgmtSession = new TaskMgmtSession(session);
      }
    }
    return taskMgmtSession;
  }

准备工作：1）以下是会涉及的布尔变量，以及其默认值：

【位置DbPersistenceService】

Connection connection = null;
  boolean mustConnectionBeClosed = false;

  Transaction transaction = null;
  boolean isTransactionEnabled = true;
  boolean isCurrentSessionEnabled = false;
  boolean isRollbackOnly = false;

  Session session;
  boolean mustSessionBeFlushed = false;
boolean mustSessionBeClosed = false;

准备工作2）由于DbPersistenceService只有一个Constructor，也就是

【位置DbPersistenceService】

public DbPersistenceService(DbPersistenceServiceFactory persistenceServiceFactory) {
    this.persistenceServiceFactory = persistenceServiceFactory;
    this.isTransactionEnabled = persistenceServiceFactory.isTransactionEnabled();
    this.isCurrentSessionEnabled = persistenceServiceFactory.isCurrentSessionEnabled();
  }

  在这里我们就知道了，进行数据库操作所用到Session，SessionFactory就只能通过相关的Setter和Getter方法来取到了。  现在进入这个方法：

【位置DbPersistenceService】

public Session getSession() {
    if ( (session==null)
         && (getSessionFactory()!=null) 
       ) {
      Connection connection = getConnection(false); 
      if (isCurrentSessionEnabled) {
        session = getSessionFactory().getCurrentSession();
        mustSessionBeClosed = false;
        mustSessionBeFlushed = false;
        mustConnectionBeClosed = false;
      } else if (connection!=null) {
        log.debug("creating hibernate session with connection "+connection);
        session = getSessionFactory().openSession(connection);
        mustSessionBeClosed = true;
        mustSessionBeFlushed = true;
        mustConnectionBeClosed = false;
      } else {
        log.debug("creating hibernate session");
        session = getSessionFactory().openSession();
        mustSessionBeClosed = true;
        mustSessionBeFlushed = true;
        mustConnectionBeClosed = false;
      }
      
      if (isTransactionEnabled) {
        log.debug("beginning hibernate transaction");
        transaction = session.beginTransaction();
      }
    }
    return session;
  }

1）如果用户向JbpmContext提供了Session，那么会立刻返回该session，并且不会修改mustConnectionBeClosed，mustSessionBeClosed等的值。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

Spring, Springmodules, JBPM持久化集成理解系列一

【本系列如需转载，请注明作者及出处】

本系列文章假设阅者具备以下知识：
1，ThreadLocal相关知识
2，Spring持久化，事务管理相关知识
3，Hibernate 持久化相关知识
4，Jbpm 持久化相关知识
5，Springmodules项目相关知识
6，相关J2EE知识