开源框架spring学习之道：spring对JDBC的支持(二)

Java的代码  

1.  API的使用。  
2. Java的代码    
3. 包 com.zxf.domain;    
4. 导入 java.util.Date的;    
5.     
6. / **  
7.  * @作者z_xiaofei168  
8.  * /    
9. 公共 类 帐户{    
10.     私人 长的ID;    
11.     私人 弦乐LOGINNAME;    
12.     私人 弦乐密码;    
13.     私人 弦乐电子邮件;    
14.     私人 弦乐手机;    
15.     私人 日期registedTime;    
16.         
17.     / /以下省略所以的设置和获取方法    
18. }    
19.      
20.    3.1 ，使用的JdbcTemplate类  
21.     
22. Java的代码    
23. 包 com.zxf.dao;    
24.     
25. 进口 的java.util.List;    
26. 导入 com.zxf.domain.Account;    
27.     
28. / **账户的DAO接口* /    
29. 公共 接口 AccountDao {    
30.     / **新增账户* /    
31.     无效 创建（帐户ACC）;    
32.     / **删除指定账户* /    
33.     无效 删除（帐号ACC）;    
34.     / **更新账户中* /    
35.     无效 更新（帐户ACC）;    
36.     / **查询指定ID的账户* /    
37.     findById帐户（隆ID）;    
38.     / **查询所有账户* /    
39.     列表<Account>的findAll（）;    
40. }    
41.     
42.     
43.     
44. 包 com.zxf.dao;    
45.     
46. 进口 的java.sql.ResultSet;    
47. 进口 的java.sql.SQLException;    
48. 导入 的java.sql.Timestamp;    
49. 导入 java.util.Date的;    
50. 进口 的java.util.List;    
51.     
52. 导入 了javax.sql.DataSource;    
53.     
54. 进口 org.springframework.jdbc.core.JdbcTemplate;    
55. 导入 org.springframework.jdbc.core.RowMapper;    
56.     
57. 导入 com.zxf.domain.Account;    
58.     
59. / **  
60.  * AccountDao实现类  
61.  *使用的JdbcTemplate来实现  
62.  * /    
63. 公共 类实现 AccountDao的{    
64.     私人 的JdbcTemplate的JdbcTemplate;    
65.         
66.     公共 无效 的setDataSource（DataSource的数据源）{    
67.         JdbcTemplate的=  新的 JdbcTemplate（数据源）;    
68.     }    
69.     
70.     公共 无效 创建（帐户ACC）{    
71.         弦乐的sql =  “INSERT INTO帐户（登录名，密码，电子邮件，”    
72.                 + “手机，registed_time）VALUES（？？？？，NOW（））” ;    
73.             
74.         Object []的paramValues​​ = {acc.getPassword acc.getLoginname（），（），     
75.                 acc.getEmail（），acc.getCellphone（）};    
76.             
77.         jdbcTemplate.update（SQL，paramValues）;    
78.     }    
79.     
80.     
81.     公共 无效 删除（帐户ACC）{    
82.         字符串的sql =  “DELETE WHERE ID =？”帐户;    
83.         paramValues​​对象[] = {acc.getId（）};    
84.             
85.         jdbcTemplate.update（SQL，paramValues）;    
86.     }    
87.         
88.     公共 无效 更新（帐户ACC）{    
89.         弦乐的sql =  “UPDATE帐户SET LOGINNAME的=？，密码=？，电子邮件=？”    
90.             + “手机=？WHERE ID =？” ;    
91.         
92.         Object []的paramValues​​ = {acc.getPassword acc.getLoginname（），（），     
93.             acc.getCellphone acc.getEmail（），（），acc.getId（）};    
94.         
95.         jdbcTemplate.update（SQL，paramValues）;    
96.     }    
97.         
98.     @ SuppressWarnings （“未选中” ）    
99.     公共 列表<Account>的findAll（）{    
100.         字符串的sql =  “SELECT * FROM帐户” ;    
101.         返回 jdbcTemplate.query（SQL，：  新 AccountRowMapper（））;    
102.     }    
103.     
104.     公共 帐户findById（长ID）{    
105.         字符串的sql =  “SELECT * FROM帐户WHERE ID =？” ;    
106.         Object []的paramValues​​ = {ID};    
107.         返回 （帐户）的JdbcTemplate。    
108.                     queryForObject（SQL，paramValues，：  新 AccountRowMapper（））;    
109.     }    
110.     
111.     / /把结果集封装成帐户对象的包装类    
112.     私人 静态 最终 类 AccountRowMapper  实现 RowMapper的{    
113.         公共的 对象mapRow（结果集RS，  INT  ROWNUM）  抛出 的SQLException {    
114.             帐户ACC =  新 帐户（）;    
115.             acc.setId（rs.getLong（“ID” ））;    
116.             acc.setLoginname（rs.getString（登录名“ ））;    
117.             acc.setPassword（rs.getString（ “ 密码” ））;    
118.             acc.setEmail（rs.getString（ “ 电子邮件” ））;    
119.             acc.setCellphone（rs.getString（ “ 手机” ））;    
120.                 
121.             时间戳温度= rs.getTimestamp（“registed_time” ）;    
122.             （温度！=  0 ）{    
123.                 （新 acc.setRegistedTime的 日期（temp.getTime（）））;    
124.             }    
125.             返回 ACC;    
126.         }    
127.     }    
128. }    
129.     
130.   3.2 ，使用NamedParameterJdbcTemplate类类  
131.    
132. Java的代码    
133. 包 com.zxf.dao;    
134.     
135. 进口 的java.sql.ResultSet;    
136. 进口 的java.sql.SQLException;    
137. 导入 的java.sql.Timestamp;    
138. 导入 java.util.Date的;    
139. 导入 的java.util.HashMap;    
140. 进口 的java.util.List;    
141. 导入 的java.util.Map;    
142.     
143. 导入 了javax.sql.DataSource;    
144.     
145. 导入 org.springframework.jdbc.core.RowMapper;    
146. 导入 org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;    
147. 导入 org.springframework.jdbc.core.namedparam.MapSqlParameterSource;    
148. 进口 org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;    
149. 导入 org.springframework.jdbc.core.namedparam.SqlParameterSource;    
150.     
151. 导入 com.zxf.domain.Account;    
152.     
153. / **  
154.  *使用NamedParameterJdbcTemplate类来实现AccountDao接口  
155.  * /    
156. 公共 类实现 AccountDao的{    
157.     / /带命名参数功能的JDBC模板类实例    
158.     私人 NamedParameterJdbcTemplate类的JdbcTemplate;    
159.         
160.     公共 无效 的setDataSource（DataSource的数据源）{    
161.         的JdbcTemplate =  新 NamedParameterJdbcTemplate类（数据源）;    
162.     }    
163.     
164.     公共 无效 创建（帐户ACC）{    
165.         弦乐的sql =  “INSERT INTO帐户（登录名，密码，电子邮件，”    
166.                 +  “手机，registed_time）”    
167.                 +  “VALUES（登录名，密码，电子邮件，手机，NOW（））” ;    
168.         / /使用一个Bean的对象的属性值作为命名参数的值    
169.         SqlParameterSource的namedParameters =     
170.                 新 组件属性SQL参数源（ACC）;    
171.     
172.         这jdbcTemplate.update（SQL，namedParameters）;    
173.     }    
174.     
175.     
176.     公共 无效 删除（帐户ACC）{    
177.         字符串的sql =  “DELETE FROM帐户WHERE ID =：ID” ;    
178.         / /使用指定的值来代替命名参数    
179.         SqlParameterSource的namedParameters =     
180.                 新 MapSqlParameterSource（“ID” ，acc.getId（））;    
181.             
182.         这jdbcTemplate.update（SQL，namedParameters）;    
183.     }    
184.         
185.     公共 无效 更新（帐户ACC）{    
186.         字符串的sql =  “ ​​更新账户的SET LOGINNAME =：登录名。”    
187.                 +  “密码：密码，电子邮件：电子邮件，”    
188.                 +  手机=手机WHERE ID =：ID“ ;    
189.         / /使用地图对象中的键/值对来代替多个命名参数的实际值    
190.         地图<String, namedParameters对象> =  新 的HashMap <String,对象>（）;    
191.         namedParameters.put（ “ 登录名” ，acc.getLoginname（））;    
192.         namedParameters.put（ “ 密码” ，acc.getPassword（））;    
193.         namedParameters.put（ “ 电子邮件” ，acc.getEmail（））;    
194.         namedParameters.put（ “ 手机” ，acc.getCellphone（））;    
195.         namedParameters.put（“ID” ，acc.getId（））;    
196.         
197.         这jdbcTemplate.update（SQL，namedParameters）;    
198.     }    
199.         
200.     @ SuppressWarnings （“未选中” ）    
201.     公共 列表<Account>的findAll（）{    
202.         字符串的sql =  “SELECT * FROM帐户” ;    
203.         / /通过getJdbcOperations（）来访问只有在使用JdbcTemplate中拥有的功能    
204.         返回 的JdbcTemplate    
205.                    getJdbcOperations（）    
206.                    查询（SQL，：  新 AccountRowMapper（））;    
207.     }    
208.     
209.     公共 帐户findById（长ID）{    
210.         字符串的sql =  “SELECT * FROM帐户WHERE ID =？” ;    
211.         / /使用指定的值来代替命名参数    
212.         SqlParameterSource的namedParameters =     
213.                 新 MapSqlParameterSource（ “ 身份证” ，身份证）;    
214.         返回 （帐户）的JdbcTemplate    
215.                     查询（SQL，namedParameters  新 AccountRowMapper（））;    
216.     }    
217.     
218.     / /把结果集封装成帐户对象的包装类    
219.     私人 静态 最终 类 AccountRowMapper  实现 RowMapper的{    
220.         公共的 对象mapRow（结果集RS，  INT  ROWNUM）  抛出 的SQLException {    
221.             帐户ACC =  新 帐户（）;    
222.             acc.setId（rs.getLong（“ID” ））;    
223.             acc.setLoginname（rs.getString（登录名“ ））;    
224.             acc.setPassword（rs.getString（ “ 密码” ））;    
225.             acc.setEmail（rs.getString（ “ 电子邮件” ））;    
226.             acc.setCellphone（rs.getString（ “ 手机” ））;    
227.             时间戳温度= rs.getTimestamp（“registed_time” ）;    
228.             （温度！=  0 ）{    
229.                 （新 acc.setRegistedTime的 日期（temp.getTime（）））;    
230.             }    
231.             返回 ACC;    
232.         }    
233.     }    
234. }    
235.     
236.   3.3 ，使用SimpleJdbcTemplate类类  
237. Java的代码    
238. 包 com.zxf.dao;    
239.     
240. 进口 的java.sql.ResultSet;    
241. 进口 的java.sql.SQLException;    
242. 导入 的java.sql.Timestamp;    
243. 导入 java.util.Date的;    
244. 进口 的java.util.List;    
245.     
246. 导入 了javax.sql.DataSource;    
247.     
248. 导入 org.springframework.jdbc.core.simple.ParameterizedRowMapper;    
249. 进口 org.springframework.jdbc.core.simple.SimpleJdbcTemplate;    
250.     
251. 导入 com.zxf.domain.Account;    
252.     
253. / **  
254.  *使用SimplateJdbcTemplate来实现AccountDao接口  
255.  * /    
256. 公共 类实现 AccountDao的{    
257.     私人 SimpleJdbcTemplate类的JdbcTemplate;    
258.         
259.     公共 无效 的setDataSource（DataSource的数据源）{    
260.         的JdbcTemplate =  新 SimpleJdbcTemplate类（数据源）;    
261.     }    
262.     
263.     公共 无效 创建（帐户ACC）{    
264.         弦乐的sql =  “INSERT INTO帐户（登录名，密码，电子邮件，”    
265.                 + “手机，registed_time）VALUES（？？？？，NOW（））” ;    
266.             
267.         这jdbcTemplate.update（SQL acc.getLoginname（）    
268.                                       acc.getPassword（），     
269.                                       acc.getEmail（），    
270.                                       acc.getCellphone（））;    
271.     }    
272.     
273.     公共 无效 删除（帐户ACC）{    
274.         字符串的sql =  “DELETE WHERE ID =？”帐户;    
275.             
276.         jdbcTemplate.update（SQL，acc.getId（））;    
277.     }    
278.         
279.     公共 无效 更新（帐户ACC）{    
280.         弦乐的sql =  “UPDATE帐户SET LOGINNAME的=？，密码=？，电子邮件=？”    
281.             + “手机=？WHERE ID =？” ;    
282.         
283.         这jdbcTemplate.update（SQL acc.getLoginname（）     
284.                                       acc.getPassword（），     
285.                                       acc.getEmail（），    
286.                                       acc.getCellphone（），     
287.                                       acc.getId（））;    
288.     }    
289.         
290.     公共 列表<Account>的findAll（）{    
291.         字符串的sql =  “SELECT * FROM帐户” ;    
292.         返回 jdbcTemplate.query（SQL，：  新 AccountRowMapper（））;    
293.     }    
294.     
295.     公共 帐户findById（长ID）{    
296.         字符串的sql =  “SELECT * FROM帐户WHERE ID =？” ;    
297.         返回 jdbcTemplate.queryForObject（SQL，  新 AccountRowMapper（），身份证）;    
298.     }    
299.     
300.     / /把结果集封装成帐户对象的包装类    
301.     私人 静态 最终 类 AccountRowMapper    
302.             实现 ParameterizedRowMapper的<Account> {    
303.         公众的 帐户方法mapRow（结果集RS，  INT  ROWNUM）     
304.                 抛出 SQLException异常{    
305.             帐户ACC =  新 帐户（）;    
306.             acc.setId（rs.getLong（“ID” ））;    
307.             acc.setLoginname（rs.getString（登录名“ ））;    
308.             acc.setPassword（rs.getString（ “ 密码” ））;    
309.             acc.setEmail（rs.getString（ “ 电子邮件” ））;    
310.             acc.setCellphone（rs.getString（ “ 手机” ））;    
311.             时间戳温度= rs.getTimestamp（“registed_time” ）;    
312.             （温度！=  0 ）{    
313.                 （新 acc.setRegistedTime的 日期（temp.getTime（）））;    
314.             }    
315.             返回 ACC;    
316.         }    
317.     }    
318. }    
319.     
320.     
321. 包 com.zxf.service;    
322.     
323. 进口 的java.util.List;    
324.     
325. 导入 com.zxf.dao.AccountDao;    
326. 导入 com.zxf.domain.Account;    
327.     
328. / **  
329.  *帐户业务逻辑类  
330.  * @作者z_xiaofei168  
331.  * /    
332. 公共 类 的AccountService {    
333.     私人 AccountDao accountDao;    
334.         
335.     / / setter方法​​注入    
336.     公共的 无效 setAccountDao（AccountDao accountDao）{    
337.         accountDao = accountDao;    
338.     }    
339.     
340.     公共 无效 创建（帐户ACC）{    
341.         accountDao.create（ACC）;    
342.     }    
343.     
344.     公共 无效 删除（帐户ACC）{    
345.         accountDao.delete（ACC）;    
346.     }    
347.     
348.     公共 无效 更新（帐户ACC）{    
349.         accountDao.update（ACC）;    
350.     }    
351.     
352.     公共 帐户findById（长ID）{    
353.         返回 accountDao.findById（ID）;    
354.     }    
355.     
356.     公共 列表<Account>的findAll（）{    
357.         返回 accountDao.findAll（）;    
358.     }    
359. }