您的位置：首页 > 编程语言 > Java开发

《Spring 5 官方文档》15.使用JDBC实现数据访问

2017-10-16 10:32 435 查看

《Spring5官方文档》15.使用JDBC实现数据访问

15.1介绍SpringJDBC框架

表格13.1很清楚的列举了Spring框架针对JDBC操作做的一些抽象和封装。里面区分了哪些操作Spring已经帮你做好了、哪些操作是应用开发者需要自己负责的.

表13.1.SpringJDBC–框架和应用开发者各自分工

操作	Spring	开发者
定义连接参数		X
打开连接	X
指定SQL语句		X
声明参数和提供参数值		X
准备和执行语句	X
返回结果的迭代（如果有）	X
具体操作每个迭代		X
异常处理	X
事务处理	X
关闭连接、语句和结果集	X

一句话、Spring帮你屏蔽了很多JDBC底层繁琐的API操作、让你更方便的开发

15.1.1选择一种JDBC数据库访问方法

JDBC数据库访问有几种基本的途径可供选择。除了JdbcTemplate的三种使用方式外，新的SimpleJdbcInsert和SimplejdbcCall调用类通过优化数据库元数据（来简化JDBC操作），还有一种更偏向于面向对象的RDBMS对象风格的方法、有点类似于JDO的查询设计。即使你已经选择了其中一种方法、你仍然可以混合使用另外一种方法的某一个特性。所有的方法都需要JDBC2.0兼容驱动的支持，一些更高级的特性则需要使用JDBC3.0驱动支持。

JdbcTemplate是经典的SpringJDBC访问方式，也是最常用的。这是“最基础”的方式、其他所有方式都是在JdbcTemplate的基础之上封装的。
NamedParameterJdbcTemplate在原有JdbcTemplate的基础上做了一层包装支持命名参数特性、用于替代传统的JDBC“？”占位符。当SQL语句中包含多个参数时使用这种方式能有更好的可读性和易用性
SimpleJdbcInsert和SimpleJdbcCall操作类主要利用JDBC驱动所提供的数据库元数据的一些特性来简化数据库操作配置。这种方式简化了编码、你只需要提供表或者存储过程的名字、以及和列名相匹配的参数Map。但前提是数据库需要提供足够的元数据。如果数据库没有提供这些元数据，需要开发者显式配置参数的映射关系。
RDBMS对象的方式包含MappingSqlQuery,SqlUpdate和StoredProcedure，需要你在初始化应用数据访问层时创建可重用和线程安全的对象。这种方式设计上类似于JDO查询、你可以定义查询字符串，声明参数及编译查询语句。一旦完成这些工作之后，执行方法可以根据不同的传入参数被多次调用。
15.1.2包层级

Spring的JDBC框架一共包含4种不同类型的包、包括core,datasource,object和support.

org.springframework.jdbc.core包含JdbcTemplate类和它各种回调接口、外加一些相关的类。它的一个子包

org.springframework.jdbc.core.simple包含SimpleJdbcInsert和SimpleJdbcCall等类。另一个叫org.springframework.jdbc.core.namedparam的子包包含NamedParameterJdbcTemplate及它的一些工具类。详见：

15.2：“使用JDBC核心类控制基础的JDBC处理过程和异常处理机制”

15.4：“JDBC批量操作”

15.5：“利用SimpleJdbc类简化JDBC操作”.

org.springframework.jdbc.datasource包包含DataSource数据源访问的工具类，以及一些简单的DataSource实现用于测试和脱离JavaEE容器运行的JDBC代码。子包org.springfamework.jdbc.datasource.embedded提供Java内置数据库例如HSQL,H2,和Derby的支持。详见：

15.3：“控制数据库连接”

15.8：“内置数据库支持”.

org.springframework.jdbc.object包含用于在RDBMS查询、更新和存储过程中创建线程安全及可重用的对象类。详见15.6：“像Java对象那样操作JDBC”；这种方式类似于JDO的查询方式，不过查询返回的对象是与数据库脱离的。此包针对JDBC做了很多上层封装、而底层依赖于org.springframework.jdbc.core包。

org.springframework.jdbc.support包含SQLException的转换类和一些工具类。JDBC处理过程中抛出的异常会被转换成org.springframework.dao里面定义的异常类。这意味着SpringJDBC抽象层的代码不需要实现JDBC或者RDBMS特定的错误处理方式。所有转换的异常都没有被捕获，而是让开发者自己处理异常、具体的话既可以捕获异常也可以直接抛给上层调用者

详见：15.2.3：“SQL异常转换器”.

15.2使用JDBC核心类控制基础的JDBC处理过程和异常处理机制

15.2.1JdbcTemplate

JdbcTemplate是JDBCcore包里面的核心类。它封装了对资源的创建和释放，可以帮你避免忘记关闭连接等常见错误。它也包含了核心JDBC工作流的一些基础工作、例如执行和声明语句，而把SQL语句的生成以及查询结果的提取工作留给应用代码。JdbcTemplate执行查询、更新SQL语句和调用存储过程，运行结果集迭代和抽取返回参数值。它也可以捕获JDBC异常并把它们转换成更加通用、解释性更强的异常层次结构、这些异常都定义在org.springframework.dao包里面。

当你在代码中使用了JdbcTemplate类，你只需要实现回调接口。PreparedStatementCreator回调接口通过传入的Connection类（该类包含SQL和任何必要的参数）创建已声明的语句。CallableStatementCreator也提供类似的方式、该接口用于创建回调语句。RowCallbackHandler用于获取结果集每一行的值。

可以在DAO实现类中通过传入DataSource引用来完成JdbcTemplate的初始化；也可以在SpringIOC容器里面配置、作为DAObean的依赖Bean配置。

备注：DataSource最好在SpringIOC容器里作为Bean配置起来。在上面第一种情况下，DataSourcebean直接传给相关的服务；第二种情况下DataSourcebean传递给JdbcTemplatebean。

JdbcTemplate中使用的所有SQL以“DEBUG”级别记入日志（一般情况下日志的归类是JdbcTemplate对应的全限定类名，不过如果需要对JdbcTemplate进行定制的话，可能是它的子类名）

JdbcTemplate使用示例

这一节提供了JdbcTemplate类的一些使用例子。这些例子没有囊括JdbcTemplate可提供的所有功能；全部功能和用法请详见相关的javadocs.

查询(SELECT)

下面是一个简单的例子、用于获取关系表里面的行数

1	int rowCount= this .jdbcTemplate.queryForObject( "selectcount(*)fromt_actor" ,Integer. class );

使用绑定变量的简单查询：

1	int countOfActorsNamedJoe= this .jdbcTemplate.queryForObject(

2	"selectcount(*)fromt_actorwherefirst_name=?" ,Integer. class , "Joe" );

String查询：

1	StringlastName= this .jdbcTemplate.queryForObject(

2	"selectlast_namefromt_actorwhereid=?" ,

3	new Object[]{1212L},String. class );

查询和填充领域模型：

01	Actoractor= this .jdbcTemplate.queryForObject(

02	"selectfirst_name,last_namefromt_actorwhereid=?" ,

03	new Object[]{1212L},

04	new RowMapper<Actor>(){

05	public ActormapRow(ResultSetrs, int rowNum) throws SQLException{

06	Actoractor= new Actor();

07	actor.setFirstName(rs.getString( "first_name" ));

08	actor.setLastName(rs.getString( "last_name" ));

09	return actor;

});

查询和填充多个领域对象：

01	List<Actor>actors= this .jdbcTemplate.query(

02	"selectfirst_name,last_namefromt_actor" ,

03	new RowMapper<Actor>(){

04	public ActormapRow(ResultSetrs, int rowNum) throws SQLException{

05	Actoractor= new Actor();

06	actor.setFirstName(rs.getString( "first_name" ));

07	actor.setLastName(rs.getString( "last_name" ));

08	return actor;

});

如果上面的两段代码实际存在于相同的应用中，建议把RowMapper匿名类中重复的代码抽取到单独的类中（通常是一个静态类），方便被DAO方法引用。例如，上面的代码例子更好的写法如下：

01	public List<Actor>findAllActors(){

02	return this .jdbcTemplate.query( "selectfirst_name,last_namefromt_actor" , new ActorMapper());

05	private static final class ActorMapper implements RowMapper<Actor>{

07	public ActormapRow(ResultSetrs, int rowNum) throws SQLException{

08	Actoractor= new Actor();

09	actor.setFirstName(rs.getString( "first_name" ));

10	actor.setLastName(rs.getString( "last_name" ));

11	return actor;

使用jdbcTemplate实现增删改

你可以使用update(..)方法实现插入，更新和删除操作。参数值可以通过可变参数或者封装在对象内传入。

1	this .jdbcTemplate.update(

2	"insertintot_actor(first_name,last_name)values(?,?)" ,

3	"Leonor" , "Watling" );

1	this .jdbcTemplate.update(

2	"updatet_actorsetlast_name=?whereid=?" ,

3	"Banjo" ,5276L);

<
227e7
divclass="lines">

1	this .jdbcTemplate.update(

2	"deletefromactorwhereid=?" ,

3	Long.valueOf(actorId));

其他jdbcTemplate操作

你可以使用execute(..)方法执行任何SQL，甚至是DDL语句。这个方法可以传入回调接口、绑定可变参数数组等。

1	this .jdbcTemplate.execute( "createtablemytable(idinteger,namevarchar(100))" );

下面的例子调用一段简单的存储过程。更复杂的存储过程支持文档后面会有描述。

1	this .jdbcTemplate.update(

2	"callSUPPORT.REFRESH_ACTORS_SUMMARY(?)" ,

3	Long.valueOf(unionId));

JdbcTemplate最佳实践

JdbcTemplate实例一旦配置之后是线程安全的。这点很重要因为这样你就能够配置JdbcTemplate的单例，然后安全的将其注入到多个DAO中（或者repositories）。JdbcTemplate是有状态的，内部存在对DataSource的引用，但是这种状态不是会话状态。

使用JdbcTemplate类的常用做法是在你的Spring配置文件里配置好一个DataSource，然后将其依赖注入进你的DAO类中（NamedParameterJdbcTemplate也是如此）。JdbcTemplate在DataSource的Setter方法中被创建。就像如下DAO类的写法一样：

01	public class JdbcCorporateEventDao implements CorporateEventDao{

03	private JdbcTemplatejdbcTemplate;

05	public void setDataSource(DataSourcedataSource){

06	this .jdbcTemplate= new JdbcTemplate(dataSource);

09	//JDBC-backedimplementationsofthemethodsontheCorporateEventDaofollow...

相关的XML配置如下：

01	<?xmlversion= "1.0" encoding= "UTF-8" ?>

02	<beansxmlns= "http://www.springframework.org/schema/beans"

03	xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"

04	xmlns:context= "http://www.springframework.org/schema/context"

05	xsi:schemaLocation="

06	http: //www.springframework.org/schema/beans

07	http: //www.springframework.org/schema/beans/spring-beans.xsd

08	http: //www.springframework.org/schema/context

09	http: //www.springframework.org/schema/context/spring-context.xsd">

11	<!--Scanswithinthebase package oftheapplication for @Component classestoconfigureasbeans-->

12	<context:component-scanbase- package = "org.springframework.docs.test" />

14	<beanid= "dataSource" class = "org.apache.commons.dbcp.BasicDataSource" destroy-method= "close" >

15	<propertyname= "driverClassName" value= "${jdbc.driverClassName}" />

16	<propertyname= "url" value= "${jdbc.url}" />

17	<propertyname= "username" value= "${jdbc.username}" />

18	<propertyname= "password" value= "${jdbc.password}" />

</bean>

21	<context:property-placeholderlocation= "jdbc.properties" />

</beans>

如果你使用Spring的JdbcDaoSupport类，许多JDBC相关的DAO类都从该类继承过来，这个时候相关子类需要继承JdbcDaoSupport类的setDataSource方法。当然你也可以选择不从这个类继承，JdbcDaoSupport本身只是提供一些便利性。

无论你选择上面提到的哪种初始方式，当你在执行SQL语句时一般都不需要重新创建JdbcTemplate实例。JdbcTemplate一旦被配置后其实例都是线程安全的。当你的应用需要访问多个数据库时你可能也需要多个JdbcTemplate实例，相应的也需要多个DataSources，同时对应多个JdbcTemplates配置。

15.2.2NamedParameterJdbcTemplate

NamedParameterJdbcTemplate提供对JDBC语句命名参数的支持，而普通的JDBC语句只能使用经典的‘?’参数。NamedParameterJdbcTemplate内部包装了JdbcTemplate，很多功能是直接通过JdbcTemplate来实现的。本节主要描述NamedParameterJdbcTemplate不同于JdbcTemplate的点；即通过使用命名参数来操作JDBC

01	//someJDBC-backedDAOclass...

02	private NamedParameterJdbcTemplatenamedParameterJdbcTemplate;

04	public void setDataSource(DataSourcedataSource){

05	this .namedParameterJdbcTemplate= new NamedParameterJdbcTemplate(dataSource);

08	public int countOfActorsByFirstName(StringfirstName){

10	Stringsql= "selectcount(*)fromT_ACTORwherefirst_name=:first_name" ;

12	SqlParameterSourcenamedParameters= new MapSqlParameterSource( "first_name" ,firstName);

14	return this .namedParameterJdbcTemplate.queryForObject(sql,namedParameters,Integer. class );

上面代码块可以看到SQL变量中命名参数的标记用法，以及namedParameters变量的相关赋值（类型为MapSqlParameterSource）

除此以外，你还可以在NamedParameterJdbcTemplate中传入Map风格的命名参数及相关的值。NamedParameterJdbcTemplate类从NamedParameterJdbcOperations接口实现的其他方法用法是类似的，这里就不一一叙述了。

下面是一个Map风格的例子：

01	//someJDBC-backedDAOclass...

02	private NamedParameterJdbcTemplatenamedParameterJdbcTemplate;

04	public void setDataSource(DataSourcedataSource){

05	this .namedParameterJdbcTemplate= new NamedParameterJdbcTemplate(dataSource);

08	public int countOfActorsByFirstName(StringfirstName){

10	Stringsql= "selectcount(*)fromT_ACTORwherefirst_name=:first_name" ;

12	Map<String,String>namedParameters=Collections.singletonMap( "first_name" ,firstName);

14	return this .namedParameterJdbcTemplate.queryForObject(sql,namedParameters,Integer. class );

与NamedParameterJdbcTemplate相关联的SqlParameterSource接口提供了很有用的功能（两者在同一个包里面）。在上面的代码片段中你已经看到了这个接口的一个实现例子（就是MapSqlParameterSource类）。SqlParameterSource类是NamedParameterJdbcTemplate

类的数值值来源。MapSqlParameterSource实现非常简单、只是适配了java.util.Map，其中Key就是参数名字，Value就是参数值。

另外一个SqlParameterSource的实现是BeanPropertySqlParameterSource类。这个类封装了任意一个JavaBean（也就是任意符合JavaBen规范的实例），在这个实现中，使用了JavaBean的属性作为命名参数的来源。

01	public class Actor{

03	private Longid;

04	private StringfirstName;

05	private StringlastName;

07	public StringgetFirstName(){

08	return this .firstName;

11	public StringgetLastName(){

12	return this .lastName;

15	public LonggetId(){

16	return this .id;

19	//settersomitted...

01	//someJDBC-backedDAOclass...

02	private NamedParameterJdbcTemplatenamedParameterJdbcTemplate;

04	public void setDataSource(DataSourcedataSource){

05	this .namedParameterJdbcTemplate= new NamedParameterJdbcTemplate(dataSource);

08	public int countOfActors(ActorexampleActor){

10	//noticehowthenamedparametersmatchthepropertiesoftheabove'Actor'class

11	Stringsql= "selectcount(*)fromT_ACTORwherefirst_name=:firstNameandlast_name=:lastName" ;

13	SqlParameterSourcenamedParameters= new BeanPropertySqlParameterSource(exampleActor);

15	return this .namedParameterJdbcTemplate.queryForObject(sql,namedParameters,Integer. class );

之前提到过NamedParameterJdbcTemplate本身包装了经典的JdbcTemplate模板。如果你想调用只存在于JdbcTemplate类中的方法，你可以使用getJdbcOperations（）方法、该方法返回JdbcOperations接口，通过这个接口你可以调用内部JdbcTemplate的方法。

NamedParameterJdbcTemplate类在应用上下文的使用方式也可见：“JdbcTemplate最佳实践”

15.2.3SQLExceptionTranslator

SQLExceptionTranslator接口用于在SQLExceptions和spring自己的org.springframework.dao.DataAccessException之间做转换，要处理批量更新或者从文件中这是为了屏蔽底层的数据访问策略。其实现可以是比较通用的（例如，使用JDBC的SQLState编码），或者是更精确专有的（例如，使用Oracle的错误类型编码）

SQLExceptionTranslator接口的默认实现是SQLErrorCodeSQLExceptionTranslator，该实现使用的是指定数据库厂商的错误编码，因为要比SQLState的实现更加精确。错误码转换过程基于JavaBean类型的SQLErrorCodes。这个类通过SQLErrorCodesFactory创建和返回，SQLErrorCodesFactory是一个基于sql-error-codes.xml配置内容来创建SQLErrorCodes的工厂类。该配置中的数据库厂商代码基于Database
MetaData信息中返回的数据库产品名（DatabaseProductName），最终使用的就是你正在使用的实际数据库中错误码。

SQLErrorCodeSQLExceptionTranslator按以下的顺序来匹配规则：

备注：SQLErrorCodesFactory是用于定义错误码和自定义异常转换的缺省工厂类。错误码参照Classpath下配置的sql-error-codes.xml文件内容，相匹配的SQLErrorCodes实例基于正在使用的底层数据库的元数据名称

是否存在自定义转换的子类。通常直接使用SQLErrorCodeSQLExceptionTranslator就可以了，因此此规则一般不会生效。只有你真正自己实现了一个子类才会生效。
是否存在SQLExceptionTranslator接口的自定义实现，通过SQLErrorCodes类的customSqlExceptionTranslator属性指定
SQLErrorCodes的customTranslations属性数组、类型为CustomSQLErrorCodesTranslation类实例列表、能否被匹配到
错误码被匹配到
使用兜底的转换器。SQLExceptionSubclassTranslator是缺省的兜底转换器。如果此转换器也不存在的话只能使用SQLStateSQLExceptionTranslator
你可以继承SQLErrorCodeSQLExceptionTranslator：

1	public class CustomSQLErrorCodesTranslator extends SQLErrorCodeSQLExceptionTranslator{

3	protected DataAccessExceptioncustomTranslate(Stringtask,Stringsql,SQLExceptionsqlex){

4	if (sqlex.getErrorCode()==- 12345 ){

5	return new DeadlockLoserDataAccessException(task,sqlex);

7	return null ;

这个例子中，特定的错误码-12345被识别后单独转换，而其他的错误码则通过默认的转换器实现来处理。在使用自定义转换器时，有必要通过setExceptionTranslator方法传入JdbcTemplate，并且使用JdbcTemplate来做所有的数据访问处理。下面是一个如何使用自定义转换器的例子

01	private JdbcTemplatejdbcTemplate;

03	public void setDataSource(DataSourcedataSource){

05	//createaJdbcTemplateandsetdatasource

06	this .jdbcTemplate= new JdbcTemplate();

07	this .jdbcTemplate.setDataSource(dataSource);

09	//createacustomtranslatorandsettheDataSourceforthedefaulttranslationlookup

10	CustomSQLErrorCodesTranslatortr= new CustomSQLErrorCodesTranslator();

11	tr.setDataSource(dataSource);

12	this .jdbcTemplate.setExceptionTranslator(tr);

16	public void updateShippingCharge( long orderId, long pct){

17	//usethepreparedJdbcTemplateforthisupdate

18	this .jdbcTemplate.update( "updateorders" +

19	"setshipping_charge=shipping_charge*?/100" +

20	"whereid=?" ,pct,orderId);

自定义转换器需要传入dataSource对象为了能够获取sql-error-codes.xml定义的错误码

15.2.4执行SQL语句

执行一条SQL语句非常方便。你只需要依赖DataSource和JdbcTemplate，包括JdbcTemplate提供的工具方法。

下面的例子展示了如何创建一个新的数据表，虽然只有几行代码、但已经完全可用了：

01	import javax.sql.DataSource;

02	import org.springframework.jdbc.core.JdbcTemplate;

04	public class ExecuteAStatement{

06	private JdbcTemplatejdbcTemplate;

08	public void setDataSource(DataSourcedataSource){

09	this .jdbcTemplate= new JdbcTemplate(dataSource);

12	public void doExecute(){

13	this .jdbcTemplate.execute( "createtablemytable(idinteger,namevarchar(100))" );

15.2.5查询

一些查询方法会返回一个单一的结果。使用queryForObject(..)返回结果计数或特定值。当返回特定值类型时，将Java类型作为方法参数传入、最终返回的JDBC类型会被转换成相应的Java类型。如果这个过程中间出现类型转换错误，则会抛出InvalidDataAccessApiUsageException的异常。下面的例子包含两个查询方法，一个返回int类型、另一个返回了String类型。

01	import javax.sql.DataSource;

02	import org.springframework.jdbc.core.JdbcTemplate;

04	public class RunAQuery{

06	private JdbcTemplatejdbcTemplate;

08	public void setDataSource(DataSourcedataSource){

09	this .jdbcTemplate= new JdbcTemplate(dataSource);

12	public int getCount(){

13	return this .jdbcTemplate.queryForObject( "selectcount(*)frommytable" ,Integer. class );

16	public StringgetName(){

17	return this .jdbcTemplate.queryForObject( "selectnamefrommytable" ,String. class );

除了返回单一查询结果的方法外，其他方法返回一个列表、列表中每一项代表查询返回的行记录。其中最通用的方式是queryForList(..)，返回一个列表，列表每一项是一个Map类型，包含数据库对应行每一列的具体值。下面的代码块给上面的例子添加一个返回所有行的方法：

1	private JdbcTemplatejdbcTemplate;

3	public void setDataSource(DataSourcedataSource){

4	this .jdbcTemplate= new JdbcTemplate(dataSource);

7	public List<Map<String,Object>>getList(){

8	return this .jdbcTemplate.queryForList( "select*frommytable" );

返回的列表结果数据格式是这样的：

1	[{name=Bob,id= 1 },{name=Mary,id= 2 }]

15.2.6更新数据库

下面的例子根据主键更新其中一列值。在这个例子中，一条SQL语句包含行参数的占位符。参数值可以通过可变参数或者对象数组传入。元数据类型需要显式或者自动装箱成对应的包装类型

01	import javax.sql.DataSource;

03	import org.springframework.jdbc.core.JdbcTemplate;

05	public class ExecuteAnUpdate{

07	private JdbcTemplatejdbcTemplate;

09	public void setDataSource(DataSourcedataSource){

10	this .jdbcTemplate= new JdbcTemplate(dataSource);

13	public void setName( int id,Stringname){

14	this .jdbcTemplate.update( "updatemytablesetname=?whereid=?" ,name,id);

15.2.7获取自增Key

update()方法支持获取数据库自增Key。这个支持已成为JDBC3.0标准之一、更多细节详见13.6章。这个方法使用PreparedStatementCreator作为其第一个入参，该类可以指定所需的insert语句。另外一个参数是KeyHolder，包含了更新操作成功之后产生的自增Key。这不是标准的创建PreparedStatement的方式。下面的例子可以在Oracle上面运行，但在其他平台上可能就不行了。

01	final StringINSERT_SQL= "insertintomy_test(name)values(?)" ;

02	final Stringname= "Rob" ;

04	KeyHolderkeyHolder= new GeneratedKeyHolder();

05	jdbcTemplate.update(

06	new PreparedStatementCreator(){

07	public PreparedStatementcreatePreparedStatement(Connectionconnection) throws SQLException{

08	PreparedStatementps=connection.prepareStatement(INSERT_SQL, new String[]{ "id" });

09	ps.setString( 1 ,name);

10	return ps;

},

13	keyHolder);

15	//keyHolder.getKey()nowcontainsthegeneratedkey

15.3控制数据库连接

15.3.1DataSource

Spring用DataSource来保持与数据库的连接。DataSource是JDBC规范的一部分同时是一种通用的连接工厂。它使得框架或者容器对应用代码屏蔽连接池或者事务管理等底层逻辑。作为开发者，你无需知道连接数据库的底层逻辑；这只是创建datasource的管理员该负责的模块。在开发测试过程中你可能需要同时扮演双重角色，但最终上线时你不需要知道生产数据源是如何配置的。

当使用SpringJDBC时，你可以通过JNDI获取数据库数据源、也可以利用第三方依赖包的连接池实现来配置。比较受欢迎的三方库有ApacheJakartaCommonsDBCP和C3P0。在Spring产品内，有自己的数据源连接实现，但仅仅用于测试目的，同时并没有使用到连接池。

这一节使用了Spring的DriverManagerDataSource实现、其他更多的实现会在后面提到。

注意：仅仅使用DriverManagerDataSource类只是为了测试目的、因为此类没有连接池功能，因此在并发连接请求时性能会比较差

通过DriverManagerDataSource获取数据库连接的方式和传统JDBC是类似的。首先指定JDBC驱动的类全名，DriverManager会据此来加载驱动类。接下来、提供JDBC驱动对应的URL名称。（可以从相应驱动的文档里找到具体的名称）。然后传入用户名和密码来连接数据库。下面是一个具体配置DriverManagerDataSource连接的Java代码块:

1	DriverManagerDataSourcedataSource= new DriverManagerDataSource();

2	dataSource.setDriverClassName( "org.hsqldb.jdbcDriver" );

3	dataSource.setUrl( "jdbc:hsqldb:hsql://localhost:" );

4	dataSource.setUsername( "sa" );

5	dataSource.setPassword( "" );

接下来是相关的XML配置：

1	<beanid= "dataSource" class = "org.springframework.jdbc.datasource.DriverManagerDataSource" >

2	<propertyname= "driverClassName" value= "${jdbc.driverClassName}" />

3	<propertyname= "url" value= "${jdbc.url}" />

4	<propertyname= "username" value= "${jdbc.username}" />

5	<propertyname= "password" value= "${jdbc.password}" />

</bean>

8	<context:property-placeholderlocation= "jdbc.properties" />

下面的例子展示的是DBCP和C3P0的基础连接配置。如果需要连接更多的连接池选项、请查看各自连接池实现的具体产品文档

DBCP配置：

1	<beanid= "dataSource" class = "org.apache.commons.dbcp.BasicDataSource" destroy-method= "close" >

2	<propertyname= "driverClassName" value= "${jdbc.driverClassName}" />

3	<propertyname= "url" value= "${jdbc.url}" />

4	<propertyname= "username" value= "${jdbc.username}" />

5	<propertyname= "password" value= "${jdbc.password}" />

</bean>

8	<context:property-placeholderlocation= "jdbc.properties" />

C3P0配置：

1	<beanid= "dataSource" class = "com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method= "close" >

2	<propertyname= "driverClass" value= "${jdbc.driverClassName}" />

3	<propertyname= "jdbcUrl" value= "${jdbc.url}" />

4	<propertyname= "user" value= "${jdbc.username}" />

5	<propertyname= "password" value= "${jdbc.password}" />

</bean>

8	<context:property-placeholderlocation= "jdbc.properties" />

15.3.2DataSourceUtils

DataSourceUtils类是一个方便有用的工具类，提供了从JNDI获取和关闭连接等有用的静态方法。它支持线程绑定的连接、例如：使用DataSourceTransactionManager的时候，将把数据库连接绑定到当前的线程上。

15.3.3SmartDataSource

实现SmartDataSource接口的实现类需要能够提供到关系数据库的连接。它继承了DataSource接口，允许使用它的类查询是否在某个特定的操作后需要关闭连接。这在当你需要重用连接时比较有用。

15.3.4AbstractDataSource

AbstractDataSource是SpringDataSource实现的基础抽象类，封装了DataSource的基础通用功能。你可以继承AbstractDataSource自定义DataSource实现。

15.3.5SingleConnectionDataSource

SingleConnectionDataSource实现了SmartDataSource接口、内部封装了一个在每次使用后都不会关闭的单一连接。显然，这种场景下无法支持多线程。

为了防止客户端代码误以为数据库连接来自连接池（就像使用持久化工具时一样）错误的调用close方法，你应将suppressClose设置为true。这样，通过该类获取的将是代理连接（禁止关闭）而不是原有的物理连接。需要注意你不能将这个类强制转换成Oracle等数据库的原生连接。

这个类主要用于测试目的。例如，他使得测试代码能够脱离应用服务器，很方便的在单一的JNDI环境下调试。和DriverManagerDataSource相反，它总是重用相同的连接，这是为了避免在测试过程中创建过多的物理连接。

15.3.6DriverManagerDataSource

DriverManagerDataSource类实现了标准的DataSource接口，可以通过JavaBean属性来配置原生的JDBC驱动，并且每次都返回一个新的连接。

这个实现对于测试和JavaEE容器以外的独立环境比较有用，无论是作为一个在SpringIOC容器内的DataSourceBean，或是在单一的JNDI环境中。由于Connection.close()仅仅只是简单的关闭数据库连接，因此任何能够操作DataSource的持久层代码都能很好的工作。但是，使用JavaBean类型的连接池，比如commons-dbcp往往更简单、即使是在测试环境下也是如此，因此更推荐commons-dbcp。

15.3.7TransactionAwareDataSourceProxy

TransactionAwareDataSourceProxy会创建一个目标DataSource的代理，内部包装了DataSource，在此基础上添加了Spring事务管理功能。有点类似于JavaEE服务器中提供的JNDI事务数据源。

注意：一般情况下很少用到这个类，除非现有代码在被调用的时候需要一个标准的JDBCDataSource接口实现作为参数。在这种场景下，使用proxy可以仍旧重用老代码，同时能够有Spring管理事务的能力。更多的场景下更推荐使用JdbcTemplate和DataSourceUtils等更高抽象的资源管理类.

（更多细节请查看TransactionAwareDataSourceProxy的JavaDoc）

15.3.8DataSourceTransactionManager

DataSourceTransactionManager类实现了PlatformTransactionManager接口。它将JDBC连接从指定的数据源绑定到当前执行的线程中，

允许一个线程连接对应一个数据源。

应用代码需要通过DataSourceUtils.getConnection(DataSource)来获取JDBC连接，而不是通过JavaEE标准的DataSource.getConnection来获取。它会抛出org.springframework.dao的运行时异常而不是编译时SQL异常。所有框架类像JdbcTemplate都默认使用这个策略。如果不需要和这个DataSourceTransactionManager类一起使用，DataSourceUtils提供的功能跟一般的数据库连接策略没有什么两样，因此它可以在任何场景下使用。

DataSourceTransactionManager支持自定义隔离级别，以及JDBC查询超时机制。为了支持后者，应用代码必须在每个创建的语句中使用JdbcTemplate或是调用DataSourceUtils.applyTransactionTimeout(..)方法

在单一的资源使用场景下它可以替代JtaTransactionManager，不需要要求容器去支持JTA。如果你严格遵循连接查找的模式的话、可以通过配置来做彼此切换。JTA本身不支持自定义隔离级别！

15.4JDBC批量操作

大多数JDBC驱动在针对同一SQL语句做批处理时能够获得更好的性能。批量更新操作可以节省数据库的来回传输次数。

15.4.1使用JdbcTemplate来进行基础的批量操作

通过JdbcTemplate实现批处理需要实现特定接口的两个方法，BatchPreparedStatementSetter，并且将其作为第二个参数传入到batchUpdate方法调用中。使用getBatchSize提供当前批量操作的大小。使用setValues方法设置语句的Value参数。这个方法会按getBatchSize设置中指定的调用次数。下面的例子中通过传入列表来批量更新actor表。在这个例子中整个列表使用了批量操作：

01	public class JdbcActorDao implements ActorDao{

02	private JdbcTemplatejdbcTemplate;

04	public void setDataSource(DataSourcedataSource){

05	this .jdbcTemplate= new JdbcTemplate(dataSource);

08	public int []batchUpdate( final List<Actor>actors){

09	int []updateCounts=jdbcTemplate.batchUpdate( "updatet_actorsetfirst_name=?," +

10	"last_name=?whereid=?" ,

11	new BatchPreparedStatementSetter(){

12	public void setValues(PreparedStatementps, int i) throws SQLException{

13	ps.setString( 1 ,actors.get(i).getFirstName());

14	ps.setString( 2 ,actors.get(i).getLastName());

15	ps.setLong( 3 ,actors.get(i).getId().longValue());

18	public int getBatchSize(){

19	return actors.size();

});

22	return updateCounts;

25	//...additionalmethods

如果你需要处理批量更新或者从文件中批量读取，你可能需要确定一个合适的批处理大小，但是最后一次批处理可能达不到这个大小。在这种场景下你可以使用InterruptibleBatchPreparedStatementSetter接口，允许在输入流耗尽之后终止批处理，isBatchExhausted方法使得你可以指定批处理结束时间。

15.4.2对象列表的批量处理

JdbcTemplate和NamedParameterJdbcTemplate都提供了批量更新的替代方案。这个时候不是实现一个特定的批量接口，而是在调用时传入所有的值列表。框架会循环访问这些值并且使用内部的SQL语句setter方法。你是否已声明参数对应API是不一样的。针对已声明参数你需要传入qlParameterSource数组，每项对应单次的批量操作。你可以使用SqlParameterSource.createBatch方法来创建这个数组，传入JavaBean数组或是包含参数值的Map数组。

下面是一个使用已声明参数的批量更新例子：

01	public class JdbcActorDao implements ActorDao{

02	private NamedParameterTemplatenamedParameterJdbcTemplate;

04	public void setDataSource(DataSourcedataSource){

05	this .namedParameterJdbcTemplate= new NamedParameterJdbcTemplate(dataSource);

08	public int []batchUpdate( final List<Actor>actors){

09	SqlParameterSource[]batch=SqlParameterSourceUtils.createBatch(actors.toArray());

10	int []updateCounts=namedParameterJdbcTemplate.batchUpdate(

11	"updatet_actorsetfirst_name=:firstName,last_name=:lastNamewhereid=:id" ,

batch);

13	return updateCounts;

16	//...additionalmethods

对于使用“？”占位符的SQL语句，你需要传入带有更新值的对象数组。对象数组每一项对应SQL语句中的一个占位符，并且传入顺序需要和SQL语句中定义的顺序保持一致。

下面是使用经典JDBC“？”占位符的例子：

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

05	public void setDataSource(DataSourcedataSource){

06	this .jdbcTemplate= new JdbcTemplate(dataSource);

09	public int []batchUpdate( final List<Actor>actors){

10	List<Object[]>batch= new ArrayList<Object[]>();

11	for (Actoractor:actors){

12	Object[]values= new Object[]{

13	actor.getFirstName(),

14	actor.getLastName(),

15	actor.getId()};

16	batch.add(values);

18	int []updateCounts=jdbcTemplate.batchUpdate(

19	"updatet_actorsetfirst_name=?,last_name=?whereid=?" ,

batch);

21	return updateCounts;

24	//...additionalmethods

上面所有的批量更新方法都返回一个数组，包含具体成功的行数。这个计数是由JDBC驱动返回的。如果拿不到计数。JDBC驱动会返回-2。

15.4.3多个批处理操作

上面最后一个例子更新的批处理数量太大，最好能再分割成更小的块。最简单的方式就是你多次调用batchUpdate来实现，但是可以有更优的方法。要使用这个方法除了SQL语句，还需要传入参数集合对象，每次Batch的更新数和一个ParameterizedPreparedStatementSetter去设置预编译SQL语句的参数值。框架会循环调用提供的值并且将更新操作切割成指定数量的小批次。

下面的例子设置了更新批次数量为100的批量更新操作：

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

05	public void setDataSource(DataSourcedataSource){

06	this .jdbcTemplate= new JdbcTemplate(dataSource);

09	public int [][]batchUpdate( final Collection<Actor>actors){

10	int [][]updateCounts=jdbcTemplate.batchUpdate(

11	"updatet_actorsetfirst_name=?,last_name=?whereid=?" ,

actors,

14	new ParameterizedPreparedStatementSetter<Actor>(){

15	public void setValues(PreparedStatementps,Actorargument) throws SQLException{

16	ps.setString( 1 ,argument.getFirstName());

17	ps.setString( 2 ,argument.getLastName());

18	ps.setLong( 3 ,argument.getId().longValue());

});

21	return updateCounts;

24	//...additionalmethods

这个调用的批量更新方法返回一个包含int数组的二维数组，包含每次更新生效的行数。第一层数组长度代表批处理执行的数量，第二层数组长度代表每个批处理生效的更新数。每个批处理的更新数必须和所有批处理的大小匹配，除非是最后一次批处理可能小于这个数，具体依赖于更新对象的总数。每次更新语句生效的更新数由JDBC驱动提供。如果更新数量不存在，JDBC驱动会返回-2

15.5利用SimpleJdbc类简化JDBC操作

SimpleJdbcInsert类和SimpleJdbcCall类主要利用了JDBC驱动所提供的数据库元数据的一些特性来简化数据库操作配置。这意味着可以在前端减少配置，当然你也可以覆盖或是关闭底层的元数据处理，在代码里面指定所有的细节。

15.5.1利用SimpleJdbcInsert插入数据

让我们首先看SimpleJdbcInsert类可提供的最小配置选项。你需要在数据访问层初始化方法里面初始化SimpleJdbcInsert类。在这个例子中，初始化方法是setDataSource。你不需要继承SimpleJdbcInsert，只需要简单的创建其实例同时调用withTableName设置数据库名。

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

04	private SimpleJdbcInsertinsertActor;

06	public void setDataSource(DataSourcedataSource){

07	this .jdbcTemplate= new JdbcTemplate(dataSource);

08	this .insertActor= new SimpleJdbcInsert(dataSource).withTableName( "t_actor" );

11	public void add(Actoractor){

12	Map<String,Object>parameters= new HashMap<String,Object>( 3 );

13	parameters.put( "id" ,actor.getId());

14	parameters.put( "first_name" ,actor.getFirstName());

15	parameters.put( "last_name" ,actor.getLastName());

16	insertActor.execute(parameters);

19	//...additionalmethods

代码中的execute只传入java.utils.Map作为唯一参数。需要注意的是Map里面用到的Key必须和数据库中表对应的列名一一匹配。这是因为我们需要按顺序读取元数据来构造实际的插入语句。

15.5.2使用SimpleJdbcInsert获取自增Key

接下来，我们对于同样的插入语句，我们并不传入id，而是通过数据库自动获取主键的方式来创建新的Actor对象并插入数据库。当我们创建SimpleJdbcInsert实例时,我们不仅需要指定表名，同时我们通过usingGeneratedKeyColumns方法指定需要数据库自动生成主键的列名。

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

04	private SimpleJdbcInsertinsertActor;

06	public void setDataSource(DataSourcedataSource){

07	this .jdbcTemplate= new JdbcTemplate(dataSource);

08	this .insertActor= new SimpleJdbcInsert(dataSource)

09	.withTableName( "t_actor" )

10	.usingGeneratedKeyColumns( "id" );

13	public void add(Actoractor){

14	Map<String,Object>parameters= new HashMap<String,Object>( 2 );

15	parameters.put( "first_name" ,actor.getFirstName());

16	parameters.put( "last_name" ,actor.getLastName());

17	NumbernewId=insertActor.executeAndReturnKey(parameters);

18	< 172ab codeclass="spaces"> actor.setId(newId.longValue());

21	//...additionalmethods

执行插入操作时第二种方式最大的区别是你不是在Map中指定ID，而是调用executeAndReturnKey方法。这个方法返回java.lang.Number对象，可以创建一个数值类型的实例用于我们的领域模型中。你不能仅仅依赖所有的数据库都返回一个指定的Java类；java.lang.Number是你可以依赖的基础类。如果你有多个自增列，或者自增的值是非数值型的，你可以使用executeAndReturnKeyHolder方法返回的KeyHolder

15.5.3使用SimpleJdbcInsert指定列

你可以在插入操作中使用usingColumns方法来指定特定的列名

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

04	private SimpleJdbcInsertinsertActor;

06	public void setDataSource(DataSourcedataSource){

07	this .jdbcTemplate= new JdbcTemplate(dataSource);

08	this .insertActor= new SimpleJdbcInsert(dataSource)

09	.withTableName( "t_actor" )

10	.usingColumns( "first_name" , "last_name" )

11	.usingGeneratedKeyColumns( "id" );

14	public void add(Actoractor){

15	Map<String,Object>parameters= new HashMap<String,Object>( 2 );

16	parameters.put( "first_name" ,actor.getFirstName());

17	parameters.put( "last_name" ,actor.getLastName());

18	NumbernewId=insertActor.executeAndReturnKey(parameters);

19	actor.setId(newId.longValue());

22	//...additionalmethods

这里插入操作的执行和你依赖元数据决定更新哪个列的方式是一样的。

15.5.4使用SqlParameterSource提供参数值

使用Map来指定参数值没有问题，但不是最便捷的方法。Spring提供了一些SqlParameterSource接口的实现类来更方便的做这些操作。

第一个是BeanPropertySqlParameterSource，如果你有一个JavaBean兼容的类包含具体的值，使用这个类是很方便的。他会使用相关的Getter方法来获取参数值。下面是一个例子：

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

04	private SimpleJdbcInsertinsertActor;

06	public void setDataSource(DataSourcedataSource){

07	this .jdbcTemplate= new JdbcTemplate(dataSource);

08	this .insertActor= new SimpleJdbcInsert(dataSource)

09	.withTableName( "t_actor" )

10	.usingGeneratedKeyColumns( "id" );

13	public void add(Actoractor){

14	SqlParameterSourceparameters= new BeanPropertySqlParameterSource(actor);

15	NumbernewId=insertActor.executeAndReturnKey(parameters);

16	actor.setId(newId.longValue());

19	//...additionalmethods

另外一个选择是使用MapSqlParameterSource，类似于Map、但是提供了一个更便捷的addValue方法可以用来做链式操作。

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

04	private SimpleJdbcInsertinsertActor;

06	public void setDataSource(DataSourcedataSource){

07	this .jdbcTemplate= new JdbcTemplate(dataSource);

08	this .insertActor= new SimpleJdbcInsert(dataSource)

09	.withTableName( "t_actor" )

10	.usingGeneratedKeyColumns( "id" );

13	public void add(Actoractor){

14	SqlParameterSourceparameters= new MapSqlParameterSource()

15	.addValue( "first_name" ,actor.getFirstName())

16	.addValue( "last_name" ,actor.getLastName());

17	NumbernewId=insertActor.executeAndReturnKey(parameters);

18	actor.setId(newId.longValue());

21	//...additionalmethods

上面这些例子可以看出、配置是一样的，区别只是切换了不同的提供参数的实现方式来执行调用。

15.5.5利用SimpleJdbcCall调用存储过程

SimpleJdbcCall利用数据库元数据的特性来查找传入的参数和返回值，这样你就不需要显式去定义他们。如果你喜欢的话也以自己定义参数，尤其对于某些参数，你无法直接将他们映射到Java类上，例如ARRAY类型和STRUCT类型的参数。下面第一个例子展示了一个存储过程，从一个MySQL数据库返回Varchar和Date类型。这个存储过程例子从指定的actor记录中查询返回first_name,last_name,和birth_date列。

01	CREATEPROCEDUREread_actor(

02	INin_idINTEGER,

03	OUTout_first_nameVARCHAR( 100 ),

04	OUTout_last_nameVARCHAR( 100 ),

05	OUTout_birth_dateDATE)

BEGIN

07	SELECTfirst_name,last_name,birth_date

08	INTOout_first_name,out_last_name,out_birth_date

09	FROMt_actorwhereid=in_id;

END;

in_id参数包含你正在查找的actor记录的id.out参数返回从数据库表读取的数据

SimpleJdbcCall和SimpleJdbcInsert定义的方式比较类似。你需要在数据访问层的初始化代码中初始化和配置该类。相比StoredProcedure类，你不需要创建一个子类并且不需要定义能够在数据库元数据中查找到的参数。下面是一个使用上面存储过程的SimpleJdbcCall配置例子。除了DataSource以外唯一的配置选项是存储过程的名字

01	public class JdbcActorDao implements ActorDao{

02	private JdbcTemplatejdbcTemplate;

03	private SimpleJdbcCallprocReadActor;

05	public void setDataSource(DataSourcedataSource){

06	this .jdbcTemplate= new JdbcTemplate(dataSource);

07	this .procReadActor= new SimpleJdbcCall(dataSource)

08	.withProcedureName( "read_actor" );

11	public ActorreadActor(Longid){

12	SqlParameterSourcein= new MapSqlParameterSource()

13	.addValue( "in_id" ,id);

14	Mapout=procReadActor.execute(in);

15	Actoractor= new Actor();

16	actor.setId(id);

17	actor.setFirstName((String)out.get( "out_first_name" ));

18	actor.setLastName((String)out.get( "out_last_name" ));

19	actor.setBirthDate((Date)out.get( "out_birth_date" ));

20	return actor;

23	//...additionalmethods

调用代码包括创建包含传入参数的SqlParameterSource。这里需要重视的是传入参数值名字需要和存储过程中定义的参数名称相匹配。有一种场景不需要匹配、那就是你使用元数据去确定数据库对象如何与存储过程相关联。在存储过程源代码中指定的并不一定是数据库中存储的格式。有些数据库会把名字转成大写、而另外一些会使用小写或者特定的格式。

execute方法接受传入参数，同时返回一个Map包含任意的返回参数，Map的Key是存储过程中指定的名字。在这个例子中它们是out_first_name,out_last_name和out_birth_date

execute方法的最后一部分使用返回的数据创建Actor对象实例。再次需要强调的是Out参数的名字必须是存储过程中定义的。结果Map中存储的返回参数名必须和数据库中的返回参数名（不同的数据库可能会不一样）相匹配，为了提高你代码的可重用性，你需要在查找中区分大小写，或者使用Spring里面的LinkedCaseInsensitiveMap。如果使用LinkedCaseInsensitiveMap，你需要创建自己的JdbcTemplate并且将setResultsMapCaseInsensitive属性设置为True。然后你将自定义的JdbcTemplate
传入到SimpleJdbcCall的构造器中。下面是这种配置的一个例子：

01	public class JdbcActorDao implements ActorDao{

03	private SimpleJdbcCallprocReadActor;

05	public void setDataSource(DataSourcedataSource){

06	JdbcTemplatejdbcTemplate= new JdbcTemplate(dataSource);

07	jdbcTemplate.setResultsMapCaseInsensitive( true );

08	this .procReadActor= new SimpleJdbcCall(jdbcTemplate)

09	.withProcedureName( "read_actor" );

12	//...additionalmethods

通过这样的配置，你就可以无需担心返回参数值的大小写问题。

15.5.6为SimpleJdbcCall显式定义参数

你已经了解如何通过元数据来简化参数配置，但如果你需要的话也可以显式指定参数。这样做的方法是在创建SimpleJdbcCall类同时通过declareParameters方法进行配置，这个方式可以传入一系列的SqlParameter。下面的章节会详细描述如何定义一个SqlParameter

备注：如果你使用的数据库不是Spring支持的数据库类型的话显式定义就很有必要了。当前Spring支持以下数据库的存储过程元数据查找能力：ApacheDerby,DB2,MySQL,MicrosoftSQLServer,Oracle,和Sybase.我们同时对某些数据库内置函数支持元数据特性：比如：MySQL、MicrosoftSQLServer和Oracle。

你可以选择显式定义一个、多个，或者所有参数。当你没有显式定义参数时元数据参数仍然会被使用。当你不想用元数据查找参数功能、只想指定参数时，需要调用withoutProcedureColumnMetaDataAccess方法。假设你针对同一个数据函数定义了两个或多个不同的调用方法签名，在每一个给定的签名中你需要使用useInParameterNames来指定传入参数的名称列表。下面是一个完全自定义的存储过程调用例子

01	public class JdbcActorDao implements ActorDao{

03	private SimpleJdbcCallprocReadActor;

05	public void setDataSource(DataSourcedataSource){

06	JdbcTemplatejdbcTemplate= new JdbcTemplate(dataSource);

07	jdbcTemplate.setResultsMapCaseInsensitive( true );

08	this .procReadActor= new SimpleJdbcCall(jdbcTemplate)

09	.withProcedureName( "read_actor" )

10	.withoutProcedureColumnMetaDataAccess()

11	.useInParameterNames( "in_id" )

12	.declareParameters(

13	new SqlParameter( "in_id" ,Types.NUMERIC),

14	new SqlOutParameter( "out_first_name" ,Types.VARCHAR),

15	new SqlOutParameter( "out_last_name" ,Types.VARCHAR),

16	new SqlOutParameter( "out_birth_date" ,Types.DATE)

);

20	//...additionalmethods

两个例子的执行结果是一样的，区别是这个例子显式指定了所有细节，而不是仅仅依赖于数据库元数据。

15.5.7如何定义SqlParameters

如何定义SimpleJdbc类和RDBMS操作类的参数，详见15.6：“像Java对象那样操作JDBC”,你需要使用SqlParameter或者是它的子类。通常需要在构造器中定义参数名和SQL类型。SQL类型使用java.sql.Types常量来定义。

我们已经看到过类似于如下的定义：

1	new SqlParameter( "in_id" ,Types.NUMERIC),

2	new SqlOutParameter( "out_first_name" ,Types.VARCHAR),

上面第一行SqlParameter定义了一个传入参数。IN参数可以同时在存储过程调用和SqlQuery查询中使用，它的子类在下面的章节也有覆盖。

上面第二行SqlOutParameter定义了在一次存储过程调用中使用的返回参数。还有一个SqlInOutParameter类，可以用于输入输出参数。也就是说，它既是一个传入参数，也是一个返回值。

备注：参数只有被定义成SqlParameter和SqlInOutParameter才可以提供输入值。不像StoredProcedure类为了考虑向后兼容允许定义为SqlOutParameter的参数可以提供输入值

对于输入参数，除了名字和SQL类型，你可以定义数值区间或是自定义数据类型名。针对输出参数，你可以使用RowMapper处理从REF游标返回的行映射。另外一种选择是定义SqlReturnType，可以针对返回值作自定义处理。

15.5.8使用SimpleJdbcCall调用内置存储函数

调用存储函数几乎和调用存储过程的方式是一样的，唯一的区别你提供的是函数名而不是存储过程名。你可以使用withFunctionName方法作为配置的一部分表示我们想要调用一个函数，以及生成函数调用相关的字符串。一个特殊的execute调用，executeFunction，用来指定这个函数并且返回一个指定类型的函数值，这意味着你不需要从结果Map获取返回值。存储过程也有一个名字为executeObject的便捷方法，但是只要一个输出参数。下面的例子基于一个名字为get_actor_name的存储函数，返回actor的全名。下面是这个函数的Mysql源代码：

1	CREATEFUNCTIONget_actor_name(in_idINTEGER)

2	RETURNSVARCHAR( 200 )READSSQLDATA

BEGIN

4	DECLAREout_nameVARCHAR( 200 );

5	SELECTconcat(first_name, '' ,last_name)

6	INTOout_name

7	FROMt_actorwhereid=in_id;

8	RETURNout_name;

END;

我们需要在初始方法中创建SimpleJdbcCall来调用这个函数

01	public class JdbcActorDao implements ActorDao{

03	private JdbcTemplatejdbcTemplate;

04	private SimpleJdbcCallfuncGetActorName;

06	public void setDataSource(DataSourcedataSource){

07	this .jdbcTemplate= new JdbcTemplate(dataSource);

08	JdbcTemplatejdbcTemplate= new JdbcTemplate(dataSource);

09	jdbcTemplate.setResultsMapCaseInsensitive( true );

10	this .funcGetActorName= new SimpleJdbcCall(jdbcTemplate)

11	.withFunctionName( "get_actor_name" );

14	public StringgetActorName(Longid){

15	SqlParameterSourcein= new MapSqlParameterSource()

16	.addValue( "in_id" ,id);

17	Stringname=funcGetActorName.executeFunction(String. class ,in);

18	return name;

21	//...additionalmethods

execute方法返回一个包含函数调用返回值的字符串

15.5.9从SimpleJdbcCall返回ResultSet/REF游标

调用存储过程或者函数返回结果集会相对棘手一点。一些数据库会在JDBC结果处理中返回结果集，而另外一些数据库则需要明确指定返回值的类型。两种方式都需要循环迭代结果集做额外处理。通过SimpleJdbcCall，你可以使用returningResultSet方法，并定义一个RowMapper的实现类来处理特定的返回值。当结果集在返回结果处理过程中没有被定义名称时，返回的结果集必须与定义的RowMapper的实现类指定的顺序保持一致。而指定的名字也会被用作返回结果集中的名称。

下面的例子使用了一个不包含输入参数的存储过程并且返回t_actor标的所有行。下面是这个存储过程的Mysql源代码：

1	CREATEPROCEDUREread_all_actors()

BEGIN

3	SELECTa.id,a.first_name,a.last_name,a.birth_dateFROMt_actora;

END;

调用这个存储过程你需要定义RowMapper。因为我们定义的Map类遵循JavaBean规范，所以我们可以使用BeanPropertyRowMapper作为实现类。通过将相应的class类作为参数传入到newInstance方法中，我们可以创建这个实现类。

01	public class JdbcActorDao implements ActorDao{

03	private SimpleJdbcCallprocReadAllActors;

05	public void setDataSource(DataSourcedataSource){

06	JdbcTemplatejdbcTemplate= new JdbcTemplate(dataSource);

07	jdbcTemplate.setResultsMapCaseInsensitive( true );

08	this .procReadAllActors= new SimpleJdbcCall(jdbcTemplate)

09	.withProcedureName( "read_all_actors" )

10	.returningResultSet( "actors" ,

11	BeanPropertyRowMapper.newInstance(Actor. class ));

14	public ListgetActorsList(){

15	Mapm=procReadAllActors.execute( new HashMap<String,Object>( 0 ));

16	return (List)m.get( "actors" );

19	//...additionalmethods

execute调用传入一个空Map，因为这里不需要传入任何参数。从结果Map中提取Actors列表，并且返回给调用者。

15.6像Java对象那样操作JDBC

org.springframework.jdbc.object包能让你更加面向对象化的访问数据库。举个例子，用户可以执行查询并返回一个list，该list作为一个结果集将把从数据库中取出的列数据映射到业务对象的属性上。你也可以执行存储过程，包括更新、删除、插入语句。

备注：许多Spring的开发者认为下面将描述的各种RDBMS操作类（StoredProcedure类除外）可以直接被JdbcTemplate代替；相对于把一个查询操作封装成一个类而言，直接调用JdbcTemplate方法将更简单而且更容易理解。但这仅仅是一种观点而已，如果你认为可以从直接使用RDBMS操作类中获取一些额外的好处，你不妨根据自己的需要和喜好进行不同的选择。

15.6.1SqlQuery

SqlQuery类主要封装了SQL查询，本身可重用并且是线程安全的。子类必须实现newRowMapper方法，这个方法提供了一个RowMapper实例，用于在查询执行返回时创建的结果集迭代过程中每一行映射并创建一个对象。SqlQuery类一般不会直接使用；因为MappingSqlQuery子类已经提供了一个更方便从列映射到Java类的实现。其他继承SqlQuery的子类有MappingSqlQueryWithParameters和UpdatableSqlQuery。

15.6.2MappingSqlQuery

MappingSqlQuery是一个可重用的查询类，它的子类必须实现mapRow(..)方法，将结果集返回的每一行转换成指定的对象类型。下面的例子展示了一个自定义的查询例子，将t_actor关系表的数据映射成Actor类。

01	public class ActorMappingQuery extends MappingSqlQuery<Actor>{

03	public ActorMappingQuery(DataSourceds){

04	super (ds, "selectid,first_name,last_namefromt_actorwhereid=?" );

05	super .declareParameter( new SqlParameter( "id" ,Types.INTEGER));

06	compile();

@Override

10	protected ActormapRow(ResultSetrs, int rowNumber) throws SQLException{

11	Actoractor= new Actor();

12	actor.setId(rs.getLong( "id" ));

13	actor.setFirstName(rs.getString( "first_name" ));

14	actor.setLastName(rs.getString( "last_name" ));

15	return actor;

这个类继承了MappingSqlQuery，并且传入Actor类型的泛型参数。这个自定义查询类的构造函数将DataSource作为唯一的传入参数。这个构造器中你调用父类的构造器，传入DataSource以及相应的SQL参数。该SQL用于创建PreparedStatement，因此它可能包含任何在执行过程中传入参数的占位符。你必须在SqlParameter中使用declareParameter方法定义每个参数。SqlParameter使用java.sql.Types定义名字和JDBC类型。在你定义了所有的参数后，你需要调用compile方法，语句被预编译后方便后续的执行。这个类在编译后是线程安全的，一旦在DAO初始化时这些实例被创建后，它们可以作为实例变量一直被重用。

01	private ActorMappingQueryactorMappingQuery;

03	@Autowired

04	public void setDataSource(DataSourcedataSource){

05	this .actorMappingQuery= new ActorMappingQuery(dataSource);

08	public CustomergetCustomer(Longid){

09	return actorMappingQuery.findObject(id);

这个例子中的方法通过唯一的传入参数id获取customer实例。因为我们只需要返回一个对象，所以就简单的调用findObject类就可以了，这个方法只需要传入id参数。如果我们需要一次查询返回一个列表的话，就需要使用传入可变参数数组的执行方法。

1	public List<Actor>searchForActors( int age,StringnamePattern){

2	List<Actor>actors=actorSearchMappingQuery.execute(age,namePattern);

3	return actors;

15.6.3SqlUpdate

SqlUpdate封装了SQL的更新操作。和查询一样，更新对象是可以被重用的，就像所有的rdbms操作类，更新操作能够传入参数并且在SQL定义。类似于SqlQuery诸多execute(..)方法，这个类提供了一系列update(..)方法。SQLUpdate类不是抽象类，它可以被继承，比如，实现自定义的更新方法。但是你并不需要继承SqlUpdate类来达到这个目的，你可以更简单的在SQL中设置自定义参数来实现。

01	import java.sql.Types;

03	import javax.sql.DataSource;

05	import org.springframework.jdbc.core.SqlParameter;

06	import org.springframework.jdbc.object.SqlUpdate;

08	public class UpdateCreditRating extends SqlUpdate{

10	public UpdateCreditRating(DataSourceds){

11	setDataSource(ds);

12	setSql( "updatecustomersetcredit_rating=?whereid=?" );

13	declareParameter( new SqlParameter( "creditRating" ,Types.NUMERIC));

14	declareParameter( new SqlParameter( "id" ,Types.NUMERIC));

15	compile();

/**

19	*@paramidfortheCustomertobeupdated

20	*@paramratingthenewvalueforcreditrating

21	*@returnnumberofrowsupdated

*/

23	public int execute( int id, int rating){

24	return update(rating,id);

15.6.4StoredProcedure

StoredProcedure类是所有RDBMS存储过程的抽象类。该类提供了多种execute(..)方法，其访问类型都是protected的。

为了定义一个存储过程类，你需要使用SqlParameter或者它的一个子类。你必须像下面的代码例子那样在构造函数中指定参数名和SQL类型。SQL类型使用java.sql.Types常量定义。

1	new SqlParameter( "in_id" ,Types.NUMERIC),

2	new SqlOutParameter( "out_first_name" ,Types.VARCHAR),

SqlParameter的第一行定义了一个输入参数。输入参数可以同时被存储过程调用和使用SqlQuery的查询语句使用，他的子类会在下面的章节提到。

第二行SqlOutParameter参数定义了一个在存储过程调用中使用的输出参数。SqlInOutParameter还有一个InOut参数，该参数提供了一个输入值，同时也有返回值。

对应输入参数，除了名字和SQL类型，你还能指定返回区间数值类型和自定义数据库类型。对于输出参数你可以使用RowMapper来处理REF游标返回的行映射关系。另一个选择是指定SqlReturnType，能够让你定义自定义的返回值类型。

下面的程序演示了如何调用Oracle中的sysdate()函数。为了使用存储过程函数你需要创建一个StoredProcedure的子类。在这个例子中，StoredProcedure是一个内部类，但是如果你需要重用StoredProcedure你需要定义成一个顶级类。这个例子没有输入参数，但是使用SqlOutParameter类定义了一个时间类型的输出参数。execute（）方法执行了存储过程，并且从结果集Map中获取返回的时间数据。结果集Map中包含每个输出参数对应的项,在这个例子中就只有一项，使用了参数名作为key.

01	import java.sql.Types;

02	import java.util.Date;

03	import java.util.HashMap;

04	import java.util.Map;

06	import javax.sql.DataSource;

08	import org.springframework.beans.factory.annotation.Autowired;

09	import org.springframework.jdbc.core.SqlOutParameter;

10	import org.springframework.jdbc.object.StoredProcedure;

12	public class StoredProcedureDao{

14	private GetSysdateProceduregetSysdate;

16	@Autowired

17	public void init(DataSourcedataSource){

18	this .getSysdate= new GetSysdateProcedure(dataSource);

21	public DategetSysdate(){

22	return getSysdate.execute();

25	private class GetSysdateProcedure extends StoredProcedure{

27	private static final StringSQL= "sysdate" ;

29	public GetSysdateProcedure(DataSourcedataSource){

30	setDataSource(dataSource);

31	setFunction( true );

32	setSql(SQL);

33	declareParameter( new SqlOutParameter( "date" ,Types.DATE));

34	compile();

37	public Dateexecute(){

38	//the'sysdate'sprochasnoinputparameters,soanemptyMapissupplied...

39	Map<String,Object>results=execute( new HashMap<String,Object>());

40	Datesysdate=(Date)results.get( "date" );

41	return sysdate;

下面是一个包含两个输出参数的存储过程例子。

01	import oracle.jdbc.OracleTypes;

02	import org.springframework.jdbc.core.SqlOutParameter;

03	import org.springframework.jdbc.object.StoredProcedure;

05	import javax.sql.DataSource;

06	import java.util.HashMap;

07	import java.util.Map;

09	public class TitlesAndGenresStoredProcedure extends StoredProcedure{

11	private static final StringSPROC_NAME= "AllTitlesAndGenres" ;

13	public TitlesAndGenresStoredProcedure(DataSourcedataSource){

14	super (dataSource,SPROC_NAME);

15	declareParameter( new SqlOutParameter( "titles" ,OracleTypes.CURSOR, new TitleMapper()));

16	declareParameter( new SqlOutParameter( "genres" ,OracleTypes.CURSOR, new GenreMapper()));

17	compile();

20	public Map<String,Object>execute(){

21	//again,thissprochasnoinputparameters,soanemptyMapissupplied

22	return super .execute( new HashMap<String,Object>());

值得注意的是TitlesAndGenresStoredProcedure构造函数中declareParameter(..)的SqlOutParameter参数，该参数使用RowMapper接口的实现。这是一种非常方便有效的重用方式。两种RowMapper实现的代码如下：

TitleMapper类将返回结果集的每一行映射成Title类

01	import org.springframework.jdbc.core.RowMapper;

03	import java.sql.ResultSet;

04	import java.sql.SQLException;

06	import com.foo.domain.Title;

08	public final class TitleMapper implements RowMapper<Title>{

10	public TitlemapRow(ResultSetrs, int rowNum) throws SQLException{

11	Titletitle= new Title();

12	title.setId(rs.getLong( "id" ));

13	title.setName(rs.getString( "name" ));

14	return title;

GenreMapper类将返回结果集的每一行映射成Genre类

01	import org.springframework.jdbc.core.RowMapper;

03	import java.sql.ResultSet;

04	import java.sql.SQLException;

06	import com.foo.domain.Genre;

08	public final class GenreMapper implements RowMapper<Genre>{

10	public GenremapRow(ResultSetrs, int rowNum) throws SQLException{

11	return new Genre(rs.getString( "name" ));

为了将参数传递给RDBMS中定义的一个或多个输入参数给存储过程，你可以定义一个强类型的execute(..)方法，该方法将调用基类的protectedexecute(Mapparameters)方法。例如：

01	import oracle.jdbc.OracleTypes;

02	import org.springframework.jdbc.core.SqlOutParameter;

03	import org.springframework.jdbc.core.SqlParameter;

04	import org.springframework.jdbc.object.StoredProcedure;

06	import javax.sql.DataSource;

08	import java.sql.Types;

09	import java.util.Date;

10	import java.util.HashMap;

11	import java.util.Map;

13	public class TitlesAfterDateStoredProcedure extends StoredProcedure{

15	private static final StringSPROC_NAME= "TitlesAfterDate" ;

16	private static final StringCUTOFF_DATE_PARAM= "cutoffDate" ;

18	public TitlesAfterDateStoredProcedure(DataSourcedataSource){

19	super (dataSource,SPROC_NAME);

20	declareParameter( new SqlParameter(CUTOFF_DATE_PARAM,Types.DATE);

21	declareParameter( new SqlOutParameter( "titles" ,OracleTypes.CURSOR, new TitleMapper()));

22	compile();

25	public Map<String,Object>execute(DatecutoffDate){

26	Map<String,Object>inputs= new HashMap<String,Object>();

27	inputs.put(CUTOFF_DATE_PARAM,cutoffDate);

28	return super .execute(inputs);

15.7参数和数据处理的常见问题

SpringJDBC框架提供了多个方法来处理常见的参数和数据问题

15.7.1为参数设置SQL的类型信息

通常Sping通过传入的参数类型决定SQL的参数类型。可以在设定参数值的时候显式提供SQL类型。有些场景下设置NULL值是有必要的。

你可以通过以下方式来设置SQL类型信息：

许多JdbcTemplate的更新和查询方法需要传入额外的int数组类型的参数。这个数组使用java.sql.Types类的常量值来确定相关参数的SQL类型。每个参数会有对应的类型项。
你可以使用SqlParameterValue类来包装需要额外信息的参数值。针对每个值创建一个新的实例，并且在构造函数中传入SQL类型和参数值。你还可以传入数值类型的可选区间参数
对于那些使用命名参数的情况，使用SqlParameterSource类型的类比如BeanPropertySqlParameterSource，或MapSqlParameterSource。他们都具备了为命名参数注册SQL类型的功能。
15.7.2处理BLOB和CLOB对象

你可以存储图片，其他类型的二进制数据，和数据库里面的大块文本。这些大的对象叫做BLOBS（全称：BinaryLargeOBject；用于二进制数据）和CLOBS（全称：CharacterLargeOBject；用于字符数据）。在Spring中你可以使用JdbcTemplate直接处理这些大对象，并且也可以使用RDBMS对象提供的上层抽象类，或者使用SimpleJdbc类。所有这些方法使用LobHandler接口的实现类来处理LOB数据的管理（全称：LargeObject）。LobHandler通过getLobCreator方法提供了对LobCreator
类的访问，用于创建新的LOB插入对象。

LobCreator/LobHandler提供了LOB输入和输出的支持：

BLOB：

2	byte [] — getBlobAsBytes和setBlobAsBytes

3	InputStream-getBlobAsBinaryStream和setBlobAsBinaryStream

CLOB：

6	String-getClobAsString和setClobAsString

7	InputStream-getClobAsAsciiStream和setClobAsAsciiStream

8	Reader-getClobAsCharacterStream和setClobAsCharacterStream

下面的例子展示了如何创建和插入一个BLOB。后面的例子我们将举例如何从数据库中将BLOB数据读取出来

这个例子使用了JdbcTemplate和AbstractLobCreatingPreparedStatementCallback的实现类。它主要实现了一个方法，setValues.这个方法提供了用于在你的SQL插入语句中设置LOB列的LobCreator。

针对这个例子我们假定有一个变量lobHandler，已经设置了DefaultLobHandler的一个实例。通常你可以使用依赖注入来设置这个值。

01	final FileblobIn= new File( "spring2004.jpg" );

02	final InputStreamblobIs= new FileInputStream(blobIn);

03	final FileclobIn= new File( "large.txt" );

04	final InputStreamclobIs= new FileInputStream(clobIn);

05	final InputStreamReaderclobReader= new InputStreamReader(clobIs);

06	jdbcTemplate.execute(

07	"INSERTINTOlob_table(id,a_clob,a_blob)VALUES(?,?,?)" ,

08	new AbstractLobCreatingPreparedStatementCallback(lobHandler){ 1

09	protected void setValues(PreparedStatementps,LobCreatorlobCreator) throws SQLException{

10	ps.setLong( 1 ,1L);

11	lobCreator.setClobAsCharacterStream(ps, 2 ,clobReader,( int )clobIn.length()); 2

12	lobCreator.setBlobAsBinaryStream(ps, 3 ,blobIs,( int )blobIn.length()); 3

);

16	blobIs.close();

17	clobReader.close();

1、这里例子中传入的lobHandler使用了默认实现类DefaultLobHandler

2、使用setClobAsCharacterStream传入CLOB的内容

3、使用setBlobAsBinaryStream传入BLOB的内容

备注：如果你调用从DefaultLobHandler.getLobCreator()返回的LobCreator的setBlobAsBinaryStream,setClobAsAsciiStream,或者setClobAsCharacterStream方法，其中contentLength参数允许传入一个负值。如果指定的内容长度是负值，DefaultLobHandler会使用JDBC4.0不带长度参数的set-stream方法，或者直接传入驱动指定的长度；JDBC驱动对未指定长度的LOB流的支持请参见相关文档

下面是从数据库读取LOB数据的例子。我们这里再次使用JdbcTempate并使用相同的DefaultLobHandler实例。

1	List<Map<String,Object>>l=jdbcTemplate.query( "selectid,a_clob,a_blobfromlob_table" ,

2	new RowMapper<Map<String,Object>>(){

3	public Map<String,Object>mapRow(ResultSetrs, int i) throws SQLException{

4	Map<String,Object>results= new HashMap<String,Object>();

5	StringclobText=lobHandler.getClobAsString(rs, "a_clob" ); 1

6	results.put( "CLOB" ,clobText); byte []blobBytes=lobHandler.getBlobAsBytes(rs, "a_blob" ); 2

7	results.put( "BLOB" ,blobBytes); return results;}});

1、使用getClobAsString获取CLOB的内容

2、使用getBlobAsBytes获取BLOC的内容

15.7.3传入IN语句的列表值

SQL标准允许基于一个带参数列表的表达式进行查询，一个典型的例子是select*fromT_ACTORwhereidin(1,2,3).这样的可变参数列表没有被JDBC标准直接支持；你不能定义可变数量的占位符（placeholder），只能定义固定变量的占位符，或者你在动态生成SQL字符串的时候需要提前知晓所需占位符的数量。NamedParameterJdbcTemplate和JdbcTemplate都使用了后面那种方式。当你传入参数时，你需要传入一个java.util.List类型，支持基本类型。而这个list将会在SQL执行时替换占位符并传入参数。

备注：在传入多个值的时候需要注意。JDBC标准不保证你能在一个in表达式列表中传入超过100个值，不少数据库会超过这个值，但是一般都会有个上限。比如Oracle的上限是1000.

除了值列表的元数据值，你可以创建java.util.List的对象数组。这个列表支持多个在in语句内定义的表达式例如

select*fromT_ACTORwhere(id,last_name)in((1,‘Johnson’),(2,‘Harrop’\))。当然有个前提你的数据库需要支持这个语法。

15.7.4处理存储过程调用的复杂类型

当你调用存储过程时有时需要使用数据库特定的复杂类型。为了兼容这些类型，当存储过程调用返回时Spring提供了一个SqlReturnType来处理这些类型，SqlTypeValue用于存储过程的传入参数。

下面是一个用户自定义类型ITEM_TYPE的OracleSTRUCT对象的返回值例子。SqlReturnType有一个方法getTypeValue必须被实现。而这个接口的实现将被用作SqlOutParameter声明的一部分。

01	final TestItem= new TestItem(123L, "Atestitem" ,

02	new SimpleDateFormat( "yyyy-M-d" ).parse( "2010-12-31" ));

04	declareParameter( new SqlOutParameter( "item" ,OracleTypes.STRUCT, "ITEM_TYPE" ,

05	new SqlReturnType(){

06	public ObjectgetTypeValue(CallableStatementcs, int colIndx, int sqlType,StringtypeName) throws SQLException{

07	STRUCTstruct=(STRUCT)cs.getObject(colIndx);

08	Object[]attr=struct.getAttributes();

09	TestItemitem= new TestItem();

10	item.setId(((Number)attr[ 0 ]).longValue());

11	item.setDescription((String)attr[ 1 ]);

12	item.setExpirationDate((java.util.Date)attr[ 2 ]);

13	return item;

}));

你可以使用SqlTypeValue类往存储过程传入像TestItem那样的Java对象。你必须实现SqlTypeValue接口的createTypeValue方法。你可以使用传入的连接来创建像StructDescriptors这样的数据库指定对象。下面是相关的例子。

01	SqlTypeValuevalue= new AbstractSqlTypeValue(){

02	protected ObjectcreateTypeValue(Connectionconn, int sqlType,StringtypeName) throws SQLException{

03	StructDescriptoritemDescriptor= new StructDescriptor(typeName,conn);

04	Structitem= new STRUCT(itemDescriptor,conn,

05	new Object[]{

06	testItem.getId(),

07	testItem.getDescription(),

08	new java.sql.Date(testItem.getExpirationDate().getTime())

});

10	return item;

};

SqlTypeValue会加入到包含输入参数的Map中，用于执行存储过程调用。

SqlTypeValue的另外一个用法是给Oracle的存储过程传入一个数组。Oracle内部有它自己的ARRAY类，在这些例子中一定会被使用，你可以使用SqlTypeValue来创建OracleARRAY的实例，并且设置到JavaARRAY类的值中。

1	final Long[]ids= new Long[]{1L,2L};

3	SqlTypeValuevalue= new AbstractSqlTypeValue(){

4	protected ObjectcreateTypeValue(Connectionconn, int sqlType,StringtypeName) throws SQLException{

5	ArrayDescriptorarrayDescriptor= new ArrayDescriptor(typeName,conn);

6	ARRAYidArray= new ARRAY(arrayDescriptor,conn,ids);

7	return idArray;

};

15.8内嵌数据库支持

org.springframework.jdbc.datasource.embedded包包含对内嵌Java数据库引擎的支持。如对HSQL,H2,andDerby原生支持，你还可以使用扩展API来嵌入新的数据库内嵌类型和Datasource实现。

15.8.1为什么使用一个内嵌数据库？

内嵌数据库因为比较轻量级所以在开发阶段比较方便有用。包括配置比较容易，启动快，方便测试，并且在开发阶段方便快速设计SQL操作

15.8.2使用Spring配置来创建内嵌数据库

如果你想要将内嵌的数据库实例作为Bean配置到Spring的ApplicationContext中，使用spring-jdbc命名空间下的embedded-databasetag

1	<jdbc:embedded-databaseid= "dataSource" generate-name= "true" >

2	<jdbc:scriptlocation= "classpath:schema.sql" />

3	<jdbc:scriptlocation= "classpath:test-data.sql" />

4	</jdbc:embedded-database>

上面的配置创建了一个内嵌的HSQL数据库，并且在classpath下面配置schema.sql和test-data.sql资源。同时，作为一种最佳实践，内嵌数据库会被制定一个唯一生成的名字。内嵌数据库在Spring容器中作为javax.sql.DataSourceBean类型存在，并且能够被注入到所需的数据库访问对象中。

15.8.3使用编程方式创建内嵌数据库

EmbeddedDatabaseBuilder提供了创建内嵌数据库的流式API。当你在独立的环境中或者是在独立的集成测试中可以使用这种方法创建一个内嵌数据库，下面是一个例子：

01	EmbeddedDatabasedb= new EmbeddedDatabaseBuilder()

02	.generateUniqueName( true )

03	.setType(H2)

04	.setScriptEncoding( "UTF-8" )

05	.ignoreFailedDrops( true )

06	.addScript( "schema.sql" )

07	.addScripts( "user_data.sql" , "country_data.sql" )

.build();

10	//performactionsagainstthedb(EmbeddedDatabaseextendsjavax.sql.DataSource)

12	db.shutdown()

更多支持的细节请参见：EmbeddedDatabaseBuilder的JavaDoc

EmbeddedDatabaseBuilder也可以使用JavaConfig类来创建内嵌数据库，下面是一个例子：

01	@Configuration

02	public class DataSourceConfig{

@Bean

05	public DataSourcedataSource(){

06	return new EmbeddedDatabaseBuilder()

07	.generateUniqueName( true )

08	.setType(H2)

09	.setScriptEncoding( "UTF-8" )

10	.ignoreFailedDrops( true )

11	.addScript( "schema.sql" )

12	.addScripts( "user_data.sql" , "country_data.sql" )

.build();

15.8.4选择内嵌数据库的类型

使用HSQL

spring支持HSQL1.8.0及以上版本。HSQL是缺省默认内嵌数据库类型。如果显式指定HSQL，设置embedded-databaseTag的type属性值为HSQL。如果使用builderAPI.调用EmbeddedDatabaseType.HSQL的setType(EmbeddedDatabaseType)方法。

使用H2

Spring也支持H2数据库。设置embedded-databasetag的type类型值为H2来启用H2。如果你使用了builderAPI。调用setType(EmbeddedDatabaseType)方法设置值为EmbeddedDatabaseType.H2。

使用Derby

Spring也支持ApacheDerby10.5及以上版本，设置embedded-databasetag的type属性值为BERBY来开启DERBY。如果你使用builderAPI，调用setType(EmbeddedDatabaseType)方法设置值为EmbeddedDatabaseType.DERBY.

15.8.5使用内嵌数据库测试数据访问层逻辑

内嵌数据库提供了数据访问层代码的轻量级测试方案，下面是使用了内嵌数据库的数据访问层集成测试模板。使用这样的模板当内嵌数据库不需要在测试类中被重用时是有用的。不过，当你希望创建可以在test集中共享的内嵌数据库。考虑使用

SpringTestContext测试框架，同时在SpringApplicationContext中将内嵌数据库配置成一个Bean，具体参见15.8.2节,“使用Spring配置来创建内嵌数据库”和15.8.3节,“使用编程方式创建内嵌数据库”.

01	public class DataAccessIntegrationTestTemplate{

03	private EmbeddedDatabasedb;

@Before

06	public void setUp(){

07	//createsanHSQLin-memorydatabasepopulatedfromdefaultscripts

08	//classpath:schema.sqlandclasspath:data.sql

09	db= new EmbeddedDatabaseBuilder()

10	.generateUniqueName( true )

11	.addDefaultScripts()

.build();

@Test

16	public void testDataAccess(){

17	JdbcTemplatetemplate= new JdbcTemplate(db);

18	template.query( /.../ );

@After

22	public void tearDown(){

23	db.shutdown();

15.8.6生成内嵌数据库的唯一名字

开发团队在使用内嵌数据库时经常碰到的一个错误是：当他们的测试集想对同一个数据库创建额外的实例。这种错误在以下场景经常发生，XML配置文件或者@Configuration类用于创建内嵌数据库，并且相关的配置在同样的测试集的多个测试场景下都被用到（例如，在同一个JVM进程中）。例如，针对内嵌数据库的不同集成测试的ApplicationContext配置的区别只在当前哪个Bean定义是有效的。

这些错误的根源是Spring的EmbeddedDatabaseFactory工厂（XML命名空间和JavaConfig对象的EmbeddedDatabaseBuilder内部都用到了这个）会将内嵌数据库的名字默认设置成”testdb”.针对的场景，内嵌数据库通常设置成和BeanId相同的名字。（例如，常用像“dataSource”的名字）。结果，接下来创建内嵌数据库的尝试都没创建一个新的数据库。相反，同样的JDBC链接URL被重用。创建内嵌数据的库的尝试往往从同一个配置返回了已存在的内嵌数据库实例。

为了解决这个问题Spring框架4.2提供了生成内嵌数据库唯一名的支持。例如：

1	EmbeddedDatabaseFactory.setGenerateUniqueDatabaseName()

2	EmbeddedDatabaseBuilder.generateUniqueName()

3	<jdbc:embedded-databasegenerate-name= "true" …>

15.8.7内嵌数据库扩展支持

SpringJDBC内嵌数据库支持以下两种扩展支持：

实现EmbeddedDatabaseConfigurer支持新的内嵌数据库类型。
实现DataSourceFactory支持新的DataSource实现，例如管理内嵌数据库连接的连接池
欢迎贡献内部扩展给Spring社区，相关网址见：jira.spring.io.

15.9初始化Datasource

org.springframework.jdbc.datasource.init用于支持初始化一个现有的DataSource。内嵌数据库提供了创建和初始化Datasource的一个选项，但是有时你需要在另外的服务器上初始化实例。

15.9.1使用SpringXML来初始化数据库

如果你想要初始化一个数据库你可以设置DataSourceBean的引用，使用spring-jdbc命名空间下的initialize-database标记

1	<jdbc:initialize-databasedata-source= "dataSource" >

2	<jdbc:scriptlocation= "classpath:com/foo/sql/db-schema.sql" />

3	<jdbc:scriptlocation= "classpath:com/foo/sql/db-test-data.sql" />

4	</jdbc:initialize-database>

上面的例子执行了数据库的两个脚本：第一个脚本创建了一个Schema，第二个往表里插入了一个测试数据集。脚本路径可以使用Spring中ant类型的查找资源的模式（例如classpath*:/com/foo/**/sql/*-data.sql）。如果使用了正则表达式，脚本会按照URL或者文件名的词法顺序执行。

默认数据库初始器会无条件执行该脚本。有时你并不想要这么做，例如。你正在执行一个已存在测试数据集的数据库脚本。下面的通用方法会避免不小心删除数据，比如像上面的例子先创建表然后再插入-第一步在表已经存在时会失败掉。

为了能够在创建和删除已有数据方面提供更多的控制，XML命名空间提供了更多的方式。第一个是将初始化设置开启还是关闭。这个可以根据当前环境情况设置（例如用系统变量或者环境属性Bean中获取一个布尔值）例如：

1	<jdbc:initialize-databasedata-source= "dataSource"

2	enabled= "#{systemProperties.INITIALIZE_DATABASE}" >

3	<jdbc:scriptlocation= "..." />

4	</jdbc:initialize-database>

第二个选项是控制当前数据的行为，这是为了提高容错性。你能够控制初始器来忽略SQL里面执行脚本的特定错误、例如：

1	<jdbc:initialize-databasedata-source= "dataSource" ignore-failures= "DROPS" >

2	<jdbc:scriptlocation= "..." />

3	</jdbc:initialize-database>

在这个例子中我们声明我们预期有时脚本会执行到一个空的数据库，那么脚本中的DROP语句会失败掉。这个失败的SQLDROP语句会被忽略，但是其他错误会抛出一个异常。这在你的SQL语句不支持DROP…IFEXISTS（或类似语法）时比较有用，但是你想要在重新创建时无条件的移除所有的测试数据。在这个案例中第一个脚本通常是一系列DROP语句的集合，然后是一系列Create语句

ignore-failures选项可以被设置成NONE(默认值),DROPS(忽略失败的删除),orALL(忽略所有失败).

每个语句都应该以;隔开，或者；字符不存在于所用的脚本的话使用新的一行。你可以全局控制或者单针对一个脚本控制，例如：

1	<jdbc:initialize-databasedata-source= "dataSource" separator= "@@" >

2	<jdbc:scriptlocation= "classpath:com/foo/sql/db-schema.sql" separator= ";" />

3	<jdbc:scriptlocation= "classpath:com/foo/sql/db-test-data-1.sql" />

4	<jdbc:scriptlocation= "classpath:com/foo/sql/db-test-data-2.sql" />

5	</jdbc:initialize-database>

在这个例子中，两个test-data脚本使用@@作为语句分隔符，并且只有db-schema.sql使用;.配置指定默认分隔符是@@，并且将db-schema脚本内容覆盖默认值。

如果你需要从XML命名空间获取更多控制，你可以直接简单的使用DataSourceInitializer，并且在你的应用中将其定义为一个模块

初始化依赖数据库的其他模块

大多数应用只需要使用数据库初始器基本不会遇到其他问题了：这些基本在Spring上下文初始化之前不会使用到数据库。如果你的应用不属于这种情况则需要使用阅读余下的内容。

数据库初始器依赖于Datasource实例，并且在初始化callback方法中执行脚本（类似于XMLbean定义中的init-method,组件中的@Postconstruct方法，或是在实现了InitializingBean类的afterPropertiesSet()方法）。如果有其他bean也依赖了同样的数据源同时也在初始化回调模块中使用数据源，那么可能会存在问题因为数据还没有初始化。

一个例子是在应用启动时缓存需要从数据库Load并且初始化数据。

为了解决这个问题你有两个选择：改变你的缓存初始化策略将其移到更后面的阶段，或者确保数据库会首先初始化。

如果你可以控制应用的初始化行为那么第一个选项明显更容易。下面是使用这个方式的一些建议，包括：

缓存做懒加载，并且只在第一次访问的时候初始化，这样会提高你应用启动时间。
让你的缓存或者其他独立模块通过实现Lifecycle或者SmartLifecycle接口来初始化缓存。当应用上下文启动时如果autoStartup有设置，SmartLifecycle会被自动启动，而Lifecycle可以在调用ConfigurableApplicationContext.start()时手动启动。
使用Spring的ApplicationEvent或者其他类似的自定义监听事件来触发缓存初始化。ContextRefreshedEvent总是在Spring容器加载完毕的时候使用（在所有Bean被初始化之后）。这类事件钩子(hook)机制在很多时候非常有用（这也是SmartLifecycle的默认工作机制）
第二个选项也可以很容易实现。建议如下：

依赖SpringBeanfatory的默认行为，Bean会按照注册顺序被初始化。你可以通过在XML配置中设置顺序来指定你应用模块的初始化顺序，确保数据库和数据库初始化会首先被执行。
将Datasource和业务模块隔离，通过将它们放在各自独立的ApplicationContext上下文实例来控制其启动顺序。（例如：父上下文包含DataSource，子上下文包含业务模块）。这种结构在SpringWeb应用中很常用，同时也是一种通用做法

原创文章，转载请注明：转载自并发编程网–ifeve.com本文链接地址:

《Spring5官方文档》15.使用JDBC实现数据访问

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： spring

相关文章推荐

新的分享

章节导航