Spring in Action 学习笔记—第四章 征服数据库(转)

Spring2.0正式版（http://www.springframework.org/download）
Spring2.0中文文档（http://spring.jactiongroup.net/viewtopic.php?t=2279&sid=0906ae6a913537b249e501db5b54c181）。
 
在前面的学习之后，我们已经了解了Spring框架的核心，在本章中作者向我们讲述了Spring的持久化层，向我们介绍了Srping对JDBC的支持。还向读者介绍了Spring如何与当前流行的一些ORM框架，如Hibernate、JDO、OJB、和iBATIS等集成。 

一、学习Spring的DAO理念 
DAO代表数据访问对象（Data Access Object）。它完美地描述了在一个应用中DAO的角色。DAO的存在提供了读写数据库中数据的一种方法。只要把这个功能通过接口暴露，应用的其他部分就可以通过这个接口来访问数据库了。下图展示了设计数据访问层的合适途径： 
 
如上图所示，服务对象不再和特定的数据访问实现邦定在一起，使得他们易于测试。此外，我们是通过与持久化技术无关的方式来访问数据访问层的，DAO接口不需要暴露他采用什么技术去访问数据。Spring帮你把数据访问层从应用的其他部分隔离开来的一种方法是：提供一套贯穿整个DAO框架的一致的分级异常体系。 
1．理解Spring的DataAccessException 
Spring的DAO框架没有抛出与特定技术相关的异常，Spring提供了一种方便的方法，把特定于某种技术的异常，如SQLException，转化为自己的异常，这种异常属于以DataAccessException为异常层次。 
DataAccessException是RuntimeException，所以它是一个无需检测的异常。意思是说，当他们被数据访问层抛出时，并不需要你的代码去处理这类异常。这遵循了Spring的一般理念：异常检查会使你的代码到处是不相关的catch或throws语句，使代码杂乱无章。对数据访问异常来说，这点尤为正确，因为我们在写连接数据库和操作数据库表的代码中，总是充斥着大量的异常。 
一般情况下，我们的数据库访问API总是要抛出一个有意义的异常。JDO有它自己的异常层次。下图是Spring2.0中定义的异常层次。 

上图所包括的异常类只是整个庞大的DataAccessException异常层次中的一部分。

2．一致的DAO支持 
不管我们采用什么技术，某些数据库访问的步骤是必须的。如数据库连接，操作，操作完后释放连接。这些都是固定步骤。Spring把数据库访问流程中的固定部分和可变部分分开，分别映射成两个截然不同的类：模板（Template）和回调（Callback）。模板管理流程的固定部分，而在回调处填写实现细节。如下图所示： 

在上图中Spring的模板类处理数据访问的不变部分—事务控制、资源管理以及异常处理。回调接口的实现定义了特定于应用的部分—创建statement，邦定参数以及整理结果集（ResultSet）。这样我们只需要关心数据访问的逻辑就可以了。 
为了便于以一种一致的方式使用各种数据库访问技术，如JDBC、JDO和Hibernate，Spring提供了一套抽象DAO类供我们进行扩展。这些抽象类提供了一些方法，通过它们我们可以获得与当前数据访问技术相关的数据源和其他配制信息。 
这些类是： 
l         JdbcDaoSupport – JDBC数据访问对象的基类。 
l         HibernateDaoSupport – Hibernate数据访问对象的基类。 
l         JdoDaoSupport – JDO数据访问对象的基类。 
l         JpaDaoSupport – JPA数据访问的基类。 
对于以上四个类，更详细的内容请参看Spring2.0第十章。 

二、在Spring中使用JDBC 
起初我们在使用Java连接数据库时候都使用的是JDBC，刚开始可能是对数据库表作一个操作就会连接一次数据库，然后再将数据库连接关闭。大概是这样的步骤：连接数据库-- 对某表进行操作—关闭数据库，后来一些人对数据库的操作进行了封装，将数据库的连接操作关闭等动作放到一个类中（http://blog.csdn.net/qutr/archive/2006/09/25/1274826.aspx），还有人设计出了数据库连接池，使得数据库连接所占有的资源更少，效率更高。这样的做法，缺点是当我们只需要一种操作（插入、删除、更新、选择）时我们要额外的多写出20—30行代码。优点是，有利于我们对资源的控制。那么在Spring中我们有了更多更好的选择。 
1．Spring2.0中的包 
Spring JDBC抽象框架由四个包构成：core、 dataSource、object以及support。 
org.springframework.jdbc.core包由JdbcTemplate类以及相关的回调接口（callback interface）和类组成。 
org.springframework.jdbc.datasource包由一些用来简化DataSource访问的工具类，以及各种DataSource接口的简单实现(主要用于单元测试以及在J2EE容器之外使用JDBC)组成。工具类提供了一些静态方法，诸如通过JNDI获取数据连接以及在必要的情况下关闭这些连接。它支持绑定线程的连接，比如被用于DataSourceTransactionManager的连接。 
org.springframework.jdbc.object包由封装了查询、更新以及存储过程的类组成，这些类的对象都是线程安全并且可重复使用的。它们类似于JDO，与JDO的不同之处在于查询结果与数据库是“断开连接”的。它们是在org.springframework.jdbc.core包的基础上对JDBC更高层次的抽象。 
org.springframework.jdbc.support包提供了一些SQLException的转换类以及相关的工具类。 
在JDBC处理过程中抛出的异常将被转换成org.springframework.dao包中定义的异常。因此使用Spring JDBC进行开发将不需要处理JDBC或者特定的RDBMS才会抛出的异常。所有的异常都是unchecked exception，这样我们就可以对传递到调用者的异常进行有选择的捕获 
2．使用JdbcTemplate 
当我们写JDBC的相关代码时候，总是写很多的代码来维护资源的连接和释放，还要处理各种异常情况。写出的try-catch语句通常会打乱程序结构。使用Spring JDBC会使我们的JDBC代码非常干净，我们不必再去写繁琐的statement和各种查询语句。提供这一功能的就是JdbcTemplate类，它存在于org.springframework.jdbc.core包下，创建一个JdbcTemplate类的实例相当简单： 
JdbcTemplate jdbcTem = new JdbcTemplate(dataSource); 
关于dataSource是DataSource的一个实例，DataSource在javax.sql包下，他是一个interface所以我们要实现他，DataSource是JDBC规范的一部分，它被视为一个通用的数据库连接工厂。通过使用DataSource， Container或Framework可以将连接池以及事务管理的细节从应用代码中分离出来。在这里我们使用DriverManagerDataSource，不过DataSource有多种实现，详细说明可以参考Spring参考手册（官方文档）。看下面的代码示例： 
    DriverManagerDataSource dataSource = new DriverManagerDataSource(); 
    dataSource.setDriverClassName("com.mysql.jdbc.Driver"); 
    dataSource.setUrl("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=gb2312&autoReconnect=true"); 
    dataSource.setUsername("root"); 
    dataSource.setPassword(""); 
当我们设置好DataSource和得到JdbcTemplate对象后就可以开始对数据库进行各种查询和更新了。 
3．写入数据 
在《Spring In Action》一书中作者介绍了好几种方法，这里只展示一种。首先，设置数据： 
    private DataSource dataSource; 
    private JdbcTemplate jdbcTemlate = new JdbcTemplate(dataSource); 
    private Person person = new Person(); 

    publicvoid setValue(PreparedStatement ps) throws SQLException 
    { 
       ps.setInt(0, person.getId()); 
       ps.setString(1, person.getFirstName()); 
       ps.setString(2, person.getLastName()); 
    }//end setValue(...) 

    publicint insertPerson(Person person) 
    { 
       String insertSql = "insert into person (id, firstName, lastName) values(?, ?, ?)"; 
       Object[] params = new Object[] {person.getId(), person.getFirstName(), person.getLastName()}; 
       returnjdbcTemlate.update(insertSql, params); 
    }//end insertPerson(...) 
最后一个insertPerson函数实现了插入一条记录的操作，可以看到非常的简单。当我们使用了JdbcTemplate后我们不必去担心数据库的关闭，再JdbcTemplate类中，在适当的地方已经为我们将数据库关闭了。 
使用BatchPreparedStatementSetter这个接口，一次插入多条记录。该接口有两个方法： 
void setValues(PreparedStatement ps, int i) throws SQLException;和 
int getBatchSize();其中getBatchSize()告诉JdbcTemplate到底有多少语句要创建。看下面的代码： 
    publicint[] updatePersons(final List persons) 
    { 
       String insertSql = "insert into person (id, firstName, lastName) values(?, ?, ?)"; 
       BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter(){ 
           publicint getBatchSize(){ 
              return persons.size(); 
           } 

           publicvoid setValues(PreparedStatement ps, int index)throws SQLException { 
              Person person = (Person)persons.get(index); 
              ps.setInt(0, person.getId()); 
              ps.setString(1, person.getFirstName()); 
              ps.setString(2, person.getLastName()); 
           } 
       }; 

       returnjdbcTemlate.batchUpdate(insertSql, setter); 
    }//end updatePersons(...) 
这样就实现了一次插入多个记录。 
4．读数据 
在JDBC中取得一条记录的结果需要通过ResultSet。在Spring JDBC中已经帮我们处理了这些。通过实现RowCallbackHandler接口中仅有的一个方法来完成。该方法为： 
void processRow(ResultSet rs) throws SQLException; 
下面的代码展示了如何使用RowCallbackHandler接口来选择一条记录。 
    public Person getPerson(final Integer id) 
    { 
       String sql = "select id, first_name, last_name from person where id = ?"; 
       final Person person = new Person(); 
       final Object[] params = new Object[] {id}; 
       jdbcTemplate.query(sql, params, new RowCallbackHandler(){ 
           publicvoid processRow(ResultSet rs) throws SQLException{ 
              person.setId(rs.getInt("id")); 
              person.setFirstName(rs.getString("first_name")); 
              person.setLastName(rs.getString("last_name")); 
           } 
       }); 
       return person; 
    }//end getPerson(...) 
利用Spring JDBC提供的RowMapper接口我们可以把ResultSet中的一条记录映射成一个对象。这个在《Spring In Action》一书中都讲解的比较详细这里就不再说了。 
值得注意的是在Spring2.0中为我们提供了一个NamedParameterJdbcTemplate类，该类为JDBC查询提供了带命名参数的占位符，而不止是JDBC自己的“？”，这样使用JDBC的时候，也可以很容易的构造出来带占位符的动态条件查询，而不是参数值带入方式的拼接SQL字符串了。（引自：Spring2.0的新特性点评）确实也是这样，而且在Spring的2.0文档中，作者用了较大篇幅介绍了该类。察看Spring2.0的原代码（该类在org.springframework.jdbc.core.namedparam包下）可以看到： 
    public NamedParameterJdbcTemplate(DataSource dataSource) { 
       Assert.notNull(dataSource, "The [dataSource] argument cannot be null."); 
       this.classicJdbcTemplate = new JdbcTemplate(dataSource); 
    } 
他事实上调用了JdbcTemplate类。关于Spring JDBC的更多更详细的内容请参看Spring2.0官方文档，上面讲解的非常透彻，代码实例也非常明了。 
还有一个类值得我们关注：SimpleJdbcTemplate类，该类是JdbcTemplate类的一个包装器（wrapper），它利用了Java 5的一些语言特性，特别适合在JDK5下编程的人。下面引用一个例子： 
public Actor findActor(long id) 
{ 
    String sql = "select id, first_name, last_name from T_ACTOR where id = ?"; 
    ParameterizedRowMapper<Actor> mapper = new ParameterizedRowMapper()<Actor> { 
        public Actor mapRow(ResultSet rs, int rowNum) throws SQLException { 
            Actor actor = new Actor(); 
            actor.setId(rs.getLong("id")); 
            actor.setFirstName(rs.getString("first_name")); 
            actor.setLastName(rs.getString("last_name")); 
            return actor; 
        } 
    }; 
    SimpleJdbcTemplate simpleJdbcTemplate = new SimpleJdbcTemplate(this.getDataSource()); 
    return simpleJdbcTemplate.queryForObject(sql, mapper, id); 
} 

三、Spring的ORM框架支持 
Spring除了很好的封装了JDBC外还支持以下持久层框架： 
l         Hibernate（http://www.hibernate.org/） 
l         JDO（http://java.sun.com/products/jdo/） 
l         iBATIS（http://ibatis.apache.org/） 
l         OJB（http://db.apache.org/ojb/） 
在我目前手头上的工作来看，有了JDBC已经足够我用了。但是学习是无止境的，看网上那帮人整天这个框架那个框架的大谈特谈，学到这里的我肯定不会停止不前的。我的决定是学习Hibernate，当然JDO是标准，iBATIS和OJB也是非常的强悍。 
写到这里下面应该接着写以上框架的一种或几种了，那么按照我的计划应该最少写点Hibernate的内容，但是很不幸的是由于太忙Hibernate学的还非常浅薄有限。思前想后，我应该停下来了。因为自打《Spring In Action》学习笔记开写以来，文章一篇比一篇质量差，贴到Blog上的东西虽然是督促自己学习的，但是肯定是有人看的。为了对得起自己，对得起看文章的人，我觉定还是把质量提高比较重要。所以到这里我要打住了。等在实践中有了经验和领悟，我会写一个关于Hibernate的专题。希望这一天早日到来。 

四、小结 
Spring的持久化技术是多种多样的，但是不管用什么样的持久化技术，Spring的目标就是让它对应用系统的其他部分来说是透明的。这样我们在编写持久层的时候可以减轻工作量，减少出错的几率。使我们对于数据库的操作更为方便和简单。