Spring 使用 JdbcTemplate 操作數據庫

之前我們使用 Java 操作數據庫，要么使用自己封裝的 Jdbc 工具類，要么使用 Mybatis。現在 Spring 自帶的 JdbcTemplate 工具類使用起來也非常簡單。如果你在實際開發中不想使用 Mybatis 的話，不妨可以使用 Spring 自帶的 JdbcTemplate 工具類。

本篇博客主要演示 Spring 自帶的兩種 JdbcTemplate 工具類的使用，一種是必須按照 SQL 語句中的參數順序，提供參數的 JdbcTemplate 工具類，一種是按照 SQL 語句中參數名稱，提供參數的 NamedParameterJdbcTemplate 工具類。當然如果在實際開發中使用的話，強烈推薦使用 NamedParameterJdbcTemplate 工具類。另外在本篇博客最后會提供 Demo 的源代碼。

一、搭建工程

新建一個 maven 項目，導入相關 jar 包，我導入的都是最新版本的 jar 包，內容如下：

有關具體的 jar 包地址，可以在 https://mvnrepository.com 上進行查詢。

<dependencies>
    <!--Spring 相關的 jar 包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.17</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.17</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.17</version>
        <scope>test</scope>
    </dependency>

    <!--Mysql 和數據庫連接池相關的 jar 包-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.8</version>
    </dependency>

    <!--
        其它相關 jar 包：
        junit 單元測試方法編寫所需要的 jar 包
        commons-lang3 這個是 apache 提供的實用的公共類工具 jar 包
    -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.9</version>
    </dependency>
</dependencies>

打開右側的 Maven 窗口，刷新一下，這樣 Maven 會自動下載所需的 jar 包文件。

搭建好的項目工程整體目錄比較簡單，具體如下圖所示：

項目工程結構簡單介紹：

config 包下存放的是 Spring 的配置類

dao 包下存放的是使用 JdbcTemplate 操作數據庫的方法類

domain 包下存放是具體的 Java Bean 實體對象類

service 包下存放的是轉調 dao 進行業務處理實現類

resources 目錄下存放的是連接數據庫的相關參數的配置文件

test 目錄下是兩個 Service 測試方法類，里面編寫了間接測試兩種 JdbcTemplate 數據庫操作的方法

說明：本 Demo 主要通過對 Employee 表進行增刪改查，演示 JdbcTemplate 和 NamedParameterJdbcTemplate 的使用。

二、相關配置細節

在本機的 mysql 中運行以下 sql 腳本，進行數據庫環境的准備工作，內容如下：

CREATE DATABASE IF NOT EXISTS `testdb`;
USE `testdb`;


CREATE TABLE IF NOT EXISTS `employee` (
  `e_id` int(11) NOT NULL AUTO_INCREMENT,
  `e_name` varchar(50) DEFAULT NULL,
  `e_salary` int(11) DEFAULT NULL,
  PRIMARY KEY (`e_id`)
) ENGINE=InnoDB AUTO_INCREMENT=103 DEFAULT CHARSET=utf8;


INSERT INTO `employee` (`e_id`, `e_name`, `e_salary`) VALUES
	(1, '侯胖胖', 25000),
	(2, '楊磅磅', 23000),
	(3, '李噸噸', 33000),
	(4, '任肥肥', 35000),
	(5, '喬豆豆', 32000),
	(6, '任天蓬', 38000),
	(7, '任政富', 40000);

在 resources 目錄下的 jdbc.properties 文件配置數據庫連接信息，內容如下：

mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/testdb?useSSL=false
mysql.username=root
mysql.password=123456

# 初始化連接的數量
druid.initialSize=3
# 最大連接的數量
druid.maxActive=20
# 獲取連接的最大等待時間（毫秒）
druid.maxWait=3000

在 config 包下，編寫 Jdbc 連接數據庫的配置類，兩種 JdbcTemplate 的 Spring Bean 裝載類，以及 Spring 的配置類：

package com.jobs.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

import javax.sql.DataSource;

//通過 @PropertySource 注解，加載 jdbc.properties 文件的配置信息
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    //通過 @Value 注解，獲取 jdbc.properties 文件中相關 key 的配置值
    @Value("${mysql.driver}")
    private String driver;
    @Value("${mysql.url}")
    private String url;
    @Value("${mysql.username}")
    private String userName;
    @Value("${mysql.password}")
    private String password;

    @Value("${druid.initialSize}")
    private Integer initialSize;
    @Value("${druid.maxActive}")
    private Integer maxActive;
    @Value("${druid.maxWait}")
    private Long maxWait;

    //讓 Spring 裝載 druid 具有數據庫連接池的數據源
    @Bean
    public DataSource getDataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        ds.setInitialSize(initialSize);
        ds.setMaxActive(maxActive);
        ds.setMaxWait(maxWait);
        return ds;
    }

    //讓 Spring 裝載 JdbcTemplate 對象
    @Bean("jdbcTemplate1")
    public JdbcTemplate getJdbcTemplate(@Autowired DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    //讓 Spring 裝載 NamedParameterJdbcTemplate 對象
    @Bean("jdbcTemplate2")
    public NamedParameterJdbcTemplate getJdbcTemplate2(@Autowired DataSource dataSource) {
        return new NamedParameterJdbcTemplate(dataSource);
    }
}

package com.jobs.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan("com.jobs")
@Import(JdbcConfig.class)
public class SpringConfig {
}

三、其它細節相關

首先列出 domain 包下 Employee 實體類細節，內容如下：

注意：這里的 Employee 類的各個字段，保持跟數據庫表 employee 的相應字段一致。因為這樣做的話，后續返回實體類對象或實體類對象列表時，在兩種 JdbcTemplate 工具類中，都可以使用 BeanPropertyRowMapper 自動進行數據庫表字段與實體類字段的映射賦值，使用起來非常方便，大大提高了開發效率。

package com.jobs.domain;

public class Employee {

    private Integer e_id;
    private String e_name;
    private Integer e_salary;

    public Employee() {
    }

    public Employee(Integer e_id, String e_name, Integer e_salary) {
        this.e_id = e_id;
        this.e_name = e_name;
        this.e_salary = e_salary;
    }

    //此處省略了 get 和 set 方法的細節....

    @Override
    public String toString() {
        return "Employee{" +
                "e_id=" + e_id +
                ", e_name='" + e_name + '\'' +
                ", e_salary=" + e_salary +
                '}';
    }
}

dao 層中兩種 JdbcTemplate 工具類的使用細節：

package com.jobs.dao;

import com.jobs.domain.Employee;
import org.apache.commons.lang3.StringUtils;

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Repository
public class EmployeeDao1 {

    @Resource(name = "jdbcTemplate1")
    private JdbcTemplate jdbcTemplate;

    //添加員工，返回受影響的行數
    public Integer add(Employee emp) {

        String sql = "insert into employee(e_id,e_name,e_salary) values(?,?,?)";
        //使用 JdbcTemplate 操作數據庫，參數順序需要跟 sql 語句中的參數順序，保持一致
        Object[] params = {emp.getE_id(), emp.getE_name(), emp.getE_salary()};
        Integer result = jdbcTemplate.update(sql, params);
        return result;
    }

    //修改員工信息，返回受影響的行數
    public Integer update(Employee emp) {

        String sql = "update employee set e_name=?,e_salary=? where e_id=?";
        //使用 JdbcTemplate 操作數據庫，參數順序需要跟 sql 語句中的參數順序，保持一致
        Object[] params = {emp.getE_name(), emp.getE_salary(), emp.getE_id()};
        Integer result = jdbcTemplate.update(sql, params);
        return result;
    }

    //獲取員工的數量
    public Long getEmployeeCount() {
        String sql = "select count(*) from employee";
        Long result = jdbcTemplate.queryForObject(sql, Long.class);
        return result;
    }

    //根據員工 id 查詢員工信息
    public Employee getEmployeeById(Integer eid) {

        String sql = "select e_id,e_name,e_salary from employee where e_id = ?";
        //自定義數據庫的行數據，與 JavaBean 的字段屬性映射解析器
        RowMapper<Employee> rm = (rs, rowNum) -> {
            Employee emp = new Employee();
            emp.setE_id(rs.getInt("e_id"));
            emp.setE_name(rs.getString("e_name"));
            emp.setE_salary(rs.getInt("e_salary"));
            return emp;
        };

        return jdbcTemplate.queryForObject(sql, rm, eid);
    }

    //查詢出所有員工，按照id升序排列
    public List<Employee> selectAll() {

        String sql = "select e_id,e_name,e_salary from employee order by e_id";
        //如果數據庫字段名稱，與 JavaBean 的字段的名稱完全一致的情況下，可以簡化代碼
        List<Employee> emplist = jdbcTemplate.query(sql,
               new BeanPropertyRowMapper<Employee>(Employee.class));
        return emplist;
    }

    //根據條件，查詢員工
    public List<Employee> selectByCondition(String name, Integer salaryStart, Integer salaryEnd) {

        StringBuilder sql = new StringBuilder();
        List<Object> paramList = new ArrayList<>();

        sql.append(" select e_id,e_name,e_salary from employee where 1=1");

        //使用 JdbcTemplate 操作數據庫，參數順序需要跟 sql 語句中的參數順序，保持一致
        if (StringUtils.isNotBlank(name)) {
            sql.append(" and (e_name like CONCAT('%',?,'%'))");
            paramList.add(name);
        }
        if (salaryStart != null) {
            sql.append(" and e_salary >= ?");
            paramList.add(salaryStart);
        }
        if (salaryEnd != null) {
            sql.append(" and e_salary <= ?");
            paramList.add(salaryEnd);
        }
        sql.append(" order by e_id");

        //如果數據庫字段名稱，與 JavaBean 的字段的名稱完全一致的情況下，可以簡化代碼
        //注意：這里傳遞的 SQL 參數列表，需要將 List 轉換為 Array ，否則會報錯
        List<Employee> emplist = jdbcTemplate.query(sql.toString(),
               new BeanPropertyRowMapper<Employee>(Employee.class), paramList.toArray());
        return emplist;
    }

    //傳入一個或多個id，刪除指定的員工
    public Integer deleteByIds(Integer... empids) {

        StringBuilder sql = new StringBuilder();
        List<Object> paramList = new ArrayList<>();

        sql.append("delete from employee");

        //使用 JdbcTemplate 操作數據庫，參數順序需要跟 sql 語句中的參數順序，保持一致
        //這里故意使用參數傳遞，展示 JdbcTemplate 的參數使用方式
        if (empids != null && empids.length > 0) {
            sql.append(" where e_id in (");
            for (int i = 0; i < empids.length; i++) {
                if (i == 0) {
                    sql.append("?");
                } else {
                    sql.append(",?");
                }
                paramList.add(empids[i]);
            }
            sql.append(")");
        } else {
            //如果沒有傳遞員工 id 的話，就不刪除任何數據
            sql.append(" where 1=2");
        }

        //注意：這里傳遞的 SQL 參數列表，需要將 List 轉換為 Array ，否則會報錯
        Integer result = jdbcTemplate.update(sql.toString(), paramList.toArray());
        return result;

        /*
        //這是沒有使用參數的實現方案，比較簡單一些
        if (empids != null && empids.length > 0) {
            String idsql = StringUtils.join(empids, ",");
            sql.append(" where e_id in (").append(idsql).append(")");
        } else {
            //如果沒有傳遞員工 id 的話，就不刪除任何數據
            sql.append(" where 1=2");
        }

        Integer result = jdbcTemplate.update(sql.toString());
        return result;
         */
    }
}

package com.jobs.dao;

import com.jobs.domain.Employee;
import org.apache.commons.lang3.StringUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Repository
public class EmployeeDao2 {

    @Resource(name = "jdbcTemplate2")
    private NamedParameterJdbcTemplate jdbcTemplate;

    //添加員工，返回受影響的行數
    public Integer add(Employee emp) {

        String sql = "insert into employee(e_id,e_name,e_salary) values(:id,:name,:salary)";
        //使用 NamedParameterJdbcTemplate 操作數據庫，需要提供 sql 語句中對應的參數和值，順序無所謂
        //注意：參數名稱不需要加冒號
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("salary", emp.getE_salary());
        paramMap.put("id", emp.getE_id());
        paramMap.put("name", emp.getE_name());

        Integer result = jdbcTemplate.update(sql, paramMap);
        return result;
    }

    //修改員工信息，返回受影響的行數
    public Integer update(Employee emp) {

        String sql = "update employee set e_name=:name,e_salary=:salary where e_id=:id";
        //使用 NamedParameterJdbcTemplate 操作數據庫，需要提供 sql 語句中對應的參數和值，順序無所謂
        //注意：參數名稱不需要加冒號
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("salary", emp.getE_salary());
        paramMap.put("id", emp.getE_id());
        paramMap.put("name", emp.getE_name());

        Integer result = jdbcTemplate.update(sql, paramMap);
        return result;
    }

    //獲取員工的數量
    public Long getEmployeeCount() {
        String sql = "select count(*) from employee";
        Long result = jdbcTemplate.queryForObject(sql, new HashMap<>(), Long.class);
        return result;
    }

    //根據員工 id 查詢員工信息
    public Employee getEmployeeById(Integer eid) {

        String sql = "select e_id,e_name,e_salary from employee where e_id =:id";
        //自定義數據庫的行數據，與 JavaBean 的字段屬性映射解析器
        RowMapper<Employee> rm = (rs, rowNum) -> {
            Employee emp = new Employee();
            emp.setE_id(rs.getInt("e_id"));
            emp.setE_name(rs.getString("e_name"));
            emp.setE_salary(rs.getInt("e_salary"));
            return emp;
        };

        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("id", eid);

        return jdbcTemplate.queryForObject(sql, paramMap, rm);
    }

    //查詢出所有員工，按照id升序排列
    public List<Employee> selectAll() {

        String sql = "select e_id,e_name,e_salary from employee order by e_id";
        //如果數據庫字段名稱，與 JavaBean 的字段的名稱完全一致的情況下，可以簡化代碼
        List<Employee> emplist = jdbcTemplate.query(sql,
               new BeanPropertyRowMapper<Employee>(Employee.class));
        return emplist;
    }

    //根據條件，查詢員工
    public List<Employee> selectByCondition(String name, Integer salaryStart, Integer salaryEnd) {

        StringBuilder sql = new StringBuilder();
        Map<String, Object> paramMap = new HashMap<>();

        sql.append(" select e_id,e_name,e_salary from employee where 1=1");

        //使用 JdbcTemplate 操作數據庫，參數順序需要跟 sql 語句中的參數順序，保持一致
        if (StringUtils.isNotBlank(name)) {
            sql.append(" and (e_name like CONCAT('%',:name,'%'))");
            paramMap.put("name", name);
        }
        if (salaryStart != null) {
            sql.append(" and e_salary >= :start");
            paramMap.put("start", salaryStart);
        }
        if (salaryEnd != null) {
            sql.append(" and e_salary <= :end");
            paramMap.put("end", salaryEnd);
        }
        sql.append(" order by e_id");

        //如果數據庫字段名稱，與 JavaBean 的字段的名稱完全一致的情況下，可以簡化代碼
        List<Employee> emplist = jdbcTemplate.query(sql.toString(),
               paramMap, new BeanPropertyRowMapper<Employee>(Employee.class));
        return emplist;
    }

    //傳入一個或多個id，刪除指定的員工
    public Integer deleteByIds(Integer... empids) {

        StringBuilder sql = new StringBuilder();
        Map<String, Object> paramMap = new HashMap<>();

        sql.append("delete from employee");

        //使用 JdbcTemplate 操作數據庫，參數順序需要跟 sql 語句中的參數順序，保持一致
        //這里故意使用參數傳遞，展示 JdbcTemplate 的參數使用方式
        if (empids != null && empids.length > 0) {
            sql.append(" where e_id in (");
            for (int i = 0; i < empids.length; i++) {
                if (i == 0) {
                    sql.append(":id" + i);
                } else {
                    sql.append(",:id" + i);
                }
                paramMap.put("id" + i, empids[i]);
            }
            sql.append(")");
        } else {
            //如果沒有傳遞員工 id 的話，就不刪除任何數據
            sql.append(" where 1=2");
        }

        Integer result = jdbcTemplate.update(sql.toString(), paramMap);
        return result;

        /*
        //這是沒有使用參數的實現方案，比較簡單一些
        if (empids != null && empids.length > 0) {
            String idsql = StringUtils.join(empids, ",");
            sql.append(" where e_id in (").append(idsql).append(")");
        } else {
            //如果沒有傳遞員工 id 的話，就不刪除任何數據
            sql.append(" where 1=2");
        }

        Integer result = jdbcTemplate.update(sql.toString());
        return result;
         */
    }
}

下面列出 service 包下的兩個業務處理類，由於本 Demo 的業務很簡單，所以這里只是對相應 dao 層兩個類的對應方法轉調：

package com.jobs.service;

import com.jobs.dao.EmployeeDao1;
import com.jobs.domain.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmployeeService1 {

    @Autowired
    private EmployeeDao1 employeeDao1;

    //添加員工，返回受影響的行數
    public Integer add(Employee emp) {
        return employeeDao1.add(emp);
    }

    //修改員工信息，返回受影響的行數
    public Integer update(Employee emp) {
        return employeeDao1.update(emp);
    }

    //獲取員工的數量
    public Long getEmployeeCount() {
        return employeeDao1.getEmployeeCount();
    }

    //根據員工 id 查詢員工信息
    public Employee getEmployeeById(Integer eid) {
        return employeeDao1.getEmployeeById(eid);
    }

    //查詢出所有員工，按照id升序排列
    public List<Employee> selectAll() {
        return employeeDao1.selectAll();
    }

    //根據條件，查詢員工
    public List<Employee> selectByCondition(String name, Integer salaryStart, Integer salaryEnd) {
        return employeeDao1.selectByCondition(name, salaryStart, salaryEnd);
    }

    //傳入一個或多個id，刪除指定的員工
    public Integer deleteByIds(Integer... empids) {
        return employeeDao1.deleteByIds(empids);
    }
}

package com.jobs.service;

import com.jobs.dao.EmployeeDao2;
import com.jobs.domain.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmployeeService2 {

    @Autowired
    private EmployeeDao2 employeeDao2;

    //添加員工，返回受影響的行數
    public Integer add(Employee emp) {
        return employeeDao2.add(emp);
    }

    //修改員工信息，返回受影響的行數
    public Integer update(Employee emp) {
        return employeeDao2.update(emp);
    }

    //獲取員工的數量
    public Long getEmployeeCount() {
        return employeeDao2.getEmployeeCount();
    }

    //根據員工 id 查詢員工信息
    public Employee getEmployeeById(Integer eid) {
        return employeeDao2.getEmployeeById(eid);
    }

    //查詢出所有員工，按照id升序排列
    public List<Employee> selectAll() {
        return employeeDao2.selectAll();
    }

    //根據條件，查詢員工
    public List<Employee> selectByCondition(String name, Integer salaryStart, Integer salaryEnd) {
        return employeeDao2.selectByCondition(name, salaryStart, salaryEnd);
    }

    //傳入一個或多個id，刪除指定的員工
    public Integer deleteByIds(Integer... empids) {
        return employeeDao2.deleteByIds(empids);
    }
}

四、成果測試驗證

最后我們在 test 目錄下創建兩個測試類，測試驗證上面編寫的代碼成果：

package com.jobs;

import com.jobs.config.SpringConfig;
import com.jobs.domain.Employee;
import com.jobs.service.EmployeeService1;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class EmployeeServiceTest1 {

    //對 JdbcTemplate 的使用，進行測試
    @Autowired
    private EmployeeService1 employeeService1;

    //添加員工，返回受影響的行數
    @Test
    public void add() {
        Employee emp1 = new Employee(100, "候菲特", 50000);
        Integer result1 = employeeService1.add(emp1);
        System.out.println(result1);

        Employee emp2 = new Employee(101, "任蓋茨", 60000);
        Integer result2 = employeeService1.add(emp2);
        System.out.println(result2);

        Employee emp3 = new Employee(102, "李政富", 70000);
        Integer result3 = employeeService1.add(emp3);
        System.out.println(result3);
    }

    //修改員工信息，返回受影響的行數
    @Test
    public void update() {
        Employee emp = new Employee(100, "任首富", 80000);
        Integer result = employeeService1.update(emp);
        System.out.println(result);
    }

    //獲取員工的數量
    @Test
    public void getEmployeeCount() {
        long result = employeeService1.getEmployeeCount();
        System.out.println(result);
    }

    //根據員工 id 查詢員工信息
    @Test
    public void getEmployeeById() {
        Employee emp = employeeService1.getEmployeeById(100);
        System.out.println(emp);
    }

    //查詢出所有員工，按照id升序排列
    @Test
    public void selectAll() {
        List<Employee> emplist = employeeService1.selectAll();
        for (Employee emp : emplist) {
            System.out.println(emp);
        }
    }

    //根據條件，查詢員工
    @Test
    public void selectByCondition() {
        String name = "任";
        int start = 30000;
        int end = 60000;
        List<Employee> emplist = employeeService1.selectByCondition(name, start, end);
        for (Employee emp : emplist) {
            System.out.println(emp);
        }
    }

    //傳入一個或多個id，刪除指定的員工
    @Test
    public void deleteByIds() {
        int result = employeeService1.deleteByIds(100, 101, 102);
        System.out.println(result);
    }
}

package com.jobs;

import com.jobs.config.SpringConfig;
import com.jobs.domain.Employee;
import com.jobs.service.EmployeeService2;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class EmployeeServiceTest2 {

    //對 NamedParameterJdbcTemplate 的使用，進行測試
    @Autowired
    private EmployeeService2 employeeService2;

    //添加員工，返回受影響的行數
    @Test
    public void add() {
        Employee emp1 = new Employee(100, "候菲特", 50000);
        Integer result1 = employeeService2.add(emp1);
        System.out.println(result1);

        Employee emp2 = new Employee(101, "任蓋茨", 60000);
        Integer result2 = employeeService2.add(emp2);
        System.out.println(result2);

        Employee emp3 = new Employee(102, "李政富", 70000);
        Integer result3 = employeeService2.add(emp3);
        System.out.println(result3);
    }

    //修改員工信息，返回受影響的行數
    @Test
    public void update() {
        Employee emp = new Employee(100, "任首富", 80000);
        Integer result = employeeService2.update(emp);
        System.out.println(result);
    }

    //獲取員工的數量
    @Test
    public void getEmployeeCount() {
        long result = employeeService2.getEmployeeCount();
        System.out.println(result);
    }

    //根據員工 id 查詢員工信息
    @Test
    public void getEmployeeById() {
        Employee emp = employeeService2.getEmployeeById(100);
        System.out.println(emp);
    }

    //查詢出所有員工，按照id升序排列
    @Test
    public void selectAll() {
        List<Employee> emplist = employeeService2.selectAll();
        for (Employee emp : emplist) {
            System.out.println(emp);
        }
    }

    //根據條件，查詢員工
    @Test
    public void selectByCondition() {
        String name = "任";
        int start = 30000;
        int end = 60000;
        List<Employee> emplist = employeeService2.selectByCondition(name, start, end);
        for (Employee emp : emplist) {
            System.out.println(emp);
        }
    }

    //傳入一個或多個id，刪除指定的員工
    @Test
    public void deleteByIds() {
        Integer[] eidArr = new Integer[]{100, 101, 102};
        int result = employeeService2.deleteByIds(eidArr);
        System.out.println(result);
    }
}

到此為止，兩種 JdbcTemplate 的使用方式已經介紹完畢，非常簡單，本 Demo 的源代碼已經詳細測試，沒有任何問題。

在實際開發中強烈推薦使用 NamedParameterJdbcTemplate 工具類。

本 Demo 的源代碼下載地址為：https://files.cnblogs.com/files/blogs/699532/Spring_JdbcTemplate.zip