查看: 170|回复: 0

[Java学习] Spring Boot中使用JDBC Templet的方法教程

发表于 4 天前

前言

Spring 的 JDBC Templet 是 Spring 对 JDBC 使用的一个基本的封装。他主要是帮助程序员实现了数据库连接的管理,其余的使用方式和直接使用 JDBC 没有什么大的区别。

业务需求

JDBC 的使用大家都比较熟悉了。这里主要为了演示在 SpringBoot 中使用 Spring JDBC Templet 的步骤,所以我们就设计一个简单的需求。一个用户对象的 CURD 的操作。对象有两个属性,一个属性是id,一个属性是名称。存储在 MySQL 的 auth_user 表里面。

新建项目和增加依赖

在 Intellij IDEA 里面新建一个空的 SpringBoot 项目。具体步骤参考
Intellij IDEA创建spring-boot项目的图文教程。根据本样例的需求,我们要添加下面三个依赖

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <dependency>
  6. <groupId>org.springframework.boot</groupId>
  7. <artifactId>spring-boot-starter-jdbc</artifactId>
  8. </dependency>
  9. <dependency>
  10. <groupId>mysql</groupId>
  11. <artifactId>mysql-connector-java</artifactId>
  12. <version>6.0.6</version>
  13. </dependency>
复制代码

因为要发布 Http Rest 的服务,所以添加 spring-boot-starter-web 依赖,这里我们要使用 JDBC Tempet 方法来访问数据库,所以添加了 spring-boot-starter-jdbc 依赖,要访问 MySQL 数据库,所以添加了 MySQL 最新版本的 JDBC 驱动程序。

准备数据库环境

假定在 Linux 操作系统上已经安装了 MySQL 5.7。以下操作都是在操作系统的命令行中,通过 root 用户登录到 MySQL 的命令行客户端中执行的。

建库建表

  1. create database springboot_jdbc;
  2. create table auth_user (uuid bigint not null,name varchar(32), primary key (uuid)) default charset=utf8mb4;
复制代码

设定用户权限

  1. grant all privileges on springboot_jdbc.* to 'springboot'@'%' identified by 'springboot';
  2. flush privileges;
复制代码

配置数据源(连接池)

SpringBoot 的数据源是自动配置的。在 SpringBoot 2.0 中,有几种数据源配置可选,他们按照 HikariCP -> Tomcat pooling -> Commons DBCP2 优先顺序来选择最后实际使用哪个数据源。

在项目加入 spring-boot-starter-jdbc 依赖的时候,就已经包括了 HikariCP 数据源的依赖,所以这里自动配置 HikariCP 连接池数据源。

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

  1. #通用数据源配置
  2. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  3. spring.datasource.url=jdbc:mysql://10.110.2.5:3306/spring-boot-jdbc?charset=utf8mb4&useSSL=false
  4. spring.datasource.username=springboot
  5. spring.datasource.password=springboot
  6. # Hikari 数据源专用配置
  7. spring.datasource.hikari.maximum-pool-size=20
  8. spring.datasource.hikari.minimum-idle=5
复制代码

其中 Hikari 数据源的大部分配置如下图。每个配置代表的含义可以自行查询一下

程序开发

用户数据库实体

根据需求,对应的用户数据实体有两个属性,一个是 id ,一个是 name 。这是一个纯 POJO 对象。

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao;
  2. /**
  3. * 用户实体对象
  4. *
  5. * @author 杨高超
  6. * @since 2018-03-09
  7. */
  8. public class UserDO {
  9. private Long id;
  10. private String name;
  11. public Long getId() {
  12. return id;
  13. }
  14. public void setId(Long id) {
  15. this.id = id;
  16. }
  17. public String getName() {
  18. return name;
  19. }
  20. public void setName(String name) {
  21. this.name = name;
  22. }
  23. }
复制代码

通用的 Http Rest 返回对象

通常在 Http Rest 接口中,我们不仅想直接返回业务对象的内容,还要返回一些通用的信息,例如接口调用的结果,调用失败的时候返回的自定义文本消息等。那么我们就需要建立两个通用的 rest 返回对象,除了返回通用的接口调用结果和文本消息,一个包括一个单独的业务内容,一个包含一个持有多个业务内容的集合。具体定义如下

单独业务内容返回对象

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo;
  2. /**
  3. * 单个对象返回结果
  4. *
  5. * @author 杨高超
  6. * @since 2018-03-09
  7. */
  8. public class RestItemResult<T> {
  9. private String result;
  10. private String message;
  11. private T item;
  12. public String getResult() {
  13. return result;
  14. }
  15. public void setResult(String result) {
  16. this.result = result;
  17. }
  18. public String getMessage() {
  19. return message;
  20. }
  21. public void setMessage(String message) {
  22. this.message = message;
  23. }
  24. public T getItem() {
  25. return item;
  26. }
  27. public void setItem(T item) {
  28. this.item = item;
  29. }
  30. }
复制代码

集合业务内容返回对象

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo;
  2. import java.util.Collection;
  3. /**
  4. * 集合对象返回结果
  5. *
  6. * @author 杨高超
  7. * @since 2018-03-09
  8. */
  9. public class RestCollectionResult<T> {
  10. private String result;
  11. private String message;
  12. private Collection<T> items;
  13. public String getResult() {
  14. return result;
  15. }
  16. public void setResult(String result) {
  17. this.result = result;
  18. }
  19. public String getMessage() {
  20. return message;
  21. }
  22. public void setMessage(String message) {
  23. this.message = message;
  24. }
  25. public Collection<T> getItems() {
  26. return items;
  27. }
  28. public void setItems(Collection<T> items) {
  29. this.items = items;
  30. }
  31. }
复制代码

数据持久层开发

用户数据持久层接口定义

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.dao;
  2. import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
  3. import java.util.List;
  4. /**
  5. * 用户数据层接口
  6. *
  7. * @author 杨高超
  8. * @since 2018-03-09
  9. */
  10. public interface UserDao {
  11. /**
  12. * 向数据库中保存一个新用户
  13. *
  14. * @param user 要保存的用户对象
  15. * @return 是否增肌成功
  16. */
  17. Boolean add(UserDO user);
  18. /**
  19. * 更新数据库中的一个用户
  20. *
  21. * @param user 要更新的用户对象
  22. * @return 是否更新成功
  23. */
  24. Boolean update(UserDO user);
  25. /**
  26. * 删除一个指定的用户
  27. *
  28. * @param id 要删除的用户的标识
  29. * @return 是否删除成功
  30. */
  31. boolean delete(Long id);
  32. /**
  33. * 精确查询一个指定的用户
  34. *
  35. * @param id 要查询的用户的标识
  36. * @return 如果能够查询到,返回用户信息,否则返回 null
  37. */
  38. UserDO locate(Long id);
  39. /**
  40. * 通过名称模糊查询用户
  41. *
  42. * @param name 要模糊查询的名称
  43. * @return 查询到的用户列表
  44. */
  45. List<UserDO> matchName(String name);
  46. }
复制代码

用户数据持久层实现

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.dao.impl;
  2. import com.yanggaochao.springboot.learn.springbootjdbclearn.dao.UserDao;
  3. import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import org.springframework.jdbc.support.rowset.SqlRowSet;
  7. import org.springframework.stereotype.Repository;
  8. import java.util.ArrayList;
  9. import java.util.List;
  10. /**
  11. * 用户对象数据库访问实现类
  12. *
  13. * @author 杨高超
  14. * @since 2018-03-09
  15. */
  16. @Repository
  17. public class UserDaoJDBCTempletImpl implements UserDao {
  18. private final JdbcTemplate jdbcTemplate;
  19. @Autowired
  20. public UserDaoJDBCTempletImpl(JdbcTemplate jdbcTemplate) {
  21. this.jdbcTemplate = jdbcTemplate;
  22. }
  23. @Override
  24. public Boolean add(UserDO user) {
  25. String sql = "INSERT INTO AUTH_USER(UUID,NAME) VALUES(?,?)";
  26. return jdbcTemplate.update(sql, user.getId(), user.getName()) > 0;
  27. }
  28. @Override
  29. public Boolean update(UserDO user) {
  30. String sql = "UPDATE AUTH_USER SET NAME = ? WHERE UUID = ?";
  31. return jdbcTemplate.update(sql, user.getName(), user.getId()) > 0;
  32. }
  33. @Override
  34. public boolean delete(Long id) {
  35. String sql = "DELETE FROM AUTH_USER WHERE UUID = ?";
  36. return jdbcTemplate.update(sql, id) > 0;
  37. }
  38. @Override
  39. public UserDO locate(Long id) {
  40. String sql = "SELECT * FROM AUTH_USER WHERE UUID=?";
  41. SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, id);
  42. if (rs.next()) {
  43. return generateEntity(rs);
  44. }
  45. return null;
  46. }
  47. @Override
  48. public List<UserDO> matchName(String name) {
  49. String sql = "SELECT * FROM AUTH_USER WHERE NAME LIKE ?";
  50. SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, "%" + name + "%");
  51. List<UserDO> users = new ArrayList<>();
  52. while (rs.next()) {
  53. users.add(generateEntity(rs));
  54. }
  55. return users;
  56. }
  57. private UserDO generateEntity(SqlRowSet rs) {
  58. UserDO weChatPay = new UserDO();
  59. weChatPay.setId(rs.getLong("UUID"));
  60. weChatPay.setName(rs.getString("NAME"));
  61. return weChatPay;
  62. }
  63. }
复制代码

这里首先用一个注解 @Repository 表示这是一个数据持久层的类,SpringBoot 将自动将这个类实例化。然后在构造函数上增加一个 @Autowired ,SpringBoot 在实例化这个类的时候,会自动将 JDBCTemplet 实例注入到这个类里面。这里 JDBCTemplet 实例是 SpringBoot 根据 applications.properties 中数据源相关的配置自动配置出来的。按照 SpringBoot 自动配置数据源的算法,这里将会配置的数据源是 HikariCP。

剩下的则和普通的 Spring JDBCTemplet 开发一样,通过程序员手动在对象和数据库 SQL 之间进行转换,实现了用户的增加、修改、删除、模糊匹配、精确查询等功能。

数据业务层开发

数据业务层接口定义

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.service;
  2. import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
  3. import java.util.List;
  4. /**
  5. * 用户服务层接口
  6. *
  7. * @author 杨高超
  8. * @since 2018-03-09
  9. */
  10. public interface UserService {
  11. UserDO add(UserDO user);
  12. UserDO update(UserDO user);
  13. boolean delete(Long id);
  14. UserDO locate(Long id);
  15. List<UserDO> matchName(String name);
  16. }
复制代码

数据业务层实现

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.service.impl;
  2. import com.yanggaochao.springboot.learn.springbootjdbclearn.dao.UserDao;
  3. import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
  4. import com.yanggaochao.springboot.learn.springbootjdbclearn.service.UserService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7. import java.util.Date;
  8. import java.util.List;
  9. /**
  10. * 用户业务层实现类
  11. *
  12. * @author 杨高超
  13. * @since 2018-03-09
  14. */
  15. @Service
  16. public class UserServiceImpl implements UserService {
  17. private final UserDao userDao;
  18. @Autowired
  19. public UserServiceImpl(UserDao userDao) {
  20. this.userDao = userDao;
  21. }
  22. @Override
  23. public UserDO add(UserDO user) {
  24. user.setId(new Date().getTime());
  25. if (userDao.add(user)) {
  26. return user;
  27. }
  28. return null;
  29. }
  30. @Override
  31. public UserDO update(UserDO user) {
  32. if (userDao.update(user)) {
  33. return locate(user.getId());
  34. }
  35. return null;
  36. }
  37. @Override
  38. public boolean delete(Long id) {
  39. return userDao.delete(id);
  40. }
  41. @Override
  42. public UserDO locate(Long id) {
  43. return userDao.locate(id);
  44. }
  45. @Override
  46. public List<UserDO> matchName(String name) {
  47. return userDao.matchName(name);
  48. }
  49. }
复制代码

这里通过一个 @Service 注解声明这个实现类是一个业务层的类。持久层的 UserDao 通过 @Autowired 让 SpringBoot 实例化这个业务层类的时候,自动将对应的持久层类注入到这个业务类中。

这里在增加用户对象的时候,给用户设定标识的时候,简单的用了一个当前时间的毫秒数作为标识。实际开发的过程中,这个地方需要用一个保证全局唯一的机制来保证这个标识不能重复。

对外服务层开发

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn.web;
  2. import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo.RestCollectionResult;
  3. import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo.RestItemResult;
  4. import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;
  5. import com.yanggaochao.springboot.learn.springbootjdbclearn.service.UserService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.*;
  8. import java.util.List;
  9. /**
  10. * 用户 Http Rest 接口
  11. *
  12. * @author 杨高超
  13. * @since 2018-03-09
  14. */
  15. @RestController
  16. @RequestMapping("api/v1/user")
  17. public class UserApi {
  18. @Autowired
  19. private UserService userService;
  20. @RequestMapping(value = "/add", method = RequestMethod.POST)
  21. public RestItemResult<UserDO> add(@RequestBody UserDO user) {
  22. RestItemResult<UserDO> result = new RestItemResult<>();
  23. user = userService.add(user);
  24. if (user != null) {
  25. result.setItem(user);
  26. result.setResult("success");
  27. } else {
  28. result.setMessage("新增用户失败");
  29. result.setResult("failure");
  30. }
  31. return result;
  32. }
  33. @RequestMapping(value = "/update", method = RequestMethod.POST)
  34. public RestItemResult<UserDO> update(@RequestBody UserDO user) {
  35. RestItemResult<UserDO> result = new RestItemResult<>();
  36. user = userService.update(user);
  37. if (user != null) {
  38. result.setItem(user);
  39. result.setResult("success");
  40. } else {
  41. result.setMessage("修改用户失败");
  42. result.setResult("failure");
  43. }
  44. return result;
  45. }
  46. @RequestMapping(value = "/delete/{uuid}", method = RequestMethod.GET)
  47. public RestItemResult<UserDO> delete(@PathVariable Long uuid) {
  48. RestItemResult<UserDO> result = new RestItemResult<>();
  49. if (userService.delete(uuid)) {
  50. result.setResult("success");
  51. } else {
  52. result.setMessage("删除用户失败");
  53. result.setResult("failure");
  54. }
  55. return result;
  56. }
  57. @RequestMapping(value = "/locate/{uuid}", method = RequestMethod.GET)
  58. public RestItemResult<UserDO> locate(@PathVariable Long uuid) {
  59. RestItemResult<UserDO> result = new RestItemResult<>();
  60. UserDO user = userService.locate(uuid);
  61. if (user != null) {
  62. result.setItem(user);
  63. result.setResult("success");
  64. } else {
  65. result.setMessage("查询用户失败");
  66. result.setResult("failure");
  67. }
  68. return result;
  69. }
  70. @RequestMapping(value = "/match/{name}", method = RequestMethod.GET)
  71. public RestCollectionResult<UserDO> match(@PathVariable String name) {
  72. RestCollectionResult<UserDO> result = new RestCollectionResult<>();
  73. List<UserDO> users = userService.matchName(name);
  74. result.setItems(users);
  75. result.setResult("success");
  76. return result;
  77. }
  78. }
复制代码

这里 @RestController 用来声明这是一个 Http Rest 接口类。通过类上的 @RequestMapping 和方法上的 @RequestMapping组合形成每个接口的调用路由。方法上的 @RequestMapping 中的 method 属性声明了 http 调用的方法。 @RequestBody 注解自动将 post 数据中的 json 对象转成 POJO 对象。@PathVariable 将 http url 路径中的数据自动转换成为服务方法的参数。

Http Rest 接口测试

测试通过 Apache commons的 HttpClient 来调用 Http Rest 服务。

Http Resst 调用辅助类

  1. package com.yanggaochao.springboot.learn.springbootjdbclearn;
  2. import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
  3. import org.apache.commons.httpclient.HttpClient;
  4. import org.apache.commons.httpclient.methods.GetMethod;
  5. import org.apache.commons.httpclient.methods.PostMethod;
  6. import org.apache.commons.httpclient.methods.StringRequestEntity;
  7. import org.apache.commons.httpclient.params.HttpMethodParams;
  8. import java.io.BufferedReader;
  9. import java.io.InputStream;
  10. import java.io.InputStreamReader;
  11. import java.io.Reader;
  12. import java.util.Map;
  13. /**
  14. * @author 杨高超
  15. * @since 2018-03-09
  16. */
  17. public class HttpClientHelper {
  18. /**
  19. * 用 get 方法发起一个http请求
  20. *
  21. * @param url 要访问的 http 的 url
  22. * @return 访问 http 后得到的回应文本
  23. */
  24. public String httpGetRequest(String url, Map<String, String> headers) {
  25. try {
  26. HttpClient httpclient = new HttpClient();
  27. GetMethod method = new GetMethod(url);
  28. method.setRequestHeader("Content-Type", "application/json; charset=utf-8");
  29. method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
  30. new DefaultHttpMethodRetryHandler(3, false));
  31. if (headers != null) {
  32. for (String key : headers.keySet()) {
  33. method.setRequestHeader(key, headers.get(key));
  34. }
  35. }
  36. int statusCode = httpclient.executeMethod(method);
  37. if (statusCode == 200) {
  38. return parseInputStream(method.getResponseBodyAsStream());
  39. } else {
  40. System.out.println(url + " status = " + statusCode);
  41. }
  42. } catch (Exception e) {
  43. e.printStackTrace();
  44. }
  45. return null;
  46. }
  47. /**
  48. * 用 post 方法发起一个 http 请求
  49. *
  50. * @param url 要访问的 http 的 url
  51. * @param data post 请求中的 data 数据
  52. * @return 访问 http 后得到的回应文本
  53. */
  54. public String httpPostRequest(String url, String data, Map<String, String> headers) {
  55. try {
  56. HttpClient httpclient = new HttpClient();
  57. PostMethod method = new PostMethod(url);
  58. method.setRequestHeader("Content-Type",
  59. "application/json;charset=UTF-8");
  60. 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");
  61. if (headers != null) {
  62. for (String key : headers.keySet()) {
  63. method.setRequestHeader(key, headers.get(key));
  64. }
  65. }
  66. method.setRequestEntity(new StringRequestEntity(data, "json", "utf-8"));
  67. int statusCode = httpclient.executeMethod(method);
  68. if (statusCode == 200) {
  69. return parseInputStream(method.getResponseBodyAsStream());
  70. } else {
  71. System.out.println(url + " status = " + statusCode + parseInputStream(method.getResponseBodyAsStream()));
  72. }
  73. } catch (Exception e) {
  74. e.printStackTrace();
  75. }
  76. return null;
  77. }
  78. /**
  79. * 从 java.io.Reader 中解析文本数据
  80. *
  81. * @param rd java.io.Reader 对象
  82. * @throws Exception 发生错误时抛出异常
  83. */
  84. private String parseReader(Reader rd) throws Exception {
  85. BufferedReader brd = new BufferedReader(rd);
  86. String line;
  87. StringBuilder respongseContext = new StringBuilder();
  88. while ((line = brd.readLine()) != null) {
  89. respongseContext.append(line).append("\n");
  90. }
  91. //rd.close();
  92. if (respongseContext.length() > 0) {
  93. respongseContext.deleteCharAt(respongseContext.length() - 1);
  94. }
  95. return respongseContext.toString();
  96. }
  97. /**
  98. * 从输入流中解析文本数据
  99. *
  100. * @param is 输入流
  101. * @throws Exception 发生错误时抛出异常
  102. */
  103. private String parseInputStream(InputStream is) throws Exception {
  104. return parseReader(new BufferedReader(new InputStreamReader(is)));
  105. }
  106. }
复制代码

这里主要是实现了用 GET 和 POST 方法调用 Http Rest 服务的方法。

测试用例

采用 JUnit 来执行测试用例。为了实现测试,我们额外增加了下面的 maven 依赖

  1. <dependency>
  2. <groupId>commons-httpclient</groupId>
  3. <artifactId>commons-httpclient</artifactId>
  4. <version>3.1</version>
  5. <scope>test</scope>
  6. </dependency>
  7. <dependency>
  8. <groupId>org.codehaus.jettison</groupId>
  9. <artifactId>jettison</artifactId>
  10. <version>1.3.3</version>
  11. <scope>test</scope>
  12. </dependency>
复制代码
  1. package com.yanggaochao.springboot.learn.springbootjdbclearn;
  2. import org.codehaus.jettison.json.JSONObject;
  3. import org.junit.After;
  4. import org.junit.Before;
  5. import org.junit.Test;
  6. import java.net.URLEncoder;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. /**
  10. * Description:
  11. *
  12. * @author 杨高超
  13. * @since 2018-03-09
  14. */
  15. public class UserApiTest {
  16. private String userAddUrl = "http://localhost:3030/security/api/v1/user/add";
  17. private String userLocateUrl = "http://localhost:3030/security/api/v1/user/locate/";
  18. private String userDeleteUrl = "http://localhost:3030/security/api/v1/user/delete/";
  19. private String userUpdateUrl = "http://localhost:3030/security/api/v1/user/update";
  20. private String userMatchUrl = "http://localhost:3030/security/api/v1/user/match/";
  21. JSONObject addUser = new JSONObject();
  22. Long addUserId = null;
  23. List<Long> userIds = new ArrayList<>();
  24. @Before
  25. public void before() throws Exception {
  26. addUser.put("name", "美羊羊");
  27. JSONObject addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, addUser.toString(), null));
  28. assert ("success".equals(addResultJson.getString("result")));
  29. addUserId = addResultJson.getJSONObject("item").getLong("id");
  30. JSONObject user = new JSONObject();
  31. user.put("name", "喜羊羊");
  32. addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, user.toString(), null));
  33. assert ("success".equals(addResultJson.getString("result")));
  34. userIds.add(addResultJson.getJSONObject("item").getLong("id"));
  35. user.put("name", "灰太狼");
  36. addResultJson = new JSONObject(new HttpClientHelper().httpPostRequest(userAddUrl, user.toString(), null));
  37. assert ("success".equals(addResultJson.getString("result")));
  38. userIds.add(addResultJson.getJSONObject("item").getLong("id"));
  39. }
  40. @Test
  41. public void testUpdateUser() throws Exception {
  42. JSONObject user = new JSONObject();
  43. user.put("name", "霉羊羊");
  44. user.put("id", addUserId);
  45. new HttpClientHelper().httpPostRequest(userUpdateUrl, user.toString(), null);
  46. JSONObject locateResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userLocateUrl + addUserId, null));
  47. assert (user.getString("name").equals(locateResultJson.getJSONObject("item").getString("name")));
  48. }
  49. @Test
  50. public void testMatchUser() throws Exception {
  51. JSONObject matchResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userMatchUrl + URLEncoder.encode("羊","UTF-8"), null));
  52. assert (matchResultJson.has("items") && matchResultJson.getJSONArray("items").length() == 2);
  53. matchResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userMatchUrl + URLEncoder.encode("狼","UTF-8"), null));
  54. assert (matchResultJson.has("items") && matchResultJson.getJSONArray("items").length() == 1);
  55. }
  56. @After
  57. public void after() throws Exception {
  58. if (addUserId != null) {
  59. JSONObject deleteResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userDeleteUrl + addUserId, null));
  60. assert ("success".equals(deleteResultJson.getString("result")));
  61. }
  62. for (Long userId : userIds) {
  63. JSONObject deleteResultJson = new JSONObject(new HttpClientHelper().httpGetRequest(userDeleteUrl + userId, null));
  64. assert ("success".equals(deleteResultJson.getString("result")));
  65. }
  66. }
  67. }
复制代码

这里在 @test 声明了两个测试用例,一个测试了用户修改功能,一个测试了用户模糊查询功能。 @Before 声明了在执行每个测试用例之前要做的准备工作。这里首先往数据库中插入三条数据,同时也测试了数据的增加功能、精确查询的功能。@After 声明了执行每个测试用例后的清理工作。这里主要是将之前插入的数据给删除了。这里同步测试了用户删除的功能。

后记

这里就展示了一个完整的 SpringBoot 使用 JDBC Templet 的完整样例。如果有在 Spring 下使用 JDBC Templet 的经历,那么在 Spring 里面主要是减少了很多配置的工作。

本文涉及的代码已经上传到 GitHUB 上,大家也可以通过本地下载

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对程序员之家的支持。



回复

使用道具 举报