Spring的連接數(shù)據(jù)庫以及JDBC模板(實(shí)例講解)
更新時(shí)間：2017年10月25日 09:19:59 作者：夜孤寒
下面小編就為大家?guī)硪黄猄pring的連接數(shù)據(jù)庫以及JDBC模板(實(shí)例講解)。小編覺得挺不錯(cuò)的，現(xiàn)在就分享給大家，也給大家做個(gè)參考。一起跟隨小編過來看看吧
前言
今天介紹的是關(guān)于Spring的數(shù)據(jù)庫連接以及Jdbc模板的相關(guān)API方法，雖然在學(xué)習(xí)了hibernate之后，會(huì)知道實(shí)現(xiàn)數(shù)據(jù)庫連接一般都是使用hibernate等持久化框架來實(shí)現(xiàn)的。但是，很多時(shí)候一些涉及到事務(wù)的東西使用這些框架并不能夠?qū)崿F(xiàn)，所以我們還需要結(jié)合spring來實(shí)現(xiàn)相關(guān)的需要。
一、創(chuàng)建工程、導(dǎo)包
要想使用Spring的jdbc模板前，還需要導(dǎo)入相關(guān)的jar包：
二、進(jìn)行相關(guān)的bean的創(chuàng)建以及工具類的編寫
2.1在數(shù)據(jù)庫中創(chuàng)建了兩張表，使用spring的jdbcTemplate中的API方法對這兩張表進(jìn)行操作
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創(chuàng)建實(shí)體bean
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
package com.util;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* 讀取配置文件的工具類，實(shí)現(xiàn)了類似工廠模式的方式
*
* @author 夜孤寒
* @version 1.1.1
*/
public class SpringUtil {
// 定義屬性
private static ApplicationContext context;
// 讀取配置文件
static {
context = new ClassPathXmlApplicationContext("spring.xml");
}
// 定義一個(gè)方法，判斷bean是否為空，如果不為空的，獲取這個(gè)bean
public static Object getBean(String beanName) {
// 定義一個(gè)空對象
Object obj = null;
// 如果beanName不為空的話，那么根據(jù)這個(gè)beanName獲取到bean對象，賦值給obj并返回
if (beanName != null && !beanName.equals("")) {
obj = context.getBean(beanName);
}
return obj;
}
}
2.4進(jìn)行配置文件的相關(guān)配置——spring.xml文件的配置
因?yàn)橐榻B的API方法可能比較多，所以一次性將寫過的xml全部粘貼了，讀者可以根據(jù)對應(yīng)的配置，去對應(yīng)到相應(yīng)的類中：
<?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：直接引用
-->
<!-- 首先需要引入一個(gè)驅(qū)動(dòng)，然後到這驅(qū)動(dòng)類下面，去查看他的源代碼，一下是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è)模板用構(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這個(gè)父類，然后用里面的方法獲取到模板，
從而獲取到數(shù)據(jù)。
備注：這個(gè)是最完美的獲取數(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中的配置為：
<!-- 方式一： 配置使用IOC：直接引用 --> <!-- 首先需要引入一個(gè)驅(qū)動(dòng)，然後到這驅(qū)動(dòng)類下面，去查看他的源代碼，一下是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)的測試類：
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對象，
* 這里使用工廠類的方法將之獨(dú)立出來，具體使用見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配置為：
<!-- 使用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)的測試類為：
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這個(gè)類來獲取到后端的數(shù)據(jù)
對應(yīng)的xml文件的配置為：
<!-- 使用我們的模板來獲取我們的數(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)的測試類：
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這個(gè)類來獲取后臺(tái)數(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é)果：
這種方式的話每次我們都要?jiǎng)?chuàng)建一個(gè)JdbcTemplate實(shí)例，這樣子比較復(fù)雜，所以考慮能不能將這個(gè)類讓Spring自己創(chuàng)建，然后在bean配置文件中引用數(shù)據(jù)源來達(dá)到目的。這就是下面要介紹的第四種方式。
（4）在配置文件中配置我們的模板類，讓Spring生成需要的bean
對應(yīng)的xml配置文件為：
<!-- 方式四 --> <!-- 配置我們模板，然后在類就只要將這個(gè)模板用構(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)的測試類為：
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注入模板，然后引用這個(gè)使用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這個(gè)類，這種方式是最簡單的，也是最常用的方式。下面筆者就簡單介紹一下這種方式的使用。
（5）繼承JdbcDaoSupport類來獲取數(shù)據(jù)庫中的數(shù)據(jù)
對應(yīng)的xml文件中的配置為：
<!-- 方式五：
直接繼承JdbcDaoSupport這個(gè)父類，然后用里面的方法獲取到模板，
從而獲取到數(shù)據(jù)。
備注：這個(gè)是最完美的獲取數(shù)據(jù)的方式，以后一般都是使用這種方式?。。?
-->
<bean name="testMain_5" class="com.jdbc.TestMain_5">
<property name="dataSource" ref="dataSource"></property>
</bean>
對應(yīng)的測試類為：
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注入的方式，直接繼承一個(gè)上述的父類， 觀察上述的父類，發(fā)現(xiàn)在這個(gè)父類里面已經(jīng)實(shí)現(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文件中的配置為：
<!-- 使用spring配置的方式操作我們的DDL語句 --> <bean name="testMain_6" class="com.jdbc.TestMain_6"> <property name="dataSource" ref="dataSource"></property> </bean>
對應(yīng)的測試類為：
package com.jdbc;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import com.util.SpringUtil;
/**
* 使用spring注入的方式進(jìn)行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());
}
/*
* 修改表，這里面可以添加或者刪除某一個(gè)屬性列
*/
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)用一個(gè)方法，打開數(shù)據(jù)庫觀察數(shù)據(jù)庫是不是已經(jīng)變化了
// testMain_6.create();
// testMain_6.alter();
testMain_6.drop();
}
}
經(jīng)過測試可以進(jìn)行DDL操作。
（7）使用spring注入的方式進(jìn)行DML操作
對應(yīng)xml文件中的配置：
<!-- 使用spring配置的方式操作我們的DML語句 --> <bean name="testMain_7" class="com.jdbc.TestMain_7"> <property name="dataSource" ref="dataSource"></property> </bean>
對應(yīng)測試類：
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ù)組的第一個(gè)元素對應(yīng)的是SQL語句中的第一個(gè)參數(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)測試，可以實(shí)現(xiàn)DML操作中的增刪改查。
（8）使用JdbcTemplate模板中的命名參數(shù)來操作我們的DML語句
對應(yīng)xml中的配置為：
<!-- 使用JdbcTemplate模板中的命名參數(shù)來操作我們的DML語句 --> <bean name="testMain_8" class="com.jdbc.TestMain_8"> <property name="dataSource" ref="dataSource"></property> </bean>
對應(yīng)的測試類：
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ù)放進(jìn)我們的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");
// 使用一個(gè)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);//由這個(gè)參數(shù)來控制是不是插入某一個(gè)屬性列的數(shù)據(jù)
testMain_8.update();
}
}
（9）JdbcTemplate模板對于查詢語句的封裝
對應(yīng)的xml文件的配置：
<!-- 使用JdbcTemplate模板對于查詢語句的封裝 --> <bean name="testMain_9" class="com.jdbc.TestMain_9"> <property name="dataSource" ref="dataSource"></property> </bean>
對應(yīng)的測試類：
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{
/*
* 最簡單的一個(gè)查詢
*/
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方法來接收一個(gè)對象:
* 1、如果方法的第二個(gè)參數(shù)是class類型的話，表示SQL只能返回一行一列。相當(dāng)于RowMapper中的SingleColumnRowMapper；
* 2、如果方法的第二個(gè)參數(shù)是rowMapper類型的話，表示SQL語句只能返回一行多列。
* 一行多列，默認(rèn)是返回queryForMap，但是Spring允許可以對返回的行數(shù)據(jù)進(jìn)行自定義的映射
*/
/*
* 方式一：返回的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：
* 這個(gè)是模板封裝好的查詢方法
*/
@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"這個(gè)字符的所有對象
ps.setString(1, "%l%");
}
},new ColumnMapRowMapper());//這里代表返回的是一個(gè)什么類型
System.out.println(deptList);
//2、處理帶有預(yù)編譯的語句，并且返回的是一個(gè)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í)例化命名參數(shù)查詢的對象
*/
public void three(){//傳一個(gè)bean條件，返回結(jié)果
//實(shí)例化一個(gè)對象
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)建一個(gè)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模板(實(shí)例講解)就是小編分享給大家的全部內(nèi)容了，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。
相關(guān)文章
java常用數(shù)據(jù)流應(yīng)用實(shí)例解析
這篇文章主要介紹了java常用數(shù)據(jù)流應(yīng)用實(shí)例解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2019-12-12
談?wù)凷pring 注入properties文件總結(jié)
本篇談?wù)凷pring 注入properties文件總結(jié)，小編覺得挺不錯(cuò)的，現(xiàn)在分享給大家，也給大家做個(gè)參考。一起跟隨小編過來看看吧2017-01-01
微服務(wù)鏈路追蹤Spring Cloud Sleuth整合Zipkin解析
這篇文章主要為大家介紹了微服務(wù)鏈路追蹤Spring Cloud Sleuth整合Zipkin解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-02-02
關(guān)于Java 項(xiàng)目封裝sqlite連接池操作持久化數(shù)據(jù)的方法
這篇文章主要介紹了Java 項(xiàng)目封裝sqlite連接池操作持久化數(shù)據(jù)的方法,文中給大家介紹了sqlite的體系結(jié)構(gòu)及封裝java的sqlite連接池的詳細(xì)過程，需要的朋友可以參考下2021-11-11
分析并解決Intellij IDEA覆蓋tomcat配置的問題/解決修改server.xml無效的問題，本文給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友一起看看吧2021-02-02
這篇文章主要介紹了Java WindowBuilder 安裝及基本使用的教程，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-05-05
這篇文章主要介紹了Java 代碼檢查工具之PMD入門使用詳細(xì)教程,本文通過圖文并茂的形式給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2021-03-03
本文簡單介紹了緩存的種類，緩存常見的問題，對大家的學(xué)習(xí)和工作有一定的參考價(jià)值，需要的小伙伴可以參考一下2021-08-08
SpringBoot?整合mapstruct的實(shí)現(xiàn)步驟
這篇文章主要介紹了SpringBoot整合mapstruct，文中通過示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2021-11-11
springboot中請求地址轉(zhuǎn)發(fā)的兩種方案
在開發(fā)過程中,我們經(jīng)常需要將請求從一個(gè)服務(wù)轉(zhuǎn)發(fā)到另一個(gè)服務(wù),以實(shí)現(xiàn)不同服務(wù)之間的協(xié)作,本文主要介紹了springboot中請求地址轉(zhuǎn)發(fā)的兩種方案,感興趣的可以了解一下2023-11-11