前言
今天介紹的是關于spring的數據庫連接以及jdbc模板的相關api方法，雖然在學習了hibernate之后，會知道實現數據庫連接一般都是使用hibernate等持久化框架來實現的。但是，很多時候一些涉及到事務的東西使用這些框架并不能夠實現，所以我們還需要結合spring來實現相關的需要。
一、創建工程、導包
要想使用spring的jdbc模板前，還需要導入相關的jar包：
二、進行相關的bean的創建以及工具類的編寫
2.1在數據庫中創建了兩張表，使用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創建實體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;/** * 創建t_dept表對應的表 * @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創建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;/** * 讀取配置文件的工具類，實現了類似工廠模式的方式 * * @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不為空的話，那么根據這個beanname獲取到bean對象，賦值給obj并返回 if (beanname != null && !beanname.equals("")) { obj = context.getbean(beanname); } return obj; }} |
2.4進行配置文件的相關配置——spring.xml文件的配置
因為要介紹的api方法可能比較多，所以一次性將寫過的xml全部粘貼了，讀者可以根據對應的配置，去對應到相應的類中：
|
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：直接引用 --> <!-- 首先需要引入一個驅動，然後到這驅動類下面，去查看他的源代碼，一下是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注入的構造方法注入的方式來注入，并且查詢我們的數據庫中的數據。 注意這里我們還需要一我們之前的datasource作為引用 --> <bean name="testmain_2" class="com.jdbc.testmain_2"> <property name="datasource" ref="datasource"></property> </bean> <!-- 使用我們的模板來獲取我們的數據庫中的數據 --> <bean name="testmain_3" class="com.jdbc.testmain_3"> <!-- 首先我們還是需要引入我們的數據庫資源，也就是我們之前已經配置過的datasource --> <property name="datasource" ref="datasource"></property> </bean> <!-- 方式四 --> <!-- 配置我們模板，然后在類就只要將這個模板用構造方法的方式注入就可以了 --> <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這個父類，然后用里面的方法獲取到模板， 從而獲取到數據。 備注：這個是最完美的獲取數據的方式，以后一般都是使用這種方式！！！ --> <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模板中的命名參數來操作我們的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）數據庫的連接
對應xml中的配置為：
|
1
2
3
4
5
6
7
8
9
10
|
<!-- 方式一： 配置使用ioc：直接引用 --> <!-- 首先需要引入一個驅動，然後到這驅動類下面，去查看他的源代碼，一下是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> |
對應的測試類：
|
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;/** * 連接數據庫的測試類 * @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);//測試是否能夠輸出連接 }} |
測試結果：
由此可見測試成功可以獲取到相應的數據庫連接。
（2）測試從創建的user表中查詢出相應的數據
對應xml配置為：
|
1
2
3
4
5
6
|
<!-- 使用di注入的構造方法注入的方式來注入，并且查詢我們的數據庫中的數據。 注意這里我們還需要一我們之前的datasource作為引用 --> <bean name="testmain_2" class="com.jdbc.testmain_2"> <property name="datasource" ref="datasource"></property> </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
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;/** * 從創建的user表中查詢相關的數據 * * @author 夜孤寒 * @version 1.1.1 */public class testmain_2 { // 使用構造方法注入 public datasource datasource; public void setdatasource(datasource datasource) { this.datasource = datasource; } /** * 從user表中獲取所有數據 */ public void list() { /* * 在我們的main方法中獲取到我們的datasource， 然后就能夠獲取連接，并且獲取到數據庫中的數據。 */ 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 { /* * 需要自己關閉資源 */ } } public static void main(string[] args) { // 獲取到我們bean對象 testmain_2 testmain_2 = (testmain_2) springutil.getbean("testmain_2"); // 調用我們的list方法 testmain_2.list(); }} |
測試結果：
備注：本測試類，使用的是常用的純粹的jdbc獲取數據的方式。
（3）使用jdbctemplate這個類來獲取到后端的數據
對應的xml文件的配置為：
|
1
2
3
4
5
|
<!-- 使用我們的模板來獲取我們的數據庫中的數據 --> <bean name="testmain_3" class="com.jdbc.testmain_3"> <!-- 首先我們還是需要引入我們的數據庫資源，也就是我們之前已經配置過的datasource --> <property name="datasource" ref="datasource"></property> </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
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這個類來獲取后臺數據 * @author 夜孤寒 * */public class testmain_3 { // 使用構造方法注入 public datasource datasource; public void setdatasource(datasource datasource) { this.datasource = datasource; } public void list() { /* * 使用我們jdbctemplate模板來獲取我們的數據 */ 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"); //調用我們的list方法 testmain_3.list(); }} |
測試的結果：
這種方式的話每次我們都要創建一個jdbctemplate實例，這樣子比較復雜，所以考慮能不能將這個類讓spring自己創建，然后在bean配置文件中引用數據源來達到目的。這就是下面要介紹的第四種方式。
（4）在配置文件中配置我們的模板類，讓spring生成需要的bean
對應的xml配置文件為：
|
1
2
3
4
5
6
7
8
9
|
<!-- 方式四 --> <!-- 配置我們模板，然后在類就只要將這個模板用構造方法的方式注入就可以了 --> <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> |
對應的測試類為：
|
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去創建模板類 * * @author 夜孤寒 * @version 1.1.1 */public class testmain_4 { // 使用構造方法的方式注入template public jdbctemplate jdbctemplate; public void setjdbctemplate(jdbctemplate jdbctemplate) { this.jdbctemplate = jdbctemplate; } public void list() { /* * 使用我們ioc注入模板，然后引用這個使用ioc注入的模板， 最后取出我們的數據 */ 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"); // 調用我們的list方法 testmain_4.list(); }} |
測試結果：
這種方式仍舊需要在xml中配置，而在spring中還有一種更加方便的方式就是直接繼承jdbcdaosupport這個類，這種方式是最簡單的，也是最常用的方式。下面筆者就簡單介紹一下這種方式的使用。
（5）繼承jdbcdaosupport類來獲取數據庫中的數據
對應的xml文件中的配置為：
|
1
2
3
4
5
6
7
8
|
<!-- 方式五： 直接繼承jdbcdaosupport這個父類，然后用里面的方法獲取到模板， 從而獲取到數據。 備注：這個是最完美的獲取數據的方式，以后一般都是使用這種方式！！！ --> <bean name="testmain_5" class="com.jdbc.testmain_5"> <property name="datasource" ref="datasource"></property> </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
|
package com.jdbc;import java.util.list;import java.util.map;import org.springframework.jdbc.core.support.jdbcdaosupport;import com.util.springutil;/** * 繼承jdbcdaosupport來獲取模板，再通過模板來獲取數據 * @author 夜孤寒 * @version 1.1.1 * */public class testmain_5 extends jdbcdaosupport { /* * 不使用di注入的方式，直接繼承一個上述的父類， 觀察上述的父類，發現在這個父類里面已經實現了類似注入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"); // 調用我們的list方法 testmain_5.list(); }} |
測試結果為：
（6）使用spring注入的方式來操作ddl語句
對應xml文件中的配置為：
|
1
2
3
4
|
<!-- 使用spring配置的方式操作我們的ddl語句 --> <bean name="testmain_6" class="com.jdbc.testmain_6"> <property name="datasource" ref="datasource"></property> </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
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 { /* * 創建表 */ 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"); // 調用我們的方法，一次調用一個方法，打開數據庫觀察數據庫是不是已經變化了 // testmain_6.create(); // testmain_6.alter(); testmain_6.drop(); }} |
經過測試可以進行ddl操作。
（7）使用spring注入的方式進行dml操作
對應xml文件中的配置：
|
1
2
3
4
|
<!-- 使用spring配置的方式操作我們的dml語句 --><bean name="testmain_7" class="com.jdbc.testmain_7"> <property name="datasource" ref="datasource"></property></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
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影響的行數= " + 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影響的行數=" + rowcount); } /* * preparestatement的寫法 */ public void delete() { stringbuffer deletesql = new stringbuffer(); deletesql.append("delete from t_dept"); deletesql.append(" where deptid=?"); /* * 關于對象數組的使用：對象數組的第一個元素對應的是sql語句中的第一個參數問號 */ object[] obj = { 1 }; int rowcount = this.getjdbctemplate().update(deletesql.tostring(), obj); system.out.println("rowcount影響的行數=" + 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(); }} |
經測試，可以實現dml操作中的增刪改查。
（8）使用jdbctemplate模板中的命名參數來操作我們的dml語句
對應xml中的配置為：
|
1
2
3
4
|
<!-- 使用jdbctemplate模板中的命名參數來操作我們的dml語句 --><bean name="testmain_8" class="com.jdbc.testmain_8"> <property name="datasource" ref="datasource"></property> </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
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模板中的命名參數來操作我們的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(")"); // 將數據放進我們的map中 備注：map中key的名稱==命名參數的名稱 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影響的行數= " + 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(); // 將數據放置到bean里面去 deptbean deptbean = new deptbean(); deptbean.setdeptid(1); deptbean.setdeptname("lisi"); deptbean.setremark("lisizhenshuai"); // 使用一個bean工廠的方法將預處理我們的bean beanpropertysqlparametersource paramsource = new beanpropertysqlparametersource(deptbean); // 調用模板方法更新數據 int rowcount = template.update(updatesql.tostring(), paramsource); // 輸出影響的行數 system.out.println("影響的行數rowcount=" + rowcount); } public static void main(string[] args) { // 獲取到bean對象 testmain_8 testmain_8 = (testmain_8) springutil.getbean("testmain_8"); // 測試方法 // testmain_8.insert(true,true);//由這個參數來控制是不是插入某一個屬性列的數據 testmain_8.update(); }} |
（9）jdbctemplate模板對于查詢語句的封裝
對應的xml文件的配置：
|
1
2
3
4
|
<!-- 使用jdbctemplate模板對于查詢語句的封裝 --><bean name="testmain_9" class="com.jdbc.testmain_9"> <property name="datasource" ref="datasource"></property></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
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、如果方法的第二個參數是class類型的話，表示sql只能返回一行一列。相當于rowmapper中的singlecolumnrowmapper； * 2、如果方法的第二個參數是rowmapper類型的話，表示sql語句只能返回一行多列。 * 一行多列，默認是返回queryformap，但是spring允許可以對返回的行數據進行自定義的映射 */ /* * 方式一：返回的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); //需要將返回的數據轉換成bean對象 deptbean deptbean=this.getjdbctemplate().queryforobject(sql, rowmapper); system.out.println(deptbean.getdeptid()+"\t"+deptbean.getdeptname()+"\t"+deptbean.getremark()); system.out.println("=============================="); } /* * 復雜的查詢queryforxx： * 這個是模板封裝好的查詢方法 */ @suppresswarnings({ "unchecked", "rawtypes" }) public void two(){ //1、處理有預編譯的語句 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、處理帶有預編譯的語句，并且返回的是一個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); } /* * 使用命名參數的查詢： * 前提是首先要實例化命名參數查詢的對象 */ public void three(){//傳一個bean條件，返回結果 //實例化一個對象 namedparameterjdbctemplate template=new namedparameterjdbctemplate(this.getdatasource()); //如果參數是javabean，那么返回值也就是javabean string sql="select * from t_dept where deptname like :deptname and remark like :remark"; //創建一個bean，設置好查詢的條件 deptbean parambean=new deptbean(); parambean.setdeptname("%l%"); parambean.setremark("%shuai%"); //將創建好的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的連接數據庫以及jdbc模板(實例講解)就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持服務器之家。
原文鏈接：http://www.cnblogs.com/Java766357768/p/7718722.html
