Spring的连接数据库以及JDBC模板(实例讲解)

Spring的连接数据库以及JDBC模板(实例讲解)

前言

今天介绍的是关于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全部粘贴了，读者可以根据对应的配置，去对应到相应的类中：

xmlns:xsi="http://w3.org/2001/XMLSchema-instance" xmlns:p="http://springframework.org/schema/p"

xmlns:context="http://springframework.org/schema/context"

xmlns:aop="http://springframework.org/schema/aop" xmlns:tx="http://springframework.org/schema/tx"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans-3.0.xsd

http://springframework.org/schema/context

http://springframework.org/schema/context/spring-context-3.0.xsd

http://springframework.org/schema/tx

http://springframework.org/schema/tx/spring-tx-3.0.xsd

http://springframework.org/schema/aop

http://springframework.org/schema/aop/spring-aop-3.0.xsd">

xmlns:xsi="http://w3.org/2001/XMLSchema-instance" xmlns:p="http://springframework.org/schema/p"

xmlns:context="http://springframework.org/schema/context"

xmlns:aop="http://springframework.org/schema/aop" xmlns:tx="http://springframework.org/schema/tx"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans-3.0.xsd

http://springframework.org/schema/context

http://springframework.org/schema/context/spring-context-3.0.xsd

http://springframework.org/schema/tx

http://springframework.org/schema/tx/spring-tx-3.0.xsd

http://springframework.org/schema/aop

http://springframework.org/schema/aop/spring-aop-3.0.xsd">

2.5介绍spring对于jdbc的模板的支持

（1）数据库的连接

对应xml中的配置为：

对应的测试类：

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配置为：

对应的测试类为：

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文件的配置为：

对应的测试类：

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

for(MaprowMap: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实例，这样子比较复杂，所以考虑能不能将这个类让SKWWqSpring自己创建，然后在bean配置文件中引用数据源来达到目的。这就是下面要介绍的第四种方式。

（4）在配置文件中配置我们的模板类，让Spring生成需要的bean

对应的xml配置文件为：

对应的测试类为：

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

for (Map 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这个父类，然后用里面的方法获取到模板，

从而获取到数据。

备注：这个是最完美的获取数据的方式，以后一般都是使用这种方式！！！

-->

对应的测试类为：

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

for (Map 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文件中的配置为：

对应的测试类为：

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());

}http://

/*

* 测试方法

*/

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文件中的配置：

对应测试类：

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中的配置为：

对应的测试类：

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 paramMap = new HashMap();

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文件的配置：

对应的测试类：

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

for(MaprowMap:deptList){

System.out.println(rowMap);

}

System.out.println("==============================");

System.out.println("2：返回一条对象");

/*

* 返回一条对象，将返回的对象使用Map的方式来接收

*/

sql="select * from t_dept where deptid=1";

MaprowMap=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";

BeanPropertyRowMapperrowMapper=new BeanPropertyRowMapper(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

@Override

public void setValues(PreparedStatement ps) throws SQLException {

//查询带有"l"这个字符的所有对象

ps.setString(1, "%l%");

}

},new ColumnMapRowMapper());//这里代表返回的是一个什么类型

System.out.println(deptList);

//2、处理带有预编译的语句，并且返回的是一个javabean

ListdeptList_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>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 vector = new Vector();

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 rowBean = new BeanPropertyRowMapper(

DeptBean.class);

ListdeptList=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模板介绍到这。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。