前言
今天介紹的是關(guān)于spring的數(shù)據(jù)庫連接以及jdbc模板的相關(guān)api方法，雖然在學(xué)習(xí)了hibernate之后，會知道實現(xiàn)數(shù)據(jù)庫連接一般都是使用hibernate等持久化框架來實現(xiàn)的。但是，很多時候一些涉及到事務(wù)的東西使用這些框架并不能夠?qū)崿F(xiàn)，所以我們還需要結(jié)合spring來實現(xiàn)相關(guān)的需要。
一、創(chuàng)建工程、導(dǎo)包
要想使用spring的jdbc模板前，還需要導(dǎo)入相關(guān)的jar包：
二、進行相關(guān)的bean的創(chuàng)建以及工具類的編寫
2.1在數(shù)據(jù)庫中創(chuàng)建了兩張表，使用spring的jdbctemplate中的api方法對這兩張表進行操作
|
1
2
3
4
5
6
|
create table `t_dept` ( `deptid` int(11) not null, `deptname` varchar(20) character set utf8 default null, `remark` varchar(30) character set utf8 default null, primary key (`deptid`)) engine=innodb default charset=gbk collate=gbk_bin; |
|
1
2
3
4
5
6
7
|
create table `user` ( `user_id` int(11) not null, `user_name` varchar(11) default null, `user_password` varchar(11) default null, `user_address` varchar(25) default null, primary key (`user_id`)) engine=innodb default charset=utf8; |
2.2創(chuàng)建實體bean
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
package com.bean;/** * 創(chuàng)建t_dept表對應(yīng)的表 * @author 夜孤寒 * @version 1.1.1 * */public class deptbean { private int deptid; private string deptname; private string remark; public deptbean() { super(); } public deptbean(int deptid, string deptname, string remark) { super(); this.deptid = deptid; this.deptname = deptname; this.remark = remark; } public int getdeptid() { return deptid; } public void setdeptid(int deptid) { this.deptid = deptid; } public string getdeptname() { return deptname; } public void setdeptname(string deptname) { this.deptname = deptname; } public string getremark() { return remark; } public void setremark(string remark) { this.remark = remark; }} |
2.3創(chuàng)建spring的工具類——springutil.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package com.util;import org.springframework.context.applicationcontext;import org.springframework.context.support.classpathxmlapplicationcontext;/** * 讀取配置文件的工具類，實現(xiàn)了類似工廠模式的方式 * * @author 夜孤寒 * @version 1.1.1 */public class springutil { // 定義屬性 private static applicationcontext context; // 讀取配置文件 static { context = new classpathxmlapplicationcontext("spring.xml"); } // 定義一個方法，判斷bean是否為空，如果不為空的，獲取這個bean public static object getbean(string beanname) { // 定義一個空對象 object obj = null; // 如果beanname不為空的話，那么根據(jù)這個beanname獲取到bean對象，賦值給obj并返回 if (beanname != null && !beanname.equals("")) { obj = context.getbean(beanname); } return obj; }} |
2.4進行配置文件的相關(guān)配置——spring.xml文件的配置
因為要介紹的api方法可能比較多，所以一次性將寫過的xml全部粘貼了，讀者可以根據(jù)對應(yīng)的配置，去對應(yīng)到相應(yīng)的類中：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
<?xml version="1.0" encoding="utf-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> <!-- 方式一： 配置使用ioc：直接引用 --> <!-- 首先需要引入一個驅(qū)動，然後到這驅(qū)動類下面，去查看他的源代碼，一下是mysql需要注入的對象 --> <bean name="datasource" class="org.springframework.jdbc.datasource.drivermanagerdatasource"> <property name="driverclassname" value="com.mysql.jdbc.driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/spring_jdbc_test"></property> <property name="username" value="root"></property> <property name="password" value="root"></property> </bean> <!-- 使用di注入的構(gòu)造方法注入的方式來注入，并且查詢我們的數(shù)據(jù)庫中的數(shù)據(jù)。 注意這里我們還需要一我們之前的datasource作為引用 --> <bean name="testmain_2" class="com.jdbc.testmain_2"> <property name="datasource" ref="datasource"></property> </bean> <!-- 使用我們的模板來獲取我們的數(shù)據(jù)庫中的數(shù)據(jù) --> <bean name="testmain_3" class="com.jdbc.testmain_3"> <!-- 首先我們還是需要引入我們的數(shù)據(jù)庫資源，也就是我們之前已經(jīng)配置過的datasource --> <property name="datasource" ref="datasource"></property> </bean> <!-- 方式四 --> <!-- 配置我們模板，然后在類就只要將這個模板用構(gòu)造方法的方式注入就可以了 --> <bean name="jdbctemplate" class="org.springframework.jdbc.core.jdbctemplate"> <property name="datasource" ref="datasource"></property> </bean> <!-- 配置我們的testmain_4，然后引用我們上面配置的模板 --> <bean name="testmain_4" class="com.jdbc.testmain_4"> <property name="jdbctemplate" ref="jdbctemplate"></property> </bean> <!-- 方式五： 直接繼承jdbcdaosupport這個父類，然后用里面的方法獲取到模板， 從而獲取到數(shù)據(jù)。 備注：這個是最完美的獲取數(shù)據(jù)的方式，以后一般都是使用這種方式！！！ --> <bean name="testmain_5" class="com.jdbc.testmain_5"> <property name="datasource" ref="datasource"></property> </bean> <!-- 使用spring配置的方式操作我們的ddl語句 --> <bean name="testmain_6" class="com.jdbc.testmain_6"> <property name="datasource" ref="datasource"></property> </bean> <!-- 使用spring配置的方式操作我們的dml語句 --> <bean name="testmain_7" class="com.jdbc.testmain_7"> <property name="datasource" ref="datasource"></property> </bean> <!-- 使用jdbctemplate模板中的命名參數(shù)來操作我們的dml語句 --> <bean name="testmain_8" class="com.jdbc.testmain_8"> <property name="datasource" ref="datasource"></property> </bean> <!-- 使用jdbctemplate模板對于查詢語句的封裝 --> <bean name="testmain_9" class="com.jdbc.testmain_9"> <property name="datasource" ref="datasource"></property> </bean> </beans> |
2.5介紹spring對于jdbc的模板的支持
（1）數(shù)據(jù)庫的連接
對應(yīng)xml中的配置為：
|
1
2
3
4
5
6
7
8
9
10
|
<!-- 方式一： 配置使用ioc：直接引用 --> <!-- 首先需要引入一個驅(qū)動，然後到這驅(qū)動類下面，去查看他的源代碼，一下是mysql需要注入的對象 --> <bean name="datasource" class="org.springframework.jdbc.datasource.drivermanagerdatasource"> <property name="driverclassname" value="com.mysql.jdbc.driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/spring_jdbc_test"></property> <property name="username" value="root"></property> <property name="password" value="root"></property> </bean> |
對應(yīng)的測試類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package com.jdbc;import java.sql.connection;import java.sql.sqlexception;import javax.sql.datasource;import com.util.springutil;/** * 連接數(shù)據(jù)庫的測試類 * @author 夜孤寒 * @version 1.1.1 * */public class testmain_1 { public static void main(string[] args) { /* * 本來需要用applicationcontext獲取到我們的bean對象， * 這里使用工廠類的方法將之獨立出來，具體使用見springutil.java */ datasource datasource=(datasource)springutil.getbean("datasource"); connection conn=null; try{ conn=datasource.getconnection(); }catch(sqlexception e){ e.printstacktrace(); } system.out.println(conn);//測試是否能夠輸出連接 }} |
測試結(jié)果：
由此可見測試成功可以獲取到相應(yīng)的數(shù)據(jù)庫連接。
（2）測試從創(chuàng)建的user表中查詢出相應(yīng)的數(shù)據(jù)
對應(yīng)xml配置為：
|
1
2
3
4
5
6
|
<!-- 使用di注入的構(gòu)造方法注入的方式來注入，并且查詢我們的數(shù)據(jù)庫中的數(shù)據(jù)。 注意這里我們還需要一我們之前的datasource作為引用 --> <bean name="testmain_2" class="com.jdbc.testmain_2"> <property name="datasource" ref="datasource"></property> </bean> |
對應(yīng)的測試類為：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
package com.jdbc;import java.sql.connection;import java.sql.resultset;import javax.sql.datasource;import com.mysql.jdbc.statement;import com.util.springutil;/** * 從創(chuàng)建的user表中查詢相關(guān)的數(shù)據(jù) * * @author 夜孤寒 * @version 1.1.1 */public class testmain_2 { // 使用構(gòu)造方法注入 public datasource datasource; public void setdatasource(datasource datasource) { this.datasource = datasource; } /** * 從user表中獲取所有數(shù)據(jù) */ public void list() { /* * 在我們的main方法中獲取到我們的datasource， 然后就能夠獲取連接，并且獲取到數(shù)據(jù)庫中的數(shù)據(jù)。 */ connection conn = null; statement stmt = null; resultset rs = null; string sql = "select * from user"; try { conn = datasource.getconnection(); stmt = (statement) conn.createstatement(); rs = stmt.executequery(sql); while (rs.next()) { system.out.println(rs.getint("user_id") + "\t" + rs.getstring("user_name") + "\t" + rs.getstring("user_password") + "\t" + rs.getstring("user_address")); } } catch (exception e) { e.printstacktrace(); } finally { /* * 需要自己關(guān)閉資源 */ } } public static void main(string[] args) { // 獲取到我們bean對象 testmain_2 testmain_2 = (testmain_2) springutil.getbean("testmain_2"); // 調(diào)用我們的list方法 testmain_2.list(); }} |
測試結(jié)果：
備注：本測試類，使用的是常用的純粹的jdbc獲取數(shù)據(jù)的方式。
（3）使用jdbctemplate這個類來獲取到后端的數(shù)據(jù)
對應(yīng)的xml文件的配置為：
|
1
2
3
4
5
|
<!-- 使用我們的模板來獲取我們的數(shù)據(jù)庫中的數(shù)據(jù) --> <bean name="testmain_3" class="com.jdbc.testmain_3"> <!-- 首先我們還是需要引入我們的數(shù)據(jù)庫資源，也就是我們之前已經(jīng)配置過的datasource --> <property name="datasource" ref="datasource"></property> </bean> |
對應(yīng)的測試類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
package com.jdbc;import java.util.list;import java.util.map;import javax.sql.datasource;import org.springframework.jdbc.core.jdbctemplate;import com.util.springutil;/** * 使用jdbctemplate這個類來獲取后臺數(shù)據(jù) * @author 夜孤寒 * */public class testmain_3 { // 使用構(gòu)造方法注入 public datasource datasource; public void setdatasource(datasource datasource) { this.datasource = datasource; } public void list() { /* * 使用我們jdbctemplate模板來獲取我們的數(shù)據(jù) */ jdbctemplate jdbctemplate=new jdbctemplate(this.datasource); string sql="select * from user"; list<map<string, object>>userlist=jdbctemplate.queryforlist(sql); for(map<string, object>rowmap:userlist){ system.out.println(rowmap); } } public static void main(string[] args) { //獲取到我們bean對象 testmain_3 testmain_3=(testmain_3)springutil.getbean("testmain_3"); //調(diào)用我們的list方法 testmain_3.list(); }} |
測試的結(jié)果：
這種方式的話每次我們都要創(chuàng)建一個jdbctemplate實例，這樣子比較復(fù)雜，所以考慮能不能將這個類讓spring自己創(chuàng)建，然后在bean配置文件中引用數(shù)據(jù)源來達到目的。這就是下面要介紹的第四種方式。
（4）在配置文件中配置我們的模板類，讓spring生成需要的bean
對應(yīng)的xml配置文件為：
|
1
2
3
4
5
6
7
8
9
|
<!-- 方式四 --> <!-- 配置我們模板，然后在類就只要將這個模板用構(gòu)造方法的方式注入就可以了 --> <bean name="jdbctemplate" class="org.springframework.jdbc.core.jdbctemplate"> <property name="datasource" ref="datasource"></property> </bean> <!-- 配置我們的testmain_4，然后引用我們上面配置的模板 --> <bean name="testmain_4" class="com.jdbc.testmain_4"> <property name="jdbctemplate" ref="jdbctemplate"></property> </bean> |
對應(yīng)的測試類為：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
package com.jdbc;import java.util.list;import java.util.map;import org.springframework.jdbc.core.jdbctemplate;import com.util.springutil;/** * 在配置文件中配置模板，讓spring去創(chuàng)建模板類 * * @author 夜孤寒 * @version 1.1.1 */public class testmain_4 { // 使用構(gòu)造方法的方式注入template public jdbctemplate jdbctemplate; public void setjdbctemplate(jdbctemplate jdbctemplate) { this.jdbctemplate = jdbctemplate; } public void list() { /* * 使用我們ioc注入模板，然后引用這個使用ioc注入的模板， 最后取出我們的數(shù)據(jù) */ string sql = "select user_name from user"; list<map<string, object>> userlist = this.jdbctemplate.queryforlist(sql); for (map<string, object> rowmap : userlist) { system.out.println(rowmap); } } public static void main(string[] args) { // 獲取到我們bean對象 testmain_4 testmain_4 = (testmain_4) springutil.getbean("testmain_4"); // 調(diào)用我們的list方法 testmain_4.list(); }} |
測試結(jié)果：
這種方式仍舊需要在xml中配置，而在spring中還有一種更加方便的方式就是直接繼承jdbcdaosupport這個類，這種方式是最簡單的，也是最常用的方式。下面筆者就簡單介紹一下這種方式的使用。
（5）繼承jdbcdaosupport類來獲取數(shù)據(jù)庫中的數(shù)據(jù)
對應(yīng)的xml文件中的配置為：
|
1
2
3
4
5
6
7
8
|
<!-- 方式五： 直接繼承jdbcdaosupport這個父類，然后用里面的方法獲取到模板， 從而獲取到數(shù)據(jù)。 備注：這個是最完美的獲取數(shù)據(jù)的方式，以后一般都是使用這種方式！！！ --> <bean name="testmain_5" class="com.jdbc.testmain_5"> <property name="datasource" ref="datasource"></property> </bean> |
對應(yīng)的測試類為：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
package com.jdbc;import java.util.list;import java.util.map;import org.springframework.jdbc.core.support.jdbcdaosupport;import com.util.springutil;/** * 繼承jdbcdaosupport來獲取模板，再通過模板來獲取數(shù)據(jù) * @author 夜孤寒 * @version 1.1.1 * */public class testmain_5 extends jdbcdaosupport { /* * 不使用di注入的方式，直接繼承一個上述的父類， 觀察上述的父類，發(fā)現(xiàn)在這個父類里面已經(jīng)實現(xiàn)了類似注入jdbctemplate模板。 */ public void list() { string sql = "select * from user"; list<map<string, object>> userlist = this.getjdbctemplate().queryforlist(sql); for (map<string, object> rowmap : userlist) { system.out.println(rowmap); } } public static void main(string[] args) { // 獲取到我們bean對象 testmain_5 testmain_5 = (testmain_5) springutil.getbean("testmain_5"); // 調(diào)用我們的list方法 testmain_5.list(); }} |
測試結(jié)果為：
（6）使用spring注入的方式來操作ddl語句
對應(yīng)xml文件中的配置為：
|
1
2
3
4
|
<!-- 使用spring配置的方式操作我們的ddl語句 --> <bean name="testmain_6" class="com.jdbc.testmain_6"> <property name="datasource" ref="datasource"></property> </bean> |
對應(yīng)的測試類為：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
package com.jdbc;import org.springframework.jdbc.core.support.jdbcdaosupport;import com.util.springutil;/** * 使用spring注入的方式進行ddl操作 * * @author 夜孤寒 * @version 1.1.1 * */public class testmain_6 extends jdbcdaosupport { /* * 創(chuàng)建表 */ public void create() { stringbuffer createsql = new stringbuffer(); createsql.append("create table t_temp_xx(id int,testname varchar(30))"); this.getjdbctemplate().execute(createsql.tostring()); } /* * 修改表，這里面可以添加或者刪除某一個屬性列 */ public void alter() { stringbuffer altersql = new stringbuffer(); altersql.append("alter table t_temp_xx add testpassword varchar(30)"); this.getjdbctemplate().execute(altersql.tostring()); } /* * 刪除一張表 */ public void drop() { stringbuffer dropsql = new stringbuffer(); dropsql.append("drop table t_temp_xx"); this.getjdbctemplate().execute(dropsql.tostring()); } /* * 測試方法 */ public static void main(string[] args) { // 獲取到我們bean對象 testmain_6 testmain_6 = (testmain_6) springutil.getbean("testmain_6"); // 調(diào)用我們的方法，一次調(diào)用一個方法，打開數(shù)據(jù)庫觀察數(shù)據(jù)庫是不是已經(jīng)變化了 // testmain_6.create(); // testmain_6.alter(); testmain_6.drop(); }} |
經(jīng)過測試可以進行ddl操作。
（7）使用spring注入的方式進行dml操作
對應(yīng)xml文件中的配置：
|
1
2
3
4
|
<!-- 使用spring配置的方式操作我們的dml語句 --><bean name="testmain_7" class="com.jdbc.testmain_7"> <property name="datasource" ref="datasource"></property></bean> |
對應(yīng)測試類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
package com.jdbc;import java.sql.preparedstatement;import java.sql.sqlexception;import org.springframework.jdbc.core.preparedstatementsetter;import org.springframework.jdbc.core.support.jdbcdaosupport;import com.util.springutil;/** * 使用spring配置的方式操作我們的dml語句 * * @author 夜孤寒 * @version 1.1.1 */public class testmain_7 extends jdbcdaosupport { /* * statement的寫法 */ public void insert() { int deptid = 1; string deptname = "zhangsan"; string remark = "zhangsanzhenshuai"; stringbuffer insertsql = new stringbuffer(); insertsql.append("insert into t_dept("); insertsql.append("deptid,deptname"); insertsql.append(",remark"); insertsql.append(") values("); insertsql.append("" + deptid + ","); insertsql.append("'" + deptname + "',"); insertsql.append("'" + remark + "'"); insertsql.append(""); insertsql.append(")"); int rowcount = this.getjdbctemplate().update(insertsql.tostring()); system.out.println("rowcount影響的行數(shù)= " + rowcount); } /* * preparestatement的寫法 */ public void update() { stringbuffer updatesql = new stringbuffer(); updatesql.append("update t_dept set "); updatesql.append("deptname = ?,"); updatesql.append("remark = ?"); updatesql.append(" where deptid=?"); int rowcount = this.getjdbctemplate().update(updatesql.tostring(), new preparedstatementsetter() { @override public void setvalues(preparedstatement ps) throws sqlexception { ps.setstring(1, "lisi"); ps.setstring(2, "lisizhenshuai"); ps.setint(3, 1); } }); system.out.println("rowcount影響的行數(shù)=" + rowcount); } /* * preparestatement的寫法 */ public void delete() { stringbuffer deletesql = new stringbuffer(); deletesql.append("delete from t_dept"); deletesql.append(" where deptid=?"); /* * 關(guān)于對象數(shù)組的使用：對象數(shù)組的第一個元素對應(yīng)的是sql語句中的第一個參數(shù)問號 */ object[] obj = { 1 }; int rowcount = this.getjdbctemplate().update(deletesql.tostring(), obj); system.out.println("rowcount影響的行數(shù)=" + rowcount); } public static void main(string[] args) { // 獲取到bean對象 testmain_7 testmain_7 = (testmain_7) springutil.getbean("testmain_7"); // 測試方法 // testmain_7.insert(); // testmain_7.update(); testmain_7.delete(); }} |
經(jīng)測試，可以實現(xiàn)dml操作中的增刪改查。
（8）使用jdbctemplate模板中的命名參數(shù)來操作我們的dml語句
對應(yīng)xml中的配置為：
|
1
2
3
4
|
<!-- 使用jdbctemplate模板中的命名參數(shù)來操作我們的dml語句 --><bean name="testmain_8" class="com.jdbc.testmain_8"> <property name="datasource" ref="datasource"></property> </bean> |
對應(yīng)的測試類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
package com.jdbc;import java.util.hashmap;import java.util.map;import org.springframework.jdbc.core.namedparam.beanpropertysqlparametersource;import org.springframework.jdbc.core.namedparam.namedparameterjdbcdaosupport;import org.springframework.jdbc.core.namedparam.namedparameterjdbctemplate;import com.bean.deptbean;import com.util.springutil;/** * 使用jdbctemplate模板中的命名參數(shù)來操作我們的dml語句 * * @author 夜孤寒 * @version 1.1.1 */public class testmain_8 extends namedparameterjdbcdaosupport { /* * statement的寫法 */ public void insert(boolean flag_1, boolean flag_2) { int deptid = 1; string deptname = "zhangsan"; string remark = "zhangsanzhenshuai"; stringbuffer insertsql = new stringbuffer(); insertsql.append("insert into t_dept(deptid"); if (flag_1) { insertsql.append(",deptname"); } if (flag_2 == true) { insertsql.append(",remark"); } insertsql.append(") values("); insertsql.append(":deptid"); if (flag_1 == true) { insertsql.append(",:deptname"); } if (flag_2 == true) { insertsql.append(",:remark"); } insertsql.append(")"); // 將數(shù)據(jù)放進我們的map中 備注：map中key的名稱==命名參數(shù)的名稱 map<string, object> parammap = new hashmap<string, object>(); parammap.put("deptid", deptid); parammap.put("deptname", deptname); parammap.put("remark", remark); int rowcount = this.getnamedparameterjdbctemplate().update(insertsql.tostring(), parammap); system.out.println("rowcount影響的行數(shù)= " + rowcount); } /* * preparestatement的寫法 */ public void update() { stringbuffer updatesql = new stringbuffer(); updatesql.append("update t_dept set"); updatesql.append(" deptname = :deptname,"); updatesql.append(" remark = :remark"); updatesql.append(" where deptid = :deptid"); updatesql.append(""); // 獲取到模板 namedparameterjdbctemplate template = this.getnamedparameterjdbctemplate(); // 將數(shù)據(jù)放置到bean里面去 deptbean deptbean = new deptbean(); deptbean.setdeptid(1); deptbean.setdeptname("lisi"); deptbean.setremark("lisizhenshuai"); // 使用一個bean工廠的方法將預(yù)處理我們的bean beanpropertysqlparametersource paramsource = new beanpropertysqlparametersource(deptbean); // 調(diào)用模板方法更新數(shù)據(jù) int rowcount = template.update(updatesql.tostring(), paramsource); // 輸出影響的行數(shù) system.out.println("影響的行數(shù)rowcount=" + rowcount); } public static void main(string[] args) { // 獲取到bean對象 testmain_8 testmain_8 = (testmain_8) springutil.getbean("testmain_8"); // 測試方法 // testmain_8.insert(true,true);//由這個參數(shù)來控制是不是插入某一個屬性列的數(shù)據(jù) testmain_8.update(); }} |
（9）jdbctemplate模板對于查詢語句的封裝
對應(yīng)的xml文件的配置：
|
1
2
3
4
|
<!-- 使用jdbctemplate模板對于查詢語句的封裝 --><bean name="testmain_9" class="com.jdbc.testmain_9"> <property name="datasource" ref="datasource"></property></bean> |
對應(yīng)的測試類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
package com.jdbc;import java.sql.preparedstatement;import java.sql.resultset;import java.sql.sqlexception;import java.util.list;import java.util.map;import java.util.vector;import org.springframework.jdbc.core.beanpropertyrowmapper;import org.springframework.jdbc.core.columnmaprowmapper;import org.springframework.jdbc.core.preparedstatementsetter;import org.springframework.jdbc.core.rowmapper;import org.springframework.jdbc.core.namedparam.beanpropertysqlparametersource;import org.springframework.jdbc.core.namedparam.namedparameterjdbctemplate;import org.springframework.jdbc.core.support.jdbcdaosupport;import com.bean.deptbean;import com.util.springutil;/** * jdbctemplate模板對于查詢語句的封裝測試類 * @author 夜孤寒 * @version 1.1.1 */public class testmain_9 extends jdbcdaosupport{ /* * 最簡單的一個查詢 */ public void one(){ system.out.println("=============================="); system.out.println("1：返回所有的對象"); string sql="select * from t_dept order by deptid asc"; list<map<string, object>>deptlist=this.getjdbctemplate().queryforlist(sql); for(map<string, object>rowmap:deptlist){ system.out.println(rowmap); } system.out.println("=============================="); system.out.println("2：返回一條對象"); /* * 返回一條對象，將返回的對象使用map的方式來接收 */ sql="select * from t_dept where deptid=1"; map<string, object>rowmap=this.getjdbctemplate().queryformap(sql); if(rowmap!=null){ system.out.println(rowmap); } /* * 使用queryforobject方法來接收一個對象: * 1、如果方法的第二個參數(shù)是class類型的話，表示sql只能返回一行一列。相當(dāng)于rowmapper中的singlecolumnrowmapper； * 2、如果方法的第二個參數(shù)是rowmapper類型的話，表示sql語句只能返回一行多列。 * 一行多列，默認是返回queryformap，但是spring允許可以對返回的行數(shù)據(jù)進行自定義的映射 */ /* * 方式一：返回的class類型 */ sql="select count(1) from t_dept where deptid=1";//什么意思？ integer dept_count=this.getjdbctemplate().queryforobject(sql, integer.class); system.out.println("dept_count="+dept_count); /* * 方式二：返回的是rowmapper的類型 */ sql="select * from t_dept where deptid=1"; beanpropertyrowmapper<deptbean>rowmapper=new beanpropertyrowmapper<deptbean>(deptbean.class); //需要將返回的數(shù)據(jù)轉(zhuǎn)換成bean對象 deptbean deptbean=this.getjdbctemplate().queryforobject(sql, rowmapper); system.out.println(deptbean.getdeptid()+"\t"+deptbean.getdeptname()+"\t"+deptbean.getremark()); system.out.println("=============================="); } /* * 復(fù)雜的查詢queryforxx： * 這個是模板封裝好的查詢方法 */ @suppresswarnings({ "unchecked", "rawtypes" }) public void two(){ //1、處理有預(yù)編譯的語句 string sql="select * from t_dept where deptname like ? order by deptid asc"; list<map<string, object>>deptlist=this.getjdbctemplate().query(sql, new preparedstatementsetter() { @override public void setvalues(preparedstatement ps) throws sqlexception { //查詢帶有"l"這個字符的所有對象 ps.setstring(1, "%l%"); } },new columnmaprowmapper());//這里代表返回的是一個什么類型 system.out.println(deptlist); //2、處理帶有預(yù)編譯的語句，并且返回的是一個javabean list<deptbean>deptlist_2 = this.getjdbctemplate().query( sql, new preparedstatementsetter() { @override public void setvalues(preparedstatement ps) throws sqlexception { ps.setstring(1, "%l%"); } }, new beanpropertyrowmapper(deptbean.class)); system.out.println(deptlist_2); //3、直接處理resultset???????什么意思 list<vector<string>>deptlist_3=this.getjdbctemplate().query(sql, new preparedstatementsetter() { @override public void setvalues(preparedstatement ps) throws sqlexception { ps.setstring(1, "%l%"); } },new rowmapper() { @override public object maprow(resultset rs, int rownum) throws sqlexception { int deptid = rs.getint("deptid"); string deptname = rs.getstring("deptname"); vector<string> vector = new vector<string>(); vector.add(string.valueof(deptid)); vector.add(deptname); return vector; } }); system.out.println(deptlist_3); } /* * 使用命名參數(shù)的查詢： * 前提是首先要實例化命名參數(shù)查詢的對象 */ public void three(){//傳一個bean條件，返回結(jié)果 //實例化一個對象 namedparameterjdbctemplate template=new namedparameterjdbctemplate(this.getdatasource()); //如果參數(shù)是javabean，那么返回值也就是javabean string sql="select * from t_dept where deptname like :deptname and remark like :remark"; //創(chuàng)建一個bean，設(shè)置好查詢的條件 deptbean parambean=new deptbean(); parambean.setdeptname("%l%"); parambean.setremark("%shuai%"); //將創(chuàng)建好的bean放到查詢語句的池子里面 beanpropertysqlparametersource paramsource=new beanpropertysqlparametersource(parambean); beanpropertyrowmapper<deptbean> rowbean = new beanpropertyrowmapper<deptbean>( deptbean.class); list<deptbean>deptlist=template.query(sql, paramsource, rowbean); for(deptbean deptbean:deptlist){ system.out.println(deptbean.getdeptname()+"\t"+deptbean.getremark()); } } public static void main(string[] args) { //獲取到bean對象 testmain_9 testmain_9=(testmain_9)springutil.getbean("testmain_9"); //測試方法// testmain_9.one();// testmain_9.two(); testmain_9.three(); }} |
今日筆者就將spring中的jdbctemplate模板介紹到這。
以上這篇spring的連接數(shù)據(jù)庫以及jdbc模板(實例講解)就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持服務(wù)器之家。
原文鏈接：http://www.cnblogs.com/Java766357768/p/7718722.html
