学步园

这里将用到以下几个包： 

主要增加了commons-collections.jar、commons-dbcp.jar、commons-pool.jar、mysql-connector-java-5.1.6-bin.jar和spring-jdbc-2.5.6.jar 
先弄个数据库，这里使用MySQL，我的最爱！ 可惜前途未卜！ 
建库： 

Sql代码  

1. CREATE DATABASE `spring` /*!40100 DEFAULT CHARACTER SET utf8 */;  

建表： 

Sql代码  

1. DROP TABLE IF EXISTS `spring`.`account`;  
2. CREATE TABLE  `spring`.`account` (  
3.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,  
4.   `username` varchar(45) NOT NULL,  
5.   `password` varchar(45) NOT NULL,  
6.   `birthday` datetime NOT NULL,  
7.   `email` varchar(45) NOT NULL,  
8.   PRIMARY KEY (`id`)  
9. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;  

插入默认数据： 

Sql代码  

1. INSERT INTO `spring`.`account`(  
2.  `username`,  
3.  `password`,  
4.  `birthday`,  
5.  `email`)  
6. VALUES(  
7.  'snowolf',  
8.  'zlex',  
9.  '2010-01-01',  
10.  'snowolf@zlex.org');  

给出一个数据库查询的结果： 
 
很不巧，为了能让数据查询更有意义，我又要改动Account类： 
Account.java 

Java代码  

1. public class Account implements Serializable {  
2.   
3.     /** 
4.      * 主键 
5.      */  
6.     private int id;  
7.       
8.     /** 
9.      * 用户名 
10.      */  
11.     private String username;  
12.       
13.     /** 
14.      * 密码 
15.      */  
16.     private String password;  
17.   
18.     /** 
19.      * 生日 
20.      */  
21.     private Date birthday;  
22.   
23.     /** 
24.      * Email 
25.      */  
26.     private String email;  
27.       
28.         // get方法set方法省略  
29. }  

这样，域对象与数据库表将完成一一对应绑定关系。 
再建立一个用于构建数据源配置的文件database.properties 
database.properties： 

Properties代码  

1. dataSource.driverClassName=com.mysql.jdbc.Driver  
2. dataSource.url=jdbc:mysql://localhost:3306/spring  
3. dataSource.username=root  
4. dataSource.password=admin  
5. dataSource.maxActive=200  
6. dataSource.maxIdle=50  
7. dataSource.maxWait=10000  

该文件位于/WEB-INF/目录下。 
接下来，我们需要把它引入spring容器，修改applicationContext.xml： 
applicationContext.xml 

Xml代码  

1. <context:property-placeholder  
2.     location="/WEB-INF/database.properties" />  

如果需要引入多个properties文件，可以用逗号分隔。 
这时，我们已经引入了数据源配置，我们可以通过修改dao.xml构建基于DBCP的数据源： 
dao.xml中dataSource配置 

Xml代码  

1. <bean  
2.         id="dataSource"  
3.         class="org.apache.commons.dbcp.BasicDataSource"  
4.         destroy-method="close"  
5.         lazy-init="false"  
6.         p:driverClassName="${dataSource.driverClassName}"  
7.         p:url="${dataSource.url}"  
8.         p:username="${dataSource.username}"  
9.         p:password="${dataSource.password}"  
10.         p:maxActive="${dataSource.maxActive}"  
11.         p:maxIdle="${dataSource.maxIdle}"  
12.         p:maxWait="${dataSource.maxWait}" />  

上述配置稀松平常，没有什么好阐述的内容，这与一般spring配置无异样。 
需要注意的是这个jdbcTemplate配置！ 
dao.xml中jdbcTemplate配置 

Xml代码  

1. <bean  
2.     class="org.springframework.jdbc.core.JdbcTemplate"  
3.     p:dataSource-ref="dataSource" />  

这个配置很关键，如果你要使用其他的ORM框架，同样需要配置这样的模板类，在Dao实现中无需继承JdbcDaoSupport类。 
不需要明确JdbcTemplate的id（id="jdbcTemplate"）吗？不再需要了！ 
AccountDao.java 

Java代码  

1. public interface AccountDao {  
2.   
3.     /** 
4.      * 读取账户信息 
5.      *  
6.      * @param username 
7.      * @return 
8.      */  
9.     Account read(String username);  
10.   
11.     /** 
12.      * 读取账户信息 
13.      *  
14.      * @param id 
15.      * @return 
16.      */  
17.     Account read(int id);  
18. }  

AccountDaoImpl.java 

Java代码  

1. /** 
2.  * 2010-1-23 
3.  */  
4. package org.zlex.spring.dao.impl;  
5.   
6. import java.sql.ResultSet;  
7. import java.sql.SQLException;  
8.   
9. import org.springframework.beans.factory.annotation.Autowired;  
10. import org.springframework.jdbc.core.JdbcTemplate;  
11. import org.springframework.jdbc.core.RowMapper;  
12. import org.springframework.stereotype.Repository;  
13. import org.zlex.spring.dao.AccountDao;  
14. import org.zlex.spring.domain.Account;  
15.   
16. /** 
17.  * 账户数据库实现 
18.  *  
19.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a> 
20.  * @version 1.0 
21.  * @since 1.0 
22.  */  
23. @Repository  
24. public class AccountDaoImpl implements AccountDao {  
25.   
26.     @Autowired  
27.     private JdbcTemplate jdbcTemplate;  
28.   
29.     @Override  
30.     public Account read(String username) {  
31.         String sql = "SELECT * From account WHERE username = ?";  
32.         return (Account) jdbcTemplate.queryForObject(sql,  
33.                 new Object[] { username }, accountRowMap);  
34.     }  
35.   
36.     @Override  
37.     public Account read(int id) {  
38.         String sql = "SELECT * From account WHERE id = ?";  
39.         return (Account) jdbcTemplate.queryForObject(sql, new Object[] { id },  
40.                 accountRowMap);  
41.     }  
42.   
43.     protected RowMapper accountRowMap = new RowMapper() {  
44.         @Override  
45.         public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  
46.             Account account = new Account();  
47.             account.setId(rs.getInt("id"));  
48.             account.setUsername(rs.getString("username"));  
49.             account.setPassword(rs.getString("password"));  
50.             account.setBirthday(rs.getDate("birthday"));  
51.             account.setEmail(rs.getString("email"));  
52.             return account;  
53.         }  
54.     };  
55. }  

分段详述： 
注解@Repository明确这个类是用于持久层的实现类，注意这样的注解不能用于接口，仅适用于实现类！ 
同时，不再需要继承JdbcDaoSupport类，其而代之的是直接注入JdbcTemplate类！ 
再看声明JdbcTemplate类： 

Java代码  

1. @Autowired  
2. private JdbcTemplate jdbcTemplate;  

需要说明一下，这里的JdbcTemplate对象jdbcTemplate名称可以自定，没有任何限制！ 
这里使用 RowMapper 定义了一个用于绑定Account域对象的内部映射类： 
RowMapper 

Java代码  

1. protected RowMapper accountRowMap = new RowMapper() {  
2.     @Override  
3.     public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  
4.         Account account = new Account();  
5.         account.setId(rs.getInt("id"));  
6.         account.setUsername(rs.getString("username"));  
7.         account.setPassword(rs.getString("password"));  
8.         account.setBirthday(rs.getDate("birthday"));  
9.         account.setEmail(rs.getString("email"));  
10.         return account;  
11.     }  
12. };  

语句级的内容，十分简单，如下所示： 

Java代码  

1. @Override  
2. public Account read(String username) {  
3.     String sql = "SELECT * From account WHERE username = ?";  
4.     return (Account) jdbcTemplate.queryForObject(sql,  
5.             new Object[] { username }, accountRowMap);  
6. }  
7.   
8. @Override  
9. public Account read(int id) {  
10.     String sql = "SELECT * From account WHERE id = ?";  
11.     return (Account) jdbcTemplate.queryForObject(sql, new Object[] { id },  
12.             accountRowMap);  
13. }  

写完这两段代码不由感慨，我曾经就这么噼里啪啦的敲了一年多这样的代码。不断的做绑定、映射、写SQL，直到可以有机会将持久层JDBC实现替换Hibernate、iBatis，我才得以解放！ 
接着，再调整一下Service实现类 
AccountServiceImpl.java 

Java代码  

1. public class AccountServiceImpl implements AccountService {  
2.   
3.     @Autowired  
4.     private AccountDao accountDao;  
5.   
6.     @Override  
7.     public Account read(String username, String password) {  
8.         Account account = accountDao.read(username);  
9.   
10.         if (!password.equals(account.getPassword())) {  
11.             account = null;  
12.         }  
13.         return account;  
14.     }  
15.   
16.     @Override  
17.     public Account read(int id) {  
18.         return accountDao.read(id);  
19.     }  
20. }  

使用AccountDao接口来完成响应的操作，逻辑部分不做详述，根据业务逻辑而定！ 
稍稍修改一下profile.jsp，将用户的生日、邮件地址都输出出来！ 

Jsp代码  

1. <fieldset><legend>用户信息</legend>  
2. <ul>  
3.     <li><label>用户名:</label><c:out value="${account.username}" /></li>  
4.     <li><label>生日:</label><fmt:formatDate value="${account.birthday}"  
5.         pattern="yyyy年MM月dd日" /></li>  
6.     <li><label>Email:</label><c:out value="${account.email}" /></li>  
7. </ul>  
8. </fieldset>  
9. 标签<fmt:formatDate />用于格式化输出，大家可以了解一下，很简单很好用的标签！ :D   

启动应用，登录，查看用户信息：