Spring 注解学习手札（四） 持久层浅析

这里将用到以下几个包：

引用

aopalliance-1.0.jar
commons-collections.jar
commons-dbcp.jar
commons-logging-1.1.1.jar
commons-pool.jar
jstl.jar
log4j-1.2.15.jar
mysql-connector-java-5.1.6-bin.jar
spring-beans-2.5.6.jar
spring-context-2.5.6.jar
spring-context-support-2.5.6.jar
spring-core-2.5.6.jar
spring-jdbc-2.5.6.jar
spring-tx-2.5.6.jar
spring-web-2.5.6.jar
spring-webmvc-2.5.6.jar
standard.jar

主要增加了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. CREATEDATABASE`spring`/*!40100DEFAULTCHARACTERSETutf8*/;

建表：

Sql代码

1. DROPTABLEIFEXISTS`spring`.`account`;
2. CREATETABLE`spring`.`account`(
3. `id`int(10)unsignedNOTNULLAUTO_INCREMENT,
4. `username`varchar(45)NOTNULL,
5. `password`varchar(45)NOTNULL,
6. `birthday`datetimeNOTNULL,
7. `email`varchar(45)NOTNULL,
8. PRIMARYKEY(`id`)
9. )ENGINE=InnoDBAUTO_INCREMENT=2DEFAULTCHARSET=utf8;

插入默认数据：

Sql代码

1. INSERTINTO`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. publicclassAccountimplementsSerializable{
3. /**
4. *主键
5. */
6. privateintid;
8. /**
9. *用户名
10. */
11. privateStringusername;
13. /**
14. *密码
15. */
16. privateStringpassword;
18. /**
19. *生日
20. */
21. privateDatebirthday;
23. /**
24. *Email
25. */
26. privateStringemail;
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. publicinterfaceAccountDao{
3. /**
4. *读取账户信息
5. *
6. *@paramusername
7. *@return
8. */
9. Accountread(Stringusername);
11. /**
12. *读取账户信息
13. *
14. *@paramid
15. *@return
16. */
17. Accountread(intid);
18. }

AccountDaoImpl.java

Java代码

1. /**
2. *2010-1-23
3. */
4. packageorg.zlex.spring.dao.impl;
6. importjava.sql.ResultSet;
7. importjava.sql.SQLException;
9. importorg.springframework.beans.factory.annotation.Autowired;
10. importorg.springframework.jdbc.core.JdbcTemplate;
11. importorg.springframework.jdbc.core.RowMapper;
12. importorg.springframework.stereotype.Repository;
13. importorg.zlex.spring.dao.AccountDao;
14. importorg.zlex.spring.domain.Account;
16. /**
17. *账户数据库实现
18. *
19. *@author<ahref="mailto:zlex.dongliang@gmail.com">梁栋</a>
20. *@version1.0
21. *@since1.0
22. */
23. @Repository
24. publicclassAccountDaoImplimplementsAccountDao{
26. @Autowired
27. privateJdbcTemplatejdbcTemplate;
29. @Override
30. publicAccountread(Stringusername){
31. Stringsql="SELECT*FromaccountWHEREusername=?";
32. return(Account)jdbcTemplate.queryForObject(sql,
33. newObject[]{username},accountRowMap);
34. }
36. @Override
37. publicAccountread(intid){
38. Stringsql="SELECT*FromaccountWHEREid=?";
39. return(Account)jdbcTemplate.queryForObject(sql,newObject[]{id},
40. accountRowMap);
41. }
43. protectedRowMapperaccountRowMap=newRowMapper(){
44. @Override
45. publicObjectmapRow(ResultSetrs,introwNum)throwsSQLException{
46. Accountaccount=newAccount();
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. returnaccount;
53. }
54. };
55. }

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

Java代码

1. @Autowired
2. privateJdbcTemplatejdbcTemplate;

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

Java代码

1. protectedRowMapperaccountRowMap=newRowMapper(){
2. @Override
3. publicObjectmapRow(ResultSetrs,introwNum)throwsSQLException{
4. Accountaccount=newAccount();
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. returnaccount;
11. }
12. };

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

Java代码

1. @Override
2. publicAccountread(Stringusername){
3. Stringsql="SELECT*FromaccountWHEREusername=?";
4. return(Account)jdbcTemplate.queryForObject(sql,
5. newObject[]{username},accountRowMap);
6. }
8. @Override
9. publicAccountread(intid){
10. Stringsql="SELECT*FromaccountWHEREid=?";
11. return(Account)jdbcTemplate.queryForObject(sql,newObject[]{id},
12. accountRowMap);
13. }

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

Java代码

1. publicclassAccountServiceImplimplementsAccountService{
3. @Autowired
4. privateAccountDaoaccountDao;
6. @Override
7. publicAccountread(Stringusername,Stringpassword){
8. Accountaccount=accountDao.read(username);
10. if(!password.equals(account.getPassword())){
11. account=null;
12. }
13. returnaccount;
14. }
16. @Override
17. publicAccountread(intid){
18. returnaccountDao.read(id);
19. }
20. }

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

Jsp代码

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

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