SpringBoot 中使用 JDBC Templet

前言

Spring 的 JDBC Templet 是 Spring 對 JDBC 使用的一個基本的封裝。他主要是幫助程式設計師實現了資料庫連線的管理，其餘的使用方式和直接使用 JDBC 沒有什麼大的區別。

業務需求

JDBC 的使用大家都比較熟悉了。這裡主要為了演示在 SpringBoot 中使用 Spring JDBC Templet 的步驟，所以我們就設計一個簡單的需求。一個使用者物件的 CURD 的操作。物件有兩個屬性，一個屬性是id，一個屬性是名稱。儲存在 MySQL 的 auth_user 表裡面。

新建專案和增加依賴

在 Intellij IDEA 裡面新建一個空的 SpringBoot 專案。具體步驟參考 SpringBoot 的第一次邂逅。根據本樣例的需求，我們要新增下面三個依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>6.0.6</version>
</dependency>
複製程式碼

因為要釋出 Http Rest 的服務，所以新增 spring-boot-starter-web 依賴，這裡我們要使用 JDBC Tempet 方法來訪問資料庫，所以新增了 spring-boot-starter-jdbc 依賴，要訪問 MySQL 資料庫，所以新增了 MySQL 最新版本的 JDBC 驅動程式。

準備資料庫環境

假定在 Linux 作業系統上已經安裝了 MySQL 5.7。以下操作都是在作業系統的命令列中，通過 root 使用者登入到 MySQL 的命令列客戶端中執行的。

建庫建表

create database springboot_jdbc;

create table auth_user (uuid bigint not null,name varchar(32), primary key (uuid)) default charset=utf8mb4;
複製程式碼

設定使用者許可權

grant all privileges on springboot_jdbc.* to 'springboot'@'%' identified by 'springboot';

flush privileges;
複製程式碼

配置資料來源（連線池）

SpringBoot 的資料來源是自動配置的。在 SpringBoot 2.0 中，有幾種資料來源配置可選，他們按照 HikariCP -> Tomcat pooling -> Commons DBCP2 優先順序來選擇最後實際使用哪個資料來源。

在專案加入 spring-boot-starter-jdbc 依賴的時候，就已經包括了 HikariCP 資料來源的依賴，所以這裡自動配置 HikariCP 連線池資料來源。

在 appplications.properties 中增加如下的配置

#通用資料來源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://10.110.2.5:3306/spring-boot-jdbc?charset=utf8mb4&useSSL=false
spring.datasource.username=springboot
spring.datasource.password=springboot
# Hikari 資料來源專用配置
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
複製程式碼

其中 Hikari 資料來源的大部分配置如下圖。每個配置代表的含義可以自行查詢一下

程式開發

使用者資料庫實體

根據需求，對應的使用者資料實體有兩個屬性，一個是 id ，一個是 name 。這是一個純 POJO 物件。

package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao;

/**
 * 使用者實體物件
 *
 * @author 楊高超
 * @since 2018-03-09
 */
public class UserDO {
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
複製程式碼

通用的 Http Rest 返回物件

通常在 Http Rest 介面中，我們不僅想直接返回業務物件的內容，還要返回一些通用的資訊，例如介面呼叫的結果，呼叫失敗的時候返回的自定義文字訊息等。那麼我們就需要建立兩個通用的 rest 返回物件，除了返回通用的介面呼叫結果和文字訊息，一個包括一個單獨的業務內容，一個包含一個持有多個業務內容的集合。具體定義如下

單獨業務內容返回物件

package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo;

/**
 * 單個物件返回結果
 *
 * @author 楊高超
 * @since 2018-03-09
 */
public class RestItemResult<T> {
    private String result;
    private String message;
    private T item;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public T getItem() {
        return item;
    }

    public void setItem(T item) {
        this.item = item;
    }
}

複製程式碼

集合業務內容返回物件

package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo;

import java.util.Collection;

/**
 * 集合物件返回結果
 *
 * @author 楊高超
 * @since 2018-03-09
 */
public class RestCollectionResult<T> {
    private String result;
    private String message;
    private Collection<T> items;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Collection<T> getItems() {
        return items;
    }

    public void setItems(Collection<T> items) {
        this.items = items;
    }
}
複製程式碼

資料持久層開發

使用者資料持久層介面定義

package com.yanggaochao.springboot.learn.springbootjdbclearn.dao;

import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;

import java.util.List;

/**
 * 使用者資料層介面
 *
 * @author 楊高超
 * @since 2018-03-09
 */
public interface UserDao {
    /**
     * 向資料庫中儲存一個新使用者
     *
     * @param user 要儲存的使用者物件
     * @return 是否增肌成功
     */
    Boolean add(UserDO user);

    /**
     * 更新資料庫中的一個使用者
     *
     * @param user 要更新的使用者物件
     * @return 是否更新成功
     */
    Boolean update(UserDO user);

    /**
     * 刪除一個指定的使用者
     *
     * @param id 要刪除的使用者的標識
     * @return 是否刪除成功
     */
    boolean delete(Long id);

    /**
     * 精確查詢一個指定的使用者
     *
     * @param id 要查詢的使用者的標識
     * @return 如果能夠查詢到，返回使用者資訊，否則返回 null
     */
    UserDO locate(Long id);

    /**
     * 通過名稱模糊查詢使用者
     *
     * @param name 要模糊查詢的名稱
     * @return 查詢到的使用者列表
     */
    List<UserDO> matchName(String name);
}

複製程式碼

使用者資料持久層實現

package com.yanggaochao.springboot.learn.springbootjdbclearn.dao.impl;

import com.yanggaochao.springboot.learn.springbootjdbclearn.dao.UserDao;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;

/**
 * 使用者物件資料庫訪問實現類
 *
 * @author 楊高超
 * @since 2018-03-09
 */
@Repository
public class UserDaoJDBCTempletImpl implements UserDao {
    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public UserDaoJDBCTempletImpl(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Boolean add(UserDO user) {
        String sql = "INSERT INTO AUTH_USER(UUID,NAME) VALUES(?,?)";
        return jdbcTemplate.update(sql, user.getId(), user.getName()) > 0;
    }

    @Override
    public Boolean update(UserDO user) {
        String sql = "UPDATE AUTH_USER SET NAME = ? WHERE UUID = ?";
        return jdbcTemplate.update(sql, user.getName(), user.getId()) > 0;
    }

    @Override
    public boolean delete(Long id) {
        String sql = "DELETE FROM AUTH_USER WHERE UUID = ?";
        return jdbcTemplate.update(sql, id) > 0;

    }

    @Override
    public UserDO locate(Long id) {
        String sql = "SELECT * FROM AUTH_USER WHERE UUID=?";
        SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, id);

        if (rs.next()) {
            return generateEntity(rs);
        }
        return null;
    }

    @Override
    public List<UserDO> matchName(String name) {
        String sql = "SELECT * FROM AUTH_USER WHERE NAME LIKE ?";
        SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, "%" + name + "%");
        List<UserDO> users = new ArrayList<>();
        while (rs.next()) {
            users.add(generateEntity(rs));
        }
        return users;
    }

    private UserDO generateEntity(SqlRowSet rs) {
        UserDO weChatPay = new UserDO();
        weChatPay.setId(rs.getLong("UUID"));
        weChatPay.setName(rs.getString("NAME"));
        return weChatPay;
    }
}

複製程式碼

這裡首先用一個註解 @Repository 表示這是一個資料持久層的類，SpringBoot 將自動將這個類例項化。然後在建構函式上增加一個 @Autowired ，SpringBoot 在例項化這個類的時候，會自動將 JDBCTemplet 例項注入到這個類裡面。這裡 JDBCTemplet 例項是 SpringBoot 根據 applications.properties 中資料來源相關的配置自動配置出來的。按照 SpringBoot 自動配置資料來源的演算法，這裡將會配置的資料來源是 HikariCP。

剩下的則和普通的 Spring JDBCTemplet 開發一樣，通過程式設計師手動在物件和資料庫 SQL 之間進行轉換，實現了使用者的增加、修改、刪除、模糊匹配、精確查詢等功能。

資料業務層開發

資料業務層介面定義

package com.yanggaochao.springboot.learn.springbootjdbclearn.service;

import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;

import java.util.List;

/**
 * 使用者服務層介面
 *
 * @author 楊高超
 * @since 2018-03-09
 */
public interface UserService {
    
    UserDO add(UserDO user);

    UserDO update(UserDO user);

    boolean delete(Long id);

    UserDO locate(Long id);

    List<UserDO> matchName(String name);
}

複製程式碼

資料業務層實現

package com.yanggaochao.springboot.learn.springbootjdbclearn.service.impl;

import com.yanggaochao.springboot.learn.springbootjdbclearn.dao.UserDao;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import com.yanggaochao.springboot.learn.springbootjdbclearn.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

/**
 * 使用者業務層實現類
 *
 * @author 楊高超
 * @since 2018-03-09
 */
@Service
public class UserServiceImpl implements UserService {
    private final UserDao userDao;

    @Autowired
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public UserDO add(UserDO user) {
        user.setId(new Date().getTime());
        if (userDao.add(user)) {
            return user;
        }
        return null;
    }

    @Override
    public UserDO update(UserDO user) {
        if (userDao.update(user)) {
            return locate(user.getId());
        }
        return null;
    }

    @Override
    public boolean delete(Long id) {
        return userDao.delete(id);
    }

    @Override
    public UserDO locate(Long id) {
        return userDao.locate(id);
    }

    @Override
    public List<UserDO> matchName(String name) {
        return userDao.matchName(name);
    }
}

複製程式碼

這裡通過一個 @Service 註解宣告這個實現類是一個業務層的類。持久層的 UserDao 通過 @Autowired 讓 SpringBoot 例項化這個業務層類的時候，自動將對應的持久層類注入到這個業務類中。

這裡在增加使用者物件的時候，給使用者設定標識的時候，簡單的用了一個當前時間的毫秒數作為標識。實際開發的過程中，這個地方需要用一個保證全域性唯一的機制來保證這個標識不能重複。

對外服務層開發

package com.yanggaochao.springboot.learn.springbootjdbclearn.web;

import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo.RestCollectionResult;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo.RestItemResult;
import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
import com.yanggaochao.springboot.learn.springbootjdbclearn.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 使用者 Http Rest 介面
 *
 * @author 楊高超
 * @since 2018-03-09
 */
@RestController
@RequestMapping("api/v1/user")
public class UserApi {
    @Autowired
    private UserService userService;

    @RequestMapping(value = "/add", method = RequestMethod.POST)
    public RestItemResult<UserDO> add(@RequestBody UserDO user) {
        RestItemResult<UserDO> result = new RestItemResult<>();
        user = userService.add(user);
        if (user != null) {
            result.setItem(user);
            result.setResult("success");
        } else {
            result.setMessage("新增使用者失敗");
            result.setResult("failure");
        }
        return result;
    }

    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public RestItemResult<UserDO> update(@RequestBody UserDO user) {
        RestItemResult<UserDO> result = new RestItemResult<>();
        user = userService.update(user);
        if (user != null) {
            result.setItem(user);
            result.setResult("success");
        } else {
            result.setMessage("修改使用者失敗");
            result.setResult("failure");
        }
        return result;
    }

    @RequestMapping(value = "/delete/{uuid}", method = RequestMethod.GET)
    public RestItemResult<UserDO> delete(@PathVariable Long uuid) {
        RestItemResult<UserDO> result = new RestItemResult<>();
        if (userService.delete(uuid)) {
            result.setResult("success");
        } else {
            result.setMessage("刪除使用者失敗");
            result.setResult("failure");
        }
        return result;
    }

    @RequestMapping(value = "/locate/{uuid}", method = RequestMethod.GET)
    public RestItemResult<UserDO> locate(@PathVariable Long uuid) {
        RestItemResult<UserDO> result = new RestItemResult<>();
        UserDO user = userService.locate(uuid);
        if (user != null) {
            result.setItem(user);
            result.setResult("success");
        } else {
            result.setMessage("查詢使用者失敗");
            result.setResult("failure");
        }
        return result;
    }

    @RequestMapping(value = "/match/{name}", method = RequestMethod.GET)
    public RestCollectionResult<UserDO> match(@PathVariable String name) {
        RestCollectionResult<UserDO> result = new RestCollectionResult<>();
        List<UserDO> users = userService.matchName(name);
        result.setItems(users);
        result.setResult("success");
        return result;
    }
}
複製程式碼

這裡 @RestController 用來宣告這是一個 Http Rest 介面類。通過類上的 @RequestMapping 和方法上的 @RequestMapping組合形成每個介面的呼叫路由。方法上的 @RequestMapping 中的 method 屬性宣告瞭 http 呼叫的方法。 @RequestBody 註解自動將 post 資料中的 json 物件轉成 POJO 物件。@PathVariable 將 http url 路徑中的資料自動轉換成為服務方法的引數。

Http Rest 介面測試

測試通過 Apache commons的 HttpClient 來呼叫 Http Rest 服務。

Http Resst 呼叫輔助類

package com.yanggaochao.springboot.learn.springbootjdbclearn;

import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.httpclient.params.HttpMethodParams;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.Map;

/**
 * @author 楊高超
 * @since 2018-03-09
 */
public class HttpClientHelper {


    /**
     * 用 get 方法發起一個http請求
     *
     * @param url 要訪問的 http 的 url
     * @return 訪問 http 後得到的迴應文字
     */
    public String httpGetRequest(String url, Map<String, String> headers) {
        try {
            HttpClient httpclient = new HttpClient();
            GetMethod method = new GetMethod(url);
            method.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
                    new DefaultHttpMethodRetryHandler(3, false));
            if (headers != null) {
                for (String key : headers.keySet()) {
                    method.setRequestHeader(key, headers.get(key));
                }
            }

            int statusCode = httpclient.executeMethod(method);
            if (statusCode == 200) {
                return parseInputStream(method.getResponseBodyAsStream());
            } else {
                System.out.println(url + " status = " + statusCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 用 post 方法發起一個 http 請求
     *
     * @param url  要訪問的 http 的 url
     * @param data post 請求中的 data 資料
     * @return 訪問 http 後得到的迴應文字
     */

    public String httpPostRequest(String url, String data, Map<String, String> headers) {
        try {
            HttpClient httpclient = new HttpClient();
            PostMethod method = new PostMethod(url);
            method.setRequestHeader("Content-Type",
                    "application/json;charset=UTF-8");
            method.setRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.131 Safari/537.36");
            if (headers != null) {
                for (String key : headers.keySet()) {
                    method.setRequestHeader(key, headers.get(key));
                }
            }

            method.setRequestEntity(new StringRequestEntity(data, "json", "utf-8"));
            int statusCode = httpclient.executeMethod(method);
            if (statusCode == 200) {
                return parseInputStream(method.getResponseBodyAsStream());
            } else {
                System.out.println(url + " status = " + statusCode + parseInputStream(method.getResponseBodyAsStream()));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 從 java.io.Reader 中解析文字資料
     *
     * @param rd java.io.Reader 物件
     * @throws Exception 發生錯誤時丟擲異常
     */
    private String parseReader(Reader rd) throws Exception {
        BufferedReader brd = new BufferedReader(rd);
        String line;
        StringBuilder respongseContext = new StringBuilder();

        while ((line = brd.readLine()) != null) {
            respongseContext.append(line).append("\n");
        }
        //rd.close();
        if (respongseContext.length() > 0) {
            respongseContext.deleteCharAt(respongseContext.length() - 1);
        }
        return respongseContext.toString();
    }

    /**
     * 從輸入流中解析文字資料
     *
     * @param is 輸入流
     * @throws Exception 發生錯誤時丟擲異常
     */
    private String parseInputStream(InputStream is) throws Exception {
        return parseReader(new BufferedReader(new InputStreamReader(is)));
    }

}

複製程式碼

這裡主要是實現了用 GET 和 POST 方法呼叫 Http Rest 服務的方法。

測試用例

採用 JUnit 來執行測試用例。為了實現測試，我們額外增加了下面的 maven 依賴

<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.codehaus.jettison</groupId>
    <artifactId>jettison</artifactId>
    <version>1.3.3</version>
    <scope>test</scope>
</dependency>
複製程式碼

package com.yanggaochao.springboot.learn.springbootjdbclearn;

import org.codehaus.jettison.json.JSONObject;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;

/**
 * Description:
 *
 * @author 楊高超
 * @since 2018-03-09
 */
public class UserApiTest {
    private String userAddUrl = "http://localhost:3030/security/api/v1/user/add";
    private String userLocateUrl = "http://localhost:3030/security/api/v1/user/locate/";
    private String userDeleteUrl = "http://localhost:3030/security/api/v1/user/delete/";
    private String userUpdateUrl = "http://localhost:3030/security/api/v1/user/update";
    private String userMatchUrl = "http://localhost:3030/security/api/v1/user/match/";
    JSONObject addUser = new JSONObject();
    Long addUserId = null;

    List<Long> userIds = new ArrayList<>();

    @Before
    public void before() throws Exception {
        addUser.put("name", "美羊羊");
        JSONObject addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, addUser.toString(), null));
        assert ("success".equals(addResultJson.getString("result")));
        addUserId = addResultJson.getJSONObject("item").getLong("id");

        JSONObject user = new JSONObject();
        user.put("name", "喜羊羊");
        addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, user.toString(), null));
        assert ("success".equals(addResultJson.getString("result")));
        userIds.add(addResultJson.getJSONObject("item").getLong("id"));
        user.put("name", "灰太狼");
        addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, user.toString(), null));
        assert ("success".equals(addResultJson.getString("result")));
        userIds.add(addResultJson.getJSONObject("item").getLong("id"));
    }

    @Test
    public void testUpdateUser() throws Exception {
        JSONObject user = new JSONObject();
        user.put("name", "黴羊羊");
        user.put("id", addUserId);
        new HttpClientHelper().httpPostRequest(userUpdateUrl, user.toString(), null);
        JSONObject locateResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userLocateUrl + addUserId, null));
        assert (user.getString("name").equals(locateResultJson.getJSONObject("item").getString("name")));
    }


    @Test
    public void testMatchUser() throws Exception {
        JSONObject matchResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userMatchUrl + URLEncoder.encode("羊","UTF-8"), null));
        assert (matchResultJson.has("items") && matchResultJson.getJSONArray("items").length() == 2);
        matchResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userMatchUrl + URLEncoder.encode("狼","UTF-8"), null));
        assert (matchResultJson.has("items") && matchResultJson.getJSONArray("items").length() == 1);
    }

    @After
    public void after() throws Exception {
        if (addUserId != null) {
            JSONObject deleteResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userDeleteUrl + addUserId, null));
            assert ("success".equals(deleteResultJson.getString("result")));
        }

        for (Long userId : userIds) {
            JSONObject deleteResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userDeleteUrl + userId, null));
            assert ("success".equals(deleteResultJson.getString("result")));
        }
    }
}
複製程式碼

這裡在 @Test 宣告瞭兩個測試用例，一個測試了使用者修改功能，一個測試了使用者模糊查詢功能。 @Before 宣告瞭在執行每個測試用例之前要做的準備工作。這裡首先往資料庫中插入三條資料，同時也測試了資料的增加功能、精確查詢的功能。@After 宣告瞭執行每個測試用例後的清理工作。這裡主要是將之前插入的資料給刪除了。這裡同步測試了使用者刪除的功能。

後記

這裡就展示了一個完整的 SpringBoot 使用 JDBC Templet 的完整樣例。如果有在 Spring 下使用 JDBC Templet 的經歷，那麼在 Spring 裡面主要是減少了很多配置的工作。

本文涉及的程式碼已經上傳到 GitHUB 上。

原文發表於 簡書