Spring 使用 JdbcTemplate 操作資料庫

阿新 • • 發佈：2022-03-28

之前我們使用 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

Spring 使用 JdbcTemplate 操作資料庫

一、搭建工程

二、相關配置細節

三、其它細節相關

四、成果測試驗證

Spring-JDBCTemplate操作資料庫（批量增刪改）

詳解在spring中使用JdbcTemplate操作資料庫的幾種方式

spring-boot-route（七）整合jdbcTemplate操作資料庫

Spring學習筆記之jdbcTemplate操作資料庫

【Spring 從0開始】JdbcTemplate 操作資料庫

Spring 使用 JdbcTemplate 操作資料庫

Spring JdbcTemplate操作

spring boot操作資料庫的時候，拋了一個錯誤：mysql時間區域時差問題

jdbctemplate 新增_Spring Boot 使用JdbcTemplate操作資料庫，配置多資料來源

JdbcTemplate操作資料庫-批量操作

在spring中使用JdbcTemplate進行資料庫管理操作

spring-boot-route（九）整合JPA操作資料庫

Spring Boot整合MyBatis操作資料庫

JdbcTemplate（操作資料庫-新增功能）

JdbcTemplate（操作資料庫-查詢返回值）

JdbcTemplate（操作資料庫-修改和刪除功能）

JAVA中直接用Jdbc就能操作資料庫了，為什麼還要用spring框架?

Spring中的JdbcTemplate操作

Spring-通過mybatis操作資料庫

Java操作資料庫Spring（1）

Spring 使用 JdbcTemplate 操作資料庫

一、搭建工程

二、相關配置細節

三、其它細節相關

四、成果測試驗證

相關推薦