Spring如何連接數據庫以及JDBC模板

這篇文章將為大家詳細講解有關Spring如何連接數據庫以及JDBC模板，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

一、創建工程、導包

要想使用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如何連接數據庫以及JDBC模板”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。