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

左手的ㄟ右手 2021-09-30 07:02 330阅读 0赞

Java的代码   ![收藏代码][icon_star.png]

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. \}

[icon_star.png]: /images/20210825/93394f6c06a841b7b8ad5c7bd7d7de09.png