前言
今天介绍的是关于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
