spring JdbcTemplate实现通用的泛型dao一：主功能实现

http://www.dexcoder.com/selfly/article/429

在项目中一直使用Mybaits，最近想自己搞个小项目，通过对比之后发现mybatis的优势并不是十分明显了，个人小项目倾向于更加简洁的DBUtils。Spring jdbc也实现了DBUtils基本一样的功能，项目中又刚好用到了spring，这当然是不二之选了。 Mybaits采用xml的方式，想要实现通用的dao比较的麻烦，spring jdbc没有类似xml的配置文件，实现一个通用的dao反而简单，参考网上的一些介绍结合自己项目的需求，写了一个算是比较规范的通用dao，这里作下整理。 

先来说一下我的通用dao实现的主要几点：

1. 小项目使用的是mysql，所以是基于mysql数据库，但是差别不大，换数据库的话改几行代码就搞定。
2. 可以自定义数据库表名、列名到Java类、属性名称的转换。主要是我设计的数据库表中，列名为了防止关键字等各类冲突，都是以下划线”_”开头和分隔的，无法和Java映射实体类的属性名保持一致。
3. 实现基本的增、删、改、查、分页查询等功能。
4. 因为没有xml等映射配置文件，所以基于编码和命名的规范性(当然不规范也能支持，但是实现自定义名称处理器将会十分复杂)。所有的数据库列名也好，Java属性名也好，映射都是有一定的规范的，不可能说我数据库列名为user_name，java实体类中映射为tomcat。
5. 我数据库表的主键名是基于表名再加上“_id”，例如user表主键即为_user_id（所有列以下划线”_”开头）。
6. 映射的实体类中不能添加数据库表中列不存在的无用字段，这样会使组装的sql语句错误。当然可以用添加注解或其它的方式来判断，但那样会破坏实体类的简洁度。任何情况下不在映射的实体类中添加数据库没有的字段（某些框架的主外键映射除外），如果需要在转换后的VO类中添加，个人认为这是一个好的编码习惯。
7. 基于spring JdbcTemplate。

下面一步一步的来实现我们的通用dao（在最后有给出完整的代码），接口在这里就不晒了，定义了几个方法的名字而已，先来看一下通用dao实现的定义：

1. public abstract class BaseDaoImpl<T> implements BaseDao<T> {
2. /** 具体操作的实体类对象 */
3. private Class<T> entityClass;
4.  
5. /** 名称加工处理器 */
6. private NameHandler nameHandler;
7.  
8. /** spring jdbcTemplate 对象 */
9. @Autowired
10. protected JdbcTemplate jdbcTemplate;
11. }

把类声明为了abstract类型，因为这个类我们是不需要直接实例化的，我们使用实例化的是继承它的子类。 另外在声明类的时候添加了一个泛型参数，这个T即是需要操作的实体类对象。 entityClass用来保存运行时T的具体类型。 nameHandler即自定义名称处理器。 JdbcTemplate spring的JdbcTemplate 对象，注意这里加了注解@Autowired，并声明为protected作用域，这样继承它的子类在使用spring注解声明bean初始化的时候会帮你自动注入jdbcTemplate。当然你也可以使用xml。 我们先来举一个使用的例子，需要实现一个用户表对应的dao，可以像下面声明：

1. public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao {
2. }

声明的这个UserDaoImpl不用写任何代码就拥有了对user表操作基本的增删改查功能，可以省略大量的重复工作。回到正题，声明了User这个泛型对象，要对User表进行操作，这就要求在运行时能够动态的得到User这个对象，因为这个User对象根据实现dao的不同是会变的，怎么在运行时得到它呢？我们来看一下public Type getGenericSuperclass()这个方法，doc上说它用来返回表示当前Class 所表示的实体（类、接口、基本类型或 void）的直接超类的Type，好，有了这个，就能拿到我们想要的了，在UserDaoImpl的构造方法中写入如下代码，在类实例化的时候就拿到具体的实体类型：

1. /**
2. * 构造方法，获取运行时的具体实体对象
3. */
4. public BaseDaoImpl() {
5. Type superclass = getClass().getGenericSuperclass();
6. ParameterizedType type = (ParameterizedType) superclass;
7. entityClass = (Class<T>) type.getActualTypeArguments()[0];
8. }

基本的工作都做完了，接下来实现业务方法，先来实现相对复杂点的insert，说insert复杂是因为它比其它操作多一了个主键的生成，mysql主键的生成由数据库负责比较简单，主要是保存记录后要返回这个主键以供后面可能需要的其它操作使用，所以不能用简单的调用update或execute方法传入sql完事了，spring提供了KeyHolder的实现，看下面代码：

1. /**
2. * 插入一条记录
3. *
4. * @param entity
5. */
6. @Override
7. public Long insert(T entity) {
8. final SqlContext sqlContext = SqlUtils.buildInsertSql(entity, this.getActualNameHandler());
9. KeyHolder keyHolder = new GeneratedKeyHolder();
10. jdbcTemplate.update(new PreparedStatementCreator() {
11. public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
12. PreparedStatement ps = con.prepareStatement(sqlContext.getSql().toString(),
13. new String[] { sqlContext.getPrimaryKey() });
14. int index = 0;
15. for (Object param : sqlContext.getParams()) {
16. index++;
17. ps.setObject(index, param);
18. }
19. return ps;
20. }
21. }, keyHolder);
22. return keyHolder.getKey().longValue();
23. }

代码很简单，主键将在保存后返回。实现了insert方法，其它的就简单了，下面是整个类的源码：

1. /**
2. * 泛型通用dao实现 依赖于spring jdbc
3. *
4. * User: liyd
5. * Date: 2/12/14
6. * Time: 2:34 PM
7. */
8. public abstract class BaseDaoImpl<T> implements BaseDao<T> {
9.  
10. /** 具体操作的实体类对象 */
11. private Class<T> entityClass;
12.  
13. /** 名称加工处理器 */
14. private NameHandler nameHandler;
15.  
16. /** spring jdbcTemplate 对象 */
17. @Autowired
18. protected JdbcTemplate jdbcTemplate;
19.  
20. /**
21. * 构造方法，获取运行时的具体实体对象
22. */
23. public BaseDaoImpl() {
24. Type superclass = getClass().getGenericSuperclass();
25. ParameterizedType type = (ParameterizedType) superclass;
26. entityClass = (Class<T>) type.getActualTypeArguments()[0];
27. }
28.  
29. /**
30. * 获取实际运行时的名称处理器
31. *
32. * @return
33. */
34. private NameHandler getActualNameHandler() {
35. if (nameHandler == null) {
36. synchronized (this) {
37. if (nameHandler == null) {
38. nameHandler = this.getNameHandler();
39. }
40. }
41. }
42. return nameHandler;
43. }
44.  
45. /**
46. * 得到名称处理器，子类覆盖此方法实现自己的名称转换处理器
47. *
48. * @return
49. */
50. protected NameHandler getNameHandler() {
51. return new DefaultNameHandler();
52. }
53.  
54. /**
55. * 插入一条记录
56. *
57. * @param entity
58. */
59. @Override
60. public Long insert(T entity) {
61. final SqlContext sqlContext = SqlUtils.buildInsertSql(entity, this.getActualNameHandler());
62. KeyHolder keyHolder = new GeneratedKeyHolder();
63. jdbcTemplate.update(new PreparedStatementCreator() {
64. public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
65. PreparedStatement ps = con.prepareStatement(sqlContext.getSql().toString(),
66. new String[] { sqlContext.getPrimaryKey() });
67. int index = 0;
68. for (Object param : sqlContext.getParams()) {
69. index++;
70. ps.setObject(index, param);
71. }
72. return ps;
73. }
74. }, keyHolder);
75. return keyHolder.getKey().longValue();
76. }
77.  
78. /**
79. * 更新记录
80. *
81. * @param entity
82. */
83. @Override
84. public void update(T entity) {
85. SqlContext sqlContext = SqlUtils.buildUpdateSql(entity, this.getActualNameHandler());
86. jdbcTemplate.update(sqlContext.getSql().toString(), sqlContext.getParams().toArray());
87. }
88.  
89. /**
90. * 删除记录
91. *
92. * @param id
93. */
94. @Override
95. public void delete(Serializable id) {
96. String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
97. String primaryName = this.getNameHandler().getPrimaryName(entityClass.getSimpleName());
98. String sql = "DELETE FROM " + tableName + " WHERE " + primaryName + " = ?";
99. jdbcTemplate.update(sql, id);
100. }
101.  
102. /**
103. * 删除所有记录
104. */
105. @Override
106. public void deleteAll() {
107. String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
108. String sql = " TRUNCATE TABLE " + tableName;
109. jdbcTemplate.execute(sql);
110. }
111.  
112. /**
113. * 得到记录
114. *
115. * @param id
116. * @return
117. */
118. @Override
119. public T getById(Serializable id) {
120. String tableName = this.getNameHandler().getTableName(entityClass.getSimpleName());
121. String primaryName = this.getNameHandler().getPrimaryName(entityClass.getSimpleName());
122. String sql = "SELECT * FROM " + tableName + " WHERE " + primaryName + " = ?";
123. return (T) jdbcTemplate.query(sql,
124. new DefaultRowMapper(entityClass, this.getActualNameHandler()), id).get(0);
125. }
126.  
127. /**
128. * 查询所有记录
129. *
130. * @return
131. */
132. @Override
133. public List<T> findAll() {
134. String sql = "SELECT * FROM "
135. + this.getActualNameHandler().getTableName(entityClass.getSimpleName());
136. return (List<T>) jdbcTemplate.query(sql,
137. new DefaultRowMapper(entityClass, this.getActualNameHandler()));
138. }
139.  
140. /**
141. * 查询记录数
142. *
143. * @param entity
144. * @return
145. */
146. public int queryCount(T entity) {
147. String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
148. StringBuilder countSql = new StringBuilder("select count(*) from ");
149. countSql.append(tableName);
150. SqlContext sqlContext = SqlUtils.buildQueryCondition(entity, this.getActualNameHandler());
151. if (sqlContext.getSql().length() > 0) {
152. countSql.append(" where ");
153. countSql.append(sqlContext.getSql());
154. }
155. return jdbcTemplate.queryForInt(countSql.toString(), sqlContext.getParams().toArray());
156. }
157.  
158. /**
159. * 查询分页列表
160. *
161. * @param entity
162. * @return
163. */
164. public Pager queryPageList(T entity) {
165. Pager pager = new Pager();
166. PagingOrder pagingOrder = (PagingOrder) entity;
167. pager.setCurPage(pagingOrder.getCurPage());
168. pager.setItemsPerPage(pagingOrder.getItemsPerPage());
169.  
170. String tableName = this.getActualNameHandler().getTableName(entityClass.getSimpleName());
171. String primaryName = this.getActualNameHandler()
172. .getPrimaryName(entityClass.getSimpleName());
173. StringBuilder querySql = new StringBuilder("select * from ");
174. StringBuilder countSql = new StringBuilder("select count(*) from ");
175. querySql.append(tableName);
176. countSql.append(tableName);
177. //不调用queryCount方法，条件共同组装一次，减少反射获取的次数
178. SqlContext sqlContext = SqlUtils.buildQueryCondition(entity, this.getActualNameHandler());
179. if (sqlContext.getSql().length() > 0) {
180. querySql.append(" where ");
181. countSql.append(" where ");
182. querySql.append(sqlContext.getSql());
183. countSql.append(sqlContext.getSql());
184. }
185. querySql.append(" order by ");
186. querySql.append(primaryName);
187. querySql.append(" desc ");
188. querySql.append("limit ?,?");
189. List<Object> queryParams = new ArrayList<Object>(sqlContext.getParams());
190. queryParams.add(pager.getBeginIndex());
191. queryParams.add(pager.getItemsPerPage());
192.  
193. List<T> list = (List<T>) jdbcTemplate.query(querySql.toString(), queryParams.toArray(),
194. new DefaultRowMapper(entityClass, this.getActualNameHandler()));
195.  
196. int totalCount = jdbcTemplate.queryForInt(countSql.toString(), sqlContext.getParams()
197. .toArray());
198. pager.setList(list);
199. pager.setItems(totalCount);
200. return pager;
201. }
202. }

这样，一个通用dao的实现思路已经清晰给出了。可能你注意到了里面的几个细节部分的几个方法，

SqlUtils.buildUpdateSql(entity, this.getActualNameHandler()); 

构建动态的sql，getActualNameHandler获取具体的名称处理器实现属性名到列名的转换。 (List) jdbcTemplate.query(sql, new DefaultRowMapper(entityClass, this.getActualNameHandler()));

 其中DefaultRowMapper是自定义实现的数据到实体对象的转换。

篇幅所限，具体见其专门的介绍。