Spring3核心技术之JdbcTemplate

一日一博

浏览: 229975 次
性别:
来自: 武汉

最近访客更多访客>>

zhangthe9

存储炒菜错

zhaohuaxishiwzw

pywang

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Spring

jdbc spring Spring JDBC

Spring对JDBC的支持
Spring通过抽象JDBC访问并提供一致的API来简化JDBC编程的工作量。我们只需要声明SQL、调用合适的Spring JDBC框架API、处理结果集即可。事务由Spring管理，并将JDBC受查异常转换为Spring一致的非受查异常，从而简化开发。

....
    Connection conn = null;  
    PreparedStatement pstmt = null;
    try {
      conn = getConnection();              //1.获取JDBC连接    
      String sql = "select * from tableName"; //2.声明SQL
      pstmt = conn.prepareStatement(sql);    //3.预编译SQL  
      ResultSet rs = pstmt.executeQuery();   //4.执行SQL  
      process(rs);                       //5.处理结果集  
      closeResultSet(rs);                 //5.释放结果集  
      closeStatement(pstmt);              //6.释放Statement  
      conn.commit();                    //8.提交事务  
    } catch (Exception e) {  
      //9.处理异常并回滚事务  
      conn.rollback();  
      throw e;  
    } finally {  
      //10.释放JDBC连接，防止JDBC连接不关闭造成的内存泄漏  
      closeConnection(conn);  
    }
....

以上代码片段具有冗长、重复、容易忘记某一步骤从而导致出错、显示控制事务、显示处理受检查异常等等。
Spring主要提供JDBC模板方式、关系数据库对象化方式和SimpleJdbc方式三种方式来简化JDBC编程，这三种方式就是Spring JDBC的工作模式：
Spring JDBC抽象框架core包提供了JDBC模板类，其中JdbcTemplate是core包的核心类，所以其他模板类都是基于它封装完成的，JDBC模板类是第一种工作模式。

JdbcTemplate类通过模板设计模式帮助我们消除了冗长的代码，只做需要做的事情（即可变部分），并且帮我们做哪些固定部分，如连接的创建及关闭。

JDBC模板方式：Spring JDBC框架提供以下几种模板类来简化JDBC编程，实现GoF模板设计模式，将可变部分和非可变部分分离，可变部分采用回调接口方式由用户来实现：如JdbcTemplate、NamedParameterJdbcTemplate、SimpleJdbcTemplate。
关系数据库操作对象化方式：Spring JDBC框架提供了将关系数据库操作对象化的表示形式，从而使用户可以采用面向对象编程来完成对数据库的访问；如MappingSqlQuery、SqlUpdate、SqlCall、SqlFunction、StoredProcedure等类。这些类的实现一旦建立即可重用并且是线程安全的。
SimpleJdbc方式：Spring JDBC框架还提供了SimpleJdbc方式来简化JDBC编程，SimpleJdbcInsert 、 SimpleJdbcCall用来简化数据库表插入、存储过程或函数访问。

Spring JDBC还提供了一些强大的工具类，如DataSourceUtils来在必要的时候手工获取数据库连接等。

Spring的JDBC架构
Spring JDBC抽象框架由四部分组成：datasource、support、core、object如图所示。

support包：提供将JDBC异常转换为DAO非检查异常转换类、一些工具类如JdbcUtils等。
datasource包：提供简化访问JDBC 数据源（javax.sql.DataSource实现）工具类，并提供了一些DataSource简单实现类从而能使从这些DataSource获取的连接能自动得到Spring管理事务支持。
core包：提供JDBC模板类实现及可变部分的回调接口，还提供SimpleJdbcInsert等简单辅助类。
object包：提供关系数据库的对象表示形式，如MappingSqlQuery、SqlUpdate、SqlCall、SqlFunction、StoredProcedure等类，该包是基于core包JDBC模板类实现。

SpringJDbc工程中需要引入以下JAR包：

Spring JDBC提供如下DaoSupport实现：
● JdbcDaoSupport：用于支持一致的JdbcTemplate访问；
● NamedParameterJdbcDaoSupport:继承JdbcDaoSupport，同时提供NamedParameterJdbcTemplate访问；
● SimpleJdbcDaoSupport：继承JdbcDaoSupport，同时提供SimpleJdbcTemplate访问。
由于JdbcTemplate、NamedParameterJdbcTemplate、SimpleJdbcTemplate类使用DataSourceUtils获取及释放连接，而且连接是与线程绑定的，因此这些JDBC模板类是线程安全的，即JdbcTemplate对象可以在多线程中重用

JdbcTemplate
JdbcTemplate主要提供以下五类方法：

execute()：可以用于执行任何SQL语句，一般用于执行DDL语句；
update()及batchUpdate()：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
query()及queryForXXX()：用于执行查询相关语句；
call()：用于执行存储过程、函数相关语句。

JdbcTemplate类支持的回调类：
● 预编译语句及存储过程创建回调：用于根据JdbcTemplate提供的连接创建相应的语句；
         PreparedStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的PreparedStatement；
         CallableStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的CallableStatement；
● 预编译语句设值回调：用于给预编译语句相应参数设值；
         PreparedStatementSetter：通过回调获取JdbcTemplate提供的PreparedStatement，由用户来对相应的预编译语句相应参数设值；
         BatchPreparedStatementSetter：；类似于PreparedStatementSetter，但用于批处理，需要指定批处理大小；
● 自定义功能回调：提供给用户一个扩展点，用户可以在指定类型的扩展点执行任何数量需要的操作；
         ConnectionCallback：通过回调获取JdbcTemplate提供的Connection，用户可在该Connection执行任何数量的操作；
         StatementCallback：通过回调获取JdbcTemplate提供的Statement，用户可以在该Statement执行任何数量的操作；
         PreparedStatementCallback：通过回调获取JdbcTemplate提供的PreparedStatement，用户可以在该PreparedStatement执行任何数量的操作；
         CallableStatementCallback：通过回调获取JdbcTemplate提供的CallableStatement，用户可以在该CallableStatement执行任何数量的操作；
● 结果集处理回调：通过回调处理ResultSet或将ResultSet转换为需要的形式；
         RowMapper：用于将结果集每行数据转换为需要的类型，用户需实现方法mapRow(ResultSet rs, int rowNum)来完成将每行数据转换为相应的类型。
         RowCallbackHandler：用于处理ResultSet的每一行结果，用户需实现方法processRow(ResultSet rs)来完成处理，在该回调方法中无需执行rs.next()，该操作由JdbcTemplate来执行，用户只需按行获取数据然后处理即可。
         ResultSetExtractor：用于结果集数据提取，用户需实现方法extractData(ResultSet rs)来处理结果集，用户必须处理整个结果集；

/**
 * 
 * @author Chou
 * @since 2012-9-9
 * SpringJdbc并没有像Hibernate那样把AutoCommit设置为false，
 * 所以没有配置事务的情况下，默认是自动提交
 */
public class JdbcTemplateDao extends JdbcDaoSupport{
	
	public void setDadasource(DataSource dataSource) {
		super.setDataSource(dataSource);
	}

	public void commonSql() {
		String insertSql = "insert into tab_item values(?,?,?)";
		String updateSql = "update tab_item set itemno = ?, itemname = ? where id = ?";
		String deleteSql = "delete tab_item where id = ?";

		Assert.isTrue(
		getJdbcTemplate().update(insertSql, new Object[]{4, "HP", "PT540"}) == 1, "插入失败");
		Assert.isTrue(
		getJdbcTemplate().update(updateSql, new Object[]{"HP", "PT555", 4}) == 1, "修改失败");
		Assert.isTrue(
		getJdbcTemplate().update(deleteSql, new Object[]{4}) == 1, "删除失败");
	}
	
	/**
	 * 预编译语句设值回调使用
	 * 通过JdbcTemplate的int update(String sql, PreparedStatementSetter pss)执行预编译sql
	 */
	public void preparedStatementSql() {
		String sql = "insert into tab_item values(?,?,?)";
		int row = getJdbcTemplate().update(sql, new PreparedStatementSetter() {
			@Override
			public void setValues(PreparedStatement ps) throws SQLException {
				ps.setInt(1, 101);// JDBC占位符集合的序号是从1开始的，而不是0
				ps.setObject(2, "Apple");
				ps.setString(3, "Ipad4");
			}
		});
		Assert.isTrue(row == 1, "插入失败");

		// JdbcTemplate也提供一种更简单的方式设值相应的占位符位置的值
		sql = "delete from tab_item where id = ?";
		row = getJdbcTemplate().update(sql, new Object[] { 101 });
		Assert.isTrue(row == 1, "删除失败");
	}

	public void queryCallback() {
		String listSql = "select * from player";
		
		/**
		 * RowMapper接口提供mapRow(ResultSet rs, int rowNum)
		 * 方法将结果集的每一行转换为一个Map，当然可以转换为其他类，如表的对象化形式。
		 */
		List<Map> result = getJdbcTemplate().query(listSql, new RowMapper<Map>() {
			@Override
			public Map mapRow(ResultSet rs, int rowNum) throws SQLException {
				System.out.println(rowNum);
				Map<Long,String> map = new HashMap<Long, String>();  
		        map.put(rs.getLong("id"), rs.getString("name"));
		        return map;
			}
		});
		Iterator it = result.iterator();
		while (it.hasNext()) {
			Map<Long,String> map = (Map<Long, String>) it.next();
			System.out.println(map.values());
		}
		
		/**
		 * RowCallbackHandler接口也提供方法processRow(ResultSet rs)，
		 * 能将结果集的行转换为需要的形式。
		 */
		getJdbcTemplate().query(listSql, new RowCallbackHandler() {
			@Override
			public void processRow(ResultSet rs) throws SQLException {
				System.out.println("处理结果集");
				System.out.print("id:" + rs.getInt("id") + "***");
				System.out.println("name:" + rs.getString("name"));
			}
		});
		
		/**
		 * ResultSetExtractor使用回调方法extractData(ResultSet rs)提供整个结果集，
		 * 让用户决定如何处理该结果集
		 */
		List list = getJdbcTemplate().query(listSql, new ResultSetExtractor<List>() {
			@Override
			public List extractData(ResultSet rs) throws SQLException,DataAccessException {
				List result = new ArrayList();  
		        while(rs.next()) {
		            Map row = new HashMap();
		            row.put(rs.getInt("id"), rs.getString("name"));
		            result.add(row);
		            System.out.println(row);
		        }
		        return result;
			}
		});
	}
	
	/**
	 * JdbcTemplate提供更简单的queryForXXX方法，来简化开发：
	 */
	private void queryForSimple() {
		//1.查询一行数据并返回int型结果  
		int countRs = getJdbcTemplate().queryForInt("select count(*) from player");
		System.out.println(countRs);
		
		//2. 查询一行数据并将该行数据转换为Map返回  
		Map map = getJdbcTemplate().queryForMap("select * from tab_item where id = ?", new Object[]{100});
		System.out.println(map.values());
		
		//3.查询一行任何类型的数据，最后一个参数指定返回结果类型  
		countRs = getJdbcTemplate().queryForObject("select count(*) from player", Integer.class);
		System.out.println(countRs);
		
		//4.查询一批数据，默认将每行数据转换为Map       
		List<Map<String, Object>> list = getJdbcTemplate().queryForList("select * from player");
		System.out.println(list.get(0).values());
		
		//5.只查询一列数据列表，列类型是String类型，列名字是name
		List<String> names = getJdbcTemplate().queryForList("select itemname from tab_item where itemname=?", new Object[]{"雷蛇鼠标"}, String.class);
		System.out.println(names.size());
		
		//6.查询一批数据，返回为SqlRowSet，类似于ResultSet，但不再绑定到连接上  
		SqlRowSet rs = getJdbcTemplate().queryForRowSet("select * from player");
	}

	/**
	 * 调用建表，删表语句
	 * 数据库不同，创建存储过程的SQL也不同
	 */
	public void createProcedure() {
		    String createTableSql = "create memory table test" +  
		    "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " +  
		    "name varchar(100))";  
		    
		    String dropTableSql = "drop table test"; 
		         
		    String createHsqldbFunctionSql =  
		      "CREATE FUNCTION FUNCTION_TEST(str CHAR(100)) " +  
		      "returns INT begin atomic return length(str);end";  
		    getJdbcTemplate().update(createHsqldbFunctionSql);
		    
		    String createProcedureSql =  
		      "CREATE PROCEDURE PROCEDURE_TEST" +  
		      "(INOUT inOutName VARCHAR(100), OUT outId INT) " +  
		      "MODIFIES SQL DATA " +  
		      "BEGIN ATOMIC " +  
		      "  insert into test(name) values (inOutName); " +  
		      "  SET outId = IDENTITY(); " +  
		      "  SET inOutName = 'Hello,' + inOutName; " +  
		    "END";
		    
		    getJdbcTemplate().update(createTableSql);  
		    getJdbcTemplate().execute(createProcedureSql);
		    
		    getJdbcTemplate().execute("DROP FUNCTION FUNCTION_TEST");  
		    getJdbcTemplate().execute("DROP PROCEDURE PROCEDURE_TEST");  
		     
		    getJdbcTemplate().execute(dropTableSql); 
	}
/**
	 * @return DriverManagerDataSource 返回数据源对象dataSource
	 */
	public static DriverManagerDataSource getMyDataSource() {
		DriverManagerDataSource dataSource = new DriverManagerDataSource(url,
				username, password);
		dataSource.setDriverClassName(driver);
		return dataSource;
	}
}

NamedParameterJdbcTemplate
NamedParameterJdbcTemplate类是基于JdbcTemplate类，并对它进行了封装从而支持命名参数特性。NamedParameterJdbcTemplate主要提供以下三类方法： execute方法、 query及queryForXXX方法、update及batchUpdate方法。

/**
 * @author Chou
 * @since 2012-9-9
 */
public class NamedParameterJdbcTemplateDao extends NamedParameterJdbcDaoSupport{
	
	public void setDadasource(DataSource dataSource) {
		super.setDataSource(dataSource);
	}

	public void commonSql() {
		//可以使用DataSource或JdbcTemplate对象作为构造器参数初始化
		namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(getJdbcTemplate());
		String insertSql = "insert into tab_item values(:id, :itemno, :itemname)";
		String deleteSql = "delete from tab_item where id = :id";
		String selectSql = "select * from player where place = :place";

		//NamedParameterJdbcTemplate类为命名参数设值有两种方式：java.util.Map和SqlParameterSource
		Map<String, Object> paramMap = new HashMap<String, Object>();
		paramMap.put("id", 101);
		paramMap.put("itemno", "Menzu");
		paramMap.put("itemname", "MP4");
		int row = namedParameterJdbcTemplate.update(insertSql, paramMap);
		Assert.isTrue(row == 1, "插入失败");

		/**
		 * 可以使用SqlParameterSource实现作为来实现为命名参数设值，默认有MapSqlParameterSource
		 * 和BeanPropertySqlParameterSource实现；MapSqlParameterSource实现非常简单，
		 * 只是封装了java.util.Map；而BeanPropertySqlParameterSource封装了一个JavaBean对象，
		 * 通过JavaBean对象属性来决定命名参数的值。
		 * 可以看出BeanPropertySqlParameterSource使用能减少很多工作量，
		 * 但命名参数必须和JavaBean属性名称相对应才可以。
		 */
		//Map<String, Object> paramMap2 = new HashMap<String, Object>();
		//paramMap2.put("id", 1);
		//SqlParameterSource paramSource = new MapSqlParameterSource(paramMap2);
		
		Item model = new Item();
		model.setId(101l);
		SqlParameterSource paramSource = new BeanPropertySqlParameterSource(model);
		
		row = namedParameterJdbcTemplate.update(deleteSql, paramSource);
		Assert.isTrue(row == 1, "删除失败");
		
		Map<String, Object> paramMap1 = new HashMap<String, Object>();
		paramMap1.put("place","PG   ");
		namedParameterJdbcTemplate.query(selectSql, paramMap1, new RowCallbackHandler() {
			@Override
			public void processRow(ResultSet rs) throws SQLException {
				System.out.println(rs.getString("name"));
			}
		});
	}
}

public class Item {
	private Long id;
	private String itemno;
	private String itemname;
	
	//省略get和set方法
}

SimpleJdbcTemplate
SimpleJdbcTemplate类也是基于JdbcTemplate类，但利用Java5+的可变参数列表和自动装箱和拆箱从而获取更简洁的代码。但是SimpleJdbcDaoSupport在Spring3.X中已经不推荐使用了。

/**
 * @author Chou
 * @since 2012-9-9 
 */
public class SimpleJdbcTemplateDao extends SimpleJdbcDaoSupport{
	
	public void setDadasource(DataSource dataSource) {
		super.setDataSource(dataSource);
	}

	public void commonSql() {
		String insertSql = "update tab_item set itemno = :itemno where itemno = :itemno2";
		int rows = getSimpleJdbcTemplate().update(insertSql, "APPLE", "Apple");
		System.out.println(rows);
	}
}

SimpleJdbc
Spring JDBC抽象框架提供SimpleJdbcInsert和SimpleJdbcCall类，这两个类通过利用JDBC驱动提供的数据库元数据来简化JDBC操作。下面代码演示SimpleJdbcInsert用法，SimpleJdbcCall用于调用存储过程及自定义函数，可以参考博客：http://jinnianshilongnian.iteye.com/blog/1428149

/**
 * @author Chou
 * @since 2012-9-9 
 */
@SuppressWarnings("deprecation")
public class SimpleJdbcTemplateDao{

	private static SimpleJdbcInsert insert;

	public static void main(String[] args) {
		insert = new SimpleJdbcInsert(JdbcTemplateTest.getMyDataSource());
		simpleInsetId()
		System.out.println(insert.getInsertString());
	}
	
	public static void simpleInsetId() {
		insert.withTableName("tab_item");
		//主键是数据库自动生成的情况下
		insert.setGeneratedKeyName("id");
		
		Map<String, Object> args = new HashMap<String, Object>();
		args.put("itemno", "SONY");
		args.put("itemname", "SONY");
		
		/**
		 * executeAndReturnKey用于执行并获取自动生成主键（注意是Number类型），
		 * 必须首先通过setGeneratedKeyName设置主键然后才能获取，如果想获取复
		 * 合主键请使用setGeneratedKeyNames描述主键然后通过executeReturningKeyHolder
		 * 获取复合主键KeyHolder对象；
		 */
		Number id = insert.executeAndReturnKey(args);
		System.out.println(id);
	}
}

SpringJdbc批量操作

public class BatchExecuteDao extends JdbcDaoSupport{
	
	public void setDadasource(DataSource dataSource) {
		super.setDataSource(dataSource);
	}
	
	@SuppressWarnings("unchecked")
	public void batchBySimpleJdbcInsert() {
		 SimpleJdbcInsert insert = new SimpleJdbcInsert(getJdbcTemplate());  
		 insert.withTableName("tab_item");  
		 Map<String, Object> valueMap = new HashMap<String, Object>();  
		 valueMap.put("id", 101);
		 valueMap.put("itemno", "SONY");
		 valueMap.put("itemname", "SONY");
		 Map<String, Object> valueMap2 = new HashMap<String, Object>();  
		 valueMap2.put("id", 102);
		 valueMap2.put("itemno", "SONY");
		 valueMap2.put("itemname", "SONY");
		 insert.executeBatch(new Map[] {valueMap, valueMap2});
		 System.out.println(insert.getInsertString());
	}

	/**
	 * 使用batchUpdate(String sql, List<Object[]> batchArgs)方法完成占位符批处理，
	 * 当然也支持命名参数批处理等
	 */
	public void batchBySimpleJdbcTemplate() {
		SimpleJdbcTemplate simpleJdbcTemplate = new SimpleJdbcTemplate(getJdbcTemplate());  
	    String deleteSql = "delete tab_item where id = :id";  
	    List<Object[]> params = new ArrayList<Object[]>();  
	    params.add(new Object[]{101});
	    params.add(new Object[]{102});
	    params.add(new Object[]{103});
	    params.add(new Object[]{104});
	    simpleJdbcTemplate.batchUpdate(deleteSql, params);
		
	}

	public void batchByNamedParameterJdbcTemplate() {
		NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(getJdbcTemplate());
	    String updateSql = "update tab_item set itemname = :itemname where id = :id";
	    Item model1 = new Item();
	    Item model2 = new Item();
	    Item model3 = new Item();
	    Item model4 = new Item();
		model1.setId(101l);
		model2.setId(102l);
		model3.setId(103l);
		model4.setId(104l);
		
		model1.setItemname("I9100");
		model2.setItemname("I9101");
		model3.setItemname("I9102");
		model4.setItemname("I9103");
		
	    SqlParameterSource[] params = SqlParameterSourceUtils.createBatch(new Object[] {model1, model2, model3, model4});  
	    namedParameterJdbcTemplate.batchUpdate(updateSql, params);
	    
	}

	/**
	 * 通过batchUpdate(String sql, final BatchPreparedStatementSetter pss)方法进行批处理，
	 * 该方式使用预编译语句，然后通过BatchPreparedStatementSetter实现进行设值（setValues）
	 * 及指定批处理大小（getBatchSize）。
	 */
	public void batchByJdbcTemplate() {
		String insertSql = "insert into tab_item values(?,?,?)";
		Object[] arg1 = {101, "SUMSUNG", "GAS1"};
		Object[] arg2 = {102, "SUMSUNG", "GAS2"};
		Object[] arg3 = {103, "SUMSUNG", "GAS3"};
		Object[] arg4 = {104, "SUMSUNG", "GAS4"};
		final List<Object[]> list = new ArrayList<Object[]>();
		list.add(arg1);
		list.add(arg2);
		list.add(arg3);
		list.add(arg4);
		
		int[] rows = getJdbcTemplate().batchUpdate(insertSql, new BatchPreparedStatementSetter() {
			
			@Override
			public void setValues(PreparedStatement ps, int i) throws SQLException {
				Object[] obj = list.get(i);
				ps.setInt(1, (Integer) obj[0]);
				ps.setString(2, (String) obj[1]);
				ps.setString(3, (String)obj[2]);
			}
			
			@Override
			public int getBatchSize() {//返回批量操作数最大值
				return list.size();
			}
		});
		System.out.println(getJdbcTemplate().getFetchSize());
		System.out.println(getJdbcTemplate().getQueryTimeout());
		for (int i = 0; i < rows.length; i++) {
			System.out.println(rows[i]);
		}
		
		Assert.isTrue(list.size() == getJdbcTemplate().queryForInt("select count(1) from tab_item where itemno = 'SUMSUNG'"), "批量更新失败");
	}
}

...
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
	    <property name="locations">  
	      <list>  
	          <value>classpath:application.properties</value>  
	      </list>  
	    </property>
    </bean>
    
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<!-- Connection Info -->
		<property name="driverClassName" value="${db.driver.class}" />
		<property name="url" value="${db.url}" />
		<property name="username" value="${db.username}" />
		<property name="password" value="${db.password}" />

		<!-- Connection Pooling Info -->
		<property name="initialSize" value="${proxool.initialSize}" />
		<property name="maxActive" value="${proxool.maxActive}" />
		<property name="maxIdle" value="${proxool.maxIdle}" />
		<property name="minIdle" value="${proxool.minIdle}" />
		<property name="maxWait" value="500" />
		<property name="poolPreparedStatements" value="false" />
	</bean>
	
	<bean id="abstractDao" abstract="true">  
    	<property name="dataSource" ref="dataSource"/>  
	</bean>
	
	<bean id="dao1" class="com.chou.jdbc.JdbcTemplateDao" parent="abstractDao"/>
	<bean id="dao2" class="com.chou.jdbc.NamedParameterJdbcTemplateDao" parent="abstractDao"/>
	<bean id="dao3" class="com.chou.jdbc.SimpleJdbcTemplateDao" parent="abstractDao"/>
	<bean id="dao4" class="com.chou.jdbc.BatchExecuteDao" parent="abstractDao"/>
...

db.driver.class=oracle.jdbc.driver.OracleDriver
db.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
db.username=db_test
db.password=db_test

#连接池连接数初始值
proxool.initialSize=2

#连接池最大连接数量
proxool.maxActive=10

#连接池最大空闲值，释放多余的不用的连接，释放到多少为止
proxool.maxIdle=5

#连接池最小空闲值，当空闲连接数小于这个数的时候，连接池就会去申请一些连接以免高峰期来不及申请
proxool.minIdle=1

Spring JDBC自身提供了以下DataSource实现：

DriverManagerDataSource ：简单封装了DriverManager获取数据库连接；通过DriverManager的getConnection方法获取数据库连接；
SingleConnectionDataSource ：内部封装了一个连接，该连接使用后不会关闭，且不能在多线程环境中使用，一般用于测试；
LazyConnectionDataSourceProxy ：包装一个DataSource，用于延迟获取数据库连接，只有在真正创建Statement等时才获取连接，因此再说实际项目中最后使用该代理包装原始DataSource从而使得只有在真正需要连接时才去获取。

Spring也能通过第三方提供的连接池实现主要有C3P0、Proxool、DBCP
DBCP没有自动的去回收空闲连接的功能
C3P0有自动回收空闲连接功能,它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。

DataSourceUtils：
Spring JDBC抽象框架内部都是通过它的getConnection(DataSource dataSource)方法获取数据库连接，releaseConnection(Connection con, DataSource dataSource) 用于释放数据库连接，DataSourceUtils用于支持Spring管理事务，只有使用DataSourceUtils获取的连接才具有Spring管理事务。

SpringJdbc在插入数据时也可以获取数据库自动生成的主键，具体用法可以参考博客：http://jinnianshilongnian.iteye.com/blog/1428149