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;

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;


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

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;

public class TestMain_1 {
 public static void main(String[] args) {
  
  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;


public class TestMain_2 {
 // 使用构造方法注入
 public DataSource datasource;

 public void setDataSource(DataSource datasource) {
  this.datasource = datasource;
 }

 
 public void list() {
  
  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;

public class TestMain_3 {
 // 使用构造方法注入
 public DataSource datasource;

 public void setDataSource(DataSource datasource) {
  this.datasource = datasource;
 }

 public void list() {
  
  JdbcTemplate jdbcTemplate=new JdbcTemplate(this.datasource);
  String sql="select * from user";
  List>userlist=jdbcTemplate.queryForList(sql);
  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实例，这样子比较复杂，所以考虑能不能将这个类让Spring自己创建，然后在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;


public class TestMain_4 {
 // 使用构造方法的方式注入template
 public JdbcTemplate jdbcTemplate;

 public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  this.jdbcTemplate = jdbcTemplate;
 }

 public void list() {
  
  String sql = "select USER_NAME from user";
  List> userlist = this.jdbcTemplate.queryForList(sql);
  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文件中的配置为：

对应的测试类为：

package com.jdbc;

import java.util.List;
import java.util.Map;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.util.SpringUtil;

public class TestMain_5 extends JdbcDaoSupport {
 

 public void list() {
  String sql = "select * from user";
  List> userlist = this.getJdbcTemplate().queryForList(sql);
  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;


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

对应测试类：

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;



public class TestMain_7 extends JdbcDaoSupport {
 
 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);
 }

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

 
 public void delete() {
  StringBuffer deleteSQL = new StringBuffer();
  deleteSQL.append("delete from t_dept");
  deleteSQL.append(" where deptid=?");
  
  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;


public class TestMain_8 extends NamedParameterJdbcDaoSupport {
 
 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);
 }

 
 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;

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>deptList=this.getJdbcTemplate().queryForList(sql);
  for(MaprowMap:deptList){
   System.out.println(rowMap);
  }
  System.out.println("==============================");
  System.out.println("2：返回一条对象");
  
  sql="select * from t_dept where deptid=1";
  MaprowMap=this.getJdbcTemplate().queryForMap(sql);
  if(rowMap!=null){
   System.out.println(rowMap);
  }
  
  
  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);
  
  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("==============================");
  
 }
 
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public void two(){
  //1、处理有预编译的语句
  String sql="select * from t_dept where deptname like ? order by deptid asc";
  List>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
  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模板介绍到这。

以上这篇Spring的连接数据库以及JDBC模板(实例讲解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持考高分网。