众诚远马科技,郭伯权软禁,妓房
前言
今天介绍的是关于spring的数据库连接以及jdbc模板的相关api方法，虽然在学习了hibernate之后，会知道实现数据库连接一般都是使用hibernate等持久化框架来实现的。但是，很多时候一些涉及到事务的东西使用这些框架并不能够实现，所以我们还需要结合spring来实现相关的需要。
一、创建工程、导包
要想使用spring的jdbc模板前，还需要导入相关的jar包：
二、进行相关的bean的创建以及工具类的编写
2.1在数据库中创建了两张表，使用spring的jdbctemplate中的api方法对这两张表进行操作
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;
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
我要评论
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
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全部粘贴了，读者可以根据对应的配置，去对应到相应的类中：
<?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中的配置为：
<!-- 方式一： 配置使用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>
对应的测试类：
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配置为：
<!-- 使用di注入的构造方法注入的方式来注入，并且查询我们的数据库中的数据。
注意这里我们还需要一我们之前的datasource作为引用
-->
<bean name="testmain_2" class="com.jdbc.testmain_2">
<property name="datasource" ref="datasource"></property>
</bean>
对应的测试类为：
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文件的配置为：
<!-- 使用我们的模板来获取我们的数据库中的数据 --> <bean name="testmain_3" class="com.jdbc.testmain_3"> <!-- 首先我们还是需要引入我们的数据库资源，也就是我们之前已经配置过的datasource --> <property name="datasource" ref="datasource"></property> </bean>
对应的测试类：
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配置文件为：
<!-- 方式四 --> <!-- 配置我们模板，然后在类就只要将这个模板用构造方法的方式注入就可以了 --> <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>
对应的测试类为：
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文件中的配置为：
<!-- 方式五：
直接继承jdbcdaosupport这个父类，然后用里面的方法获取到模板，
从而获取到数据。
备注：这个是最完美的获取数据的方式，以后一般都是使用这种方式！！！
-->
<bean name="testmain_5" class="com.jdbc.testmain_5">
<property name="datasource" ref="datasource"></property>
</bean>
对应的测试类为：
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文件中的配置为：
<!-- 使用spring配置的方式操作我们的ddl语句 --> <bean name="testmain_6" class="com.jdbc.testmain_6"> <property name="datasource" ref="datasource"></property> </bean>
对应的测试类为：
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文件中的配置：
<!-- 使用spring配置的方式操作我们的dml语句 --> <bean name="testmain_7" class="com.jdbc.testmain_7"> <property name="datasource" ref="datasource"></property> </bean>
对应测试类：
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中的配置为：
<!-- 使用jdbctemplate模板中的命名参数来操作我们的dml语句 --> <bean name="testmain_8" class="com.jdbc.testmain_8"> <property name="datasource" ref="datasource"></property> </bean>
对应的测试类：
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文件的配置：
<!-- 使用jdbctemplate模板对于查询语句的封装 --> <bean name="testmain_9" class="com.jdbc.testmain_9"> <property name="datasource" ref="datasource"></property> </bean>
对应的测试类：
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模板(实例讲解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持移动技术网。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
浅析我对 String、StringBuilder、StringBuffer 的理解
使用IDEA搭建SSM框架的详细教程(spring + springMVC +MyBatis)
Springboot整合freemarker 404问题解决方案
引入mybatis-plus报 Invalid bound statement错误问题的解决方法
网友评论