如果您想了解SpringBoot与Kotlin使用JdbcTemplate连接MySQL数据库的方法的知识，那么本篇文章将是您的不二之选。同时我们将深入剖析Springboot+jdbcTemplat
如果您想了解Spring Boot 与 Kotlin 使用JdbcTemplate连接MySQL数据库的方法的知识，那么本篇文章将是您的不二之选。同时我们将深入剖析Spring boot + jdbcTemplate + MySQL实现增删改查、Spring Boot 2.x 基础教程：使用 JdbcTemplate 访问 MySQL 数据库、Spring Boot 2.x基础教程：使用JdbcTemplate访问MySQL数据库、Spring Boot 使用 SQL 关系型数据库-JdbcTemplate的各个方面，并给出实际的案例分析，希望能帮助到您！
本文目录一览：- Spring Boot 与 Kotlin 使用JdbcTemplate连接MySQL数据库的方法
- Spring boot + jdbcTemplate + MySQL实现增删改查
- Spring Boot 2.x 基础教程：使用 JdbcTemplate 访问 MySQL 数据库
- Spring Boot 2.x基础教程：使用JdbcTemplate访问MySQL数据库
- Spring Boot 使用 SQL 关系型数据库-JdbcTemplate
Spring Boot 与 Kotlin 使用JdbcTemplate连接MySQL数据库的方法
之前介绍了一些Web层的例子，包括构建RESTful API、使用Thymeleaf模板引擎渲染Web视图，但是这些内容还不足以
之前介绍了一些Web层的例子，包括构建RESTful API、使用Thymeleaf模板引擎渲染Web视图，但是这些内容还不足以构建一个动态的应用。通常我们做App也好，做Web应用也好，都需要内容，而内容通常存储于各种类型的数据库，服务端在接收到访问请求之后需要访问数据库获取并处理成展现给用户使用的数据形式。
本文介绍在Spring Boot基础下配置数据源和通过 JdbcTemplate 编写数据访问的示例。
数据源配置
在我们访问数据库的时候，需要先配置一个数据源，下面分别介绍一下几种不同的数据库配置方式。
首先，为了连接数据库需要引入jdbc支持，在 build.gradle 中引入如下配置：
compile "org.springframework.boot:spring-boot-starter-jdbc:$spring_boot_version"
连接数据源
以MysqL数据库为例，先引入MysqL连接的依赖包，在 build.gradle 中加入：
compile "MysqL:mysql-connector-java:$MysqL_version"
完整 build.gradle
group 'name.quanke.kotlin' version '1.0-SNAPSHOT' buildscript { ext.kotlin_version = '1.2.10' ext.spring_boot_version = '1.5.4.RELEASE' ext.springfox_swagger2_version = '2.7.0' ext.MysqL_version = '5.1.21' repositories { mavenCentral() } dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" classpath("org.springframework.boot:spring-boot-gradle-plugin:$spring_boot_version") // Kotlin整合SpringBoot的默认无参构造函数，默认把所有的类设置open类插件 classpath("org.jetbrains.kotlin:kotlin-noarg:$kotlin_version") classpath("org.jetbrains.kotlin:kotlin-allopen:$kotlin_version") } } apply plugin: 'kotlin' apply plugin: "kotlin-spring" // See https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-plugin apply plugin: 'org.springframework.boot' jar { baseName = 'chapter11-6-1-service' version = '0.1.0' } repositories { mavenCentral() } dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version" compile "org.springframework.boot:spring-boot-starter-web:$spring_boot_version" compile "org.springframework.boot:spring-boot-starter-jdbc:$spring_boot_version" compile "MysqL:mysql-connector-java:$MysqL_version" testCompile "org.springframework.boot:spring-boot-starter-test:$spring_boot_version" testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version" } compileKotlin { kotlinoptions.jvmTarget = "1.8" } compileTestKotlin { kotlinoptions.jvmTarget = "1.8" }
在 src/main/resources/application.yml 中配置数据源信息
spring: datasource: url: jdbc:MysqL://localhost:3306/test username: root password: 123456 driver-class-name: com.MysqL.jdbc.Driver
连接JNDI数据源
当你将应用部署于应用服务器上的时候想让数据源由应用服务器管理，那么可以使用如下配置方式引入JNDI数据源。
如果对JNDI不是很了解的，请参考 https://baike.baidu.com/item/JNDI/3792442?fr=aladdin
spring.datasource.jndi-name=java:jboss/datasources/customers
使用JdbcTemplate操作数据库
Spring的 JdbcTemplate 是自动配置的，你可以直接使用 @Autowired 来注入到你自己的bean中来使用。
举例：我们在创建 User 表，包含属性id,name、age，下面来编写数据访问对象和单元测试用例。
定义包含有插入、删除、查询的抽象接口UserService
interface UserService { /** * 获取用户总量 */ val allUsers: Int? /** * 新增一个用户 * @param name * @param age */ fun create(name: String, password: String?) /** * 根据name删除一个用户高 * @param name */ fun deleteByName(name: String) /** * 删除所有用户 */ fun deleteallUsers() }
通过 JdbcTemplate 实现 UserService 中定义的数据访问操作
import org.springframework.beans.factory.annotation.Autowired import org.springframework.jdbc.core.JdbcTemplate import org.springframework.stereotype.Service /** * Created by http://quanke.name on 2018/1/10. */ @Service class UserServiceImpl : UserService { @Autowired private val jdbcTemplate: JdbcTemplate? = null override val allUsers: Int? get() = jdbcTemplate!!.queryForObject("select count(1) from USER", Int::class.java) override fun create(name: String, password: String?) { jdbcTemplate!!.update("insert into USER(USERNAME, PASSWORD) values(?, ?)", name, password) } override fun deleteByName(name: String) { jdbcTemplate!!.update("delete from USER where USERNAME = ?", name) } override fun deleteallUsers() { jdbcTemplate!!.update("delete from USER") } }
创建对UserService的单元测试用例，通过创建、删除和查询来验证数据库操作的正确性。
/** * Created by http://quanke.name on 2018/1/9. */ @RunWith(springrunner::class) @SpringBoottest class ApplicationTests { val log = LogFactory.getLog(ApplicationTests::class.java)!! @Autowired lateinit var userService: UserService @Test fun `jdbc test"`() { val username = "quanke" val password = "123456" // 插入5个用户 userService.create("$username a", "$password 1") userService.create("$username b", "$password 2") userService.create("$username c", "$password 3") userService.create("$username d", "$password 4") userService.create("$username e", "$password 5") log.info("总共用户 ${userService.allUsers}") // 删除两个用户 userService.deleteByName("$username a") userService.deleteByName("$username b") log.info("总共用户 ${userService.allUsers}") } }
上面介绍的JdbcTemplate只是最基本的几个操作，更多其他数据访问操作的使用请参考：JdbcTemplate API
通过上面这个简单的例子，我们可以看到在Spring Boot下访问数据库的配置依然秉承了框架的初衷：简单。我们只需要在pom.xml中加入数据库依赖，再到application.yml中配置连接信息，不需要像Spring应用中创建JdbcTemplate的Bean，就可以直接在自己的对象中注入使用。
总结
以上所述是小编给大家介绍的Spring Boot 与 Kotlin 使用JdbcTemplate连接MysqL数据库的方法，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对小编网站的支持！
Spring boot + jdbcTemplate + MySQL实现增删改查
目录结构
数据库结构
1. 添加相关引用
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- 引入jdbc支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- 连接MySQL数据库 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 生成api文档 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.2.2</version>
</dependency>
</dependencies>
2. 在application.properties配置连接MySQL数据库
spring.datasource.url=jdbc:mysql://localhost:3306/test_db?serverTimezone=GMT%2B8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
3. 创建实体对象
Student.java
package com.hsl.springbootjdbctemplate.entity;
import java.io.Serializable;
public class Student {
private int id;
private String name;
private int sex;
private int age;
public Student() {
}
public Student(int id, String name, int sex, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
4. 定义接口
UserService.java
package com.hsl.springbootjdbctemplate.service;
import com.hsl.springbootjdbctemplate.entity.Student;
import java.util.List;
import java.util.Map;
public interface UserService {
/**
* 获取用户总量
* @return
*/
String getAllUsers();
/**
* 获取全部学生
* @return
*/
List<Map<String, Object>> findAll();
/**
* 根据id获取学生
* @param id
* @return
*/
Student getById(int id);
/**
* 增加学生
* @param student
* @return
*/
int addStu(Student student);
/**
* 根据id删除学生
* @param id
* @return
*/
int deleteStu(int id);
/**
* 修改学生信息
* @param student
* @return
*/
int updateStu(Student student);
/**
* 判断是否存在该学生
* @param id
* @return
*/
int isHasStu(int id);
}
5. 通过jdbcTemplate实现接口中定义的数据访问操作
UserServiceImpt.java
package com.hsl.springbootjdbctemplate.service;
import com.hsl.springbootjdbctemplate.entity.Student;
import com.sun.org.apache.bcel.internal.generic.LSTORE;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.swing.plaf.basic.BasicTreeUI;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
@Service
public class UserServiceImpt implements UserService {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public String getAllUsers(){
return jdbcTemplate.queryForObject("select count(1) from STUDENT", String.class);
}
@Override
public List<Map<String, Object>> findAll() {
String sql = "select * from sTUDENT";
List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
return list;
}
@Override
public Student getById(int id) {
String sql = "select * from student where id = ? ";
List<Student> stu = jdbcTemplate.query(sql,new Object[]{id}, new StudentRowMapper());
Student student = null;
if(!stu.isEmpty()){
student = stu.get(0);
}
return student;
}
/**
* 插入用户-防止sql注入-可以返回该条记录的主键
* @param student
* @return
*/
@Override
public int addStu(Student student) {
String sql = "insert into student(id,name,sex,age) values(null,?,?,?)";
KeyHolder keyHolder = new GeneratedKeyHolder();
int resRow = jdbcTemplate.update(new PreparedStatementCreator() {
@Override
public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
PreparedStatement ps = connection.prepareStatement(sql,new String[]{"id"});
ps.setString(1,student.getName());
ps.setInt(2,student.getSex());
ps.setInt(3,student.getAge());
return ps;
}
},keyHolder);
System.out.println("操作记录数："+resRow+" 主键："+keyHolder.getKey());
return Integer.parseInt(keyHolder.getKey().toString());
}
@Override
public int deleteStu(int id) {
String sql = "delete from student where id = ?";
return jdbcTemplate.update(sql,id);
}
@Override
public int updateStu(Student student) {
String sql = "update student set name=?,sex=?,age=? where id=?";
int res = jdbcTemplate.update(sql, new PreparedStatementSetter() {
@Override
public void setValues(PreparedStatement preparedStatement) throws SQLException {
preparedStatement.setString(1,student.getName());
preparedStatement.setInt(2,student.getSex());
preparedStatement.setInt(3,student.getAge());
preparedStatement.setInt(4,student.getId());
}
});
return res;
}
@Override
public int isHasStu(int id) {
String sql = "select * from student where id=?";
List<Student> student = jdbcTemplate.query(sql, new Object[]{id}, new StudentRowMapper());
if (student!=null && student.size()>0){
return 1;
} else {
return 0;
}
}
}
class StudentRowMapper implements RowMapper<Student> {
@Override
public Student mapRow(ResultSet resultSet,int i) throws SQLException{
Student stu = new Student();
stu.setId(resultSet.getInt("id"));
stu.setAge(resultSet.getInt("age"));
stu.setSex(resultSet.getInt("sex"));
stu.setName(resultSet.getString("name"));
return stu;
}
}
6. 定义controller
UserController.java
package com.hsl.springbootjdbctemplate.controller;
import com.hsl.springbootjdbctemplate.entity.Student;
import com.hsl.springbootjdbctemplate.service.UserService;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/users")
public class UserController {
@Autowired
private UserService service;
@ApiOperation(value = "获取用户总数",notes = "")
@RequestMapping(value = "/getAllUsers", method = RequestMethod.GET)
public String getAllUsers(){
return service.getAllUsers();
}
//http://127.0.0.1:8080/users/
@ApiOperation(value = "获取用户列表",notes = "")
@RequestMapping(value = "/", method = RequestMethod.GET)
public List<Map<String, Object>> findAll(){
List<Map<String, Object>> list = service.findAll();
return list;
}
//http://127.0.0.1:8080/users/1
@ApiOperation(value = "获取用户",notes = "根据用户id获取用户")
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
public Student getStuById(@PathVariable int id){
Student student = service.getById(id);
return student;
}
//http://127.0.0.1:8080/users/
@ApiOperation(value = "添加用户",notes = "添加用户")
@RequestMapping(value = "/", method = RequestMethod.POST)
public int addStu(Student student){
//System.out.println(student.getName());
int res = service.addStu(student);
return res;
}
@ApiOperation(value = "删除用户",notes = "根据用户Id删除用户")
@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
public int deleteStu(@PathVariable int id){
System.out.println(id);
int res = service.deleteStu(id);
return res;
}
@ApiOperation(value = "修改用户信息",notes = "根据用户Id修改用户信息")
@RequestMapping(value = "/", method = RequestMethod.PUT)
public int updateStu(Student student){
System.out.println(student.getId());
int isHas = service.isHasStu(student.getId());
int res = 0;
if (isHas==1){
res = service.updateStu(student);
}
return res;
}
}
7. 生成文档
在controller层新建Swagger2.java，并在UserController.java中添加注解@ApiOpeation(value="", notets="")
package com.hsl.springbootjdbctemplate.controller;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class Swagger2 {
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.hsl"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("使用jdbcTemplate的增删该查")
.description("第一个jdbcTemplate")
.termsOfServiceUrl("http://blog.didispace.com/")
.contact("LevineHua")
.version("1.0")
.build();
}
}
文档地址:http://127.0.0.1:8080/swagger-ui.html
效果：
8. 使用postman测试接口
8.1 获取用户列表
8.2 获取用户
8.3 获取用户总数
8.4 添加用户
8.5 修改用户
8.6 删除用户
Spring Boot 2.x 基础教程：使用 JdbcTemplate 访问 MySQL 数据库
在第 2 章节中，我们介绍了如何通过 Spring Boot 来实现 HTTP 接口，以及围绕 HTTP 接口相关的单元测试、文档生成等实用技能。但是，这些内容还不足以帮助我们构建一个动态应用的服务端程序。不论我们是要做 App、小程序、还是传统的 Web 站点，对于用户的信息、相关业务的内容，通常都需要对其进行存储，而不是像第 2 章节中那样，把用户信息存储在内存中（重启就丢了！）。
对于信息的存储，现在已经有非常非常多的产品可以选择，其中不乏许多非常优秀的开源免费产品，比如：MySQL，Redis 等。接下来，在第 3 章节，我们将继续学习在使用 Spring Boot 开发服务端程序的时候，如何实现对各流行数据存储产品的增删改查操作。
作为数据访问章节的第一篇，我们将从最为常用的关系型数据库开始。通过一个简单例子，学习在 Spring Boot 中最基本的数据访问工具：JdbcTemplate。
数据源配置
在我们访问数据库的时候，需要先配置一个数据源，下面分别介绍一下几种不同的数据库配置方式。
首先，为了连接数据库需要引入 jdbc 支持，在 pom.xml 中引入如下配置：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
嵌入式数据库支持
嵌入式数据库通常用于开发和测试环境，不推荐用于生产环境。Spring Boot 提供自动配置的嵌入式数据库有 H2、HSQL、Derby，你不需要提供任何连接配置就能使用。
比如，我们可以在 pom.xml 中引入如下配置使用 HSQL
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<scope>runtime</scope>
</dependency>
连接生产数据源
以 MySQL 数据库为例，先引入 MySQL 连接的依赖包，在 pom.xml 中加入：
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
在 src/main/resources/application.properties 中配置数据源信息
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
连接 JNDI 数据源
当你将应用部署于应用服务器上的时候想让数据源由应用服务器管理，那么可以使用如下配置方式引入 JNDI 数据源。
spring.datasource.jndi-name=java:jboss/datasources/customers
使用 JdbcTemplate 操作数据库
Spring 的 JdbcTemplate 是自动配置的，你可以直接使用 @Autowired 或构造函数（推荐）来注入到你自己的 bean 中来使用。
下面就来一起完成一个增删改查的例子：
准备数据库
先创建 User 表，包含属性 name、age。可以通过执行下面的建表语句：：
CREATE TABLE `User` (
`name` varchar(100) COLLATE utf8mb4_general_ci NOT NULL,
`age` int NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci
编写领域对象
根据数据库中创建的 User 表，创建领域对象：
@Data
@NoArgsConstructor
public class User {
private String name;
private Integer age;
}
这里使用了 Lombok 的 @Data 和 @NoArgsConstructor 注解来自动生成各参数的 Set、Get 函数以及不带参数的构造函数。如果您对 Lombok 还不了解，可以看看这篇文章：Java 开发神器 Lombok 的使用与原理。
编写数据访问对象
- 定义包含有插入、删除、查询的抽象接口 UserService
public interface UserService {
/**
* 新增一个用户
*
* @param name
* @param age
*/
int create(String name, Integer age);
/**
* 根据name查询用户
*
* @param name
* @return
*/
List<User> getByName(String name);
/**
* 根据name删除用户
*
* @param name
*/
int deleteByName(String name);
/**
* 获取用户总量
*/
int getAllUsers();
/**
* 删除所有用户
*/
int deleteAllUsers();
}
- 通过
JdbcTemplate实现UserService中定义的数据访问操作
@Service
public class UserServiceImpl implements UserService {
private JdbcTemplate jdbcTemplate;
UserServiceImpl(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public int create(String name, Integer age) {
return jdbcTemplate.update("insert into USER(NAME, AGE) values(?, ?)", name, age);
}
@Override
public List<User> getByName(String name) {
List<User> users = jdbcTemplate.query("select NAME, AGE from USER where NAME = ?", (resultSet, i) -> {
User user = new User();
user.setName(resultSet.getString("NAME"));
user.setAge(resultSet.getInt("AGE"));
return user;
}, name);
return users;
}
@Override
public int deleteByName(String name) {
return jdbcTemplate.update("delete from USER where NAME = ?", name);
}
@Override
public int getAllUsers() {
return jdbcTemplate.queryForObject("select count(1) from USER", Integer.class);
}
@Override
public int deleteAllUsers() {
return jdbcTemplate.update("delete from USER");
}
}
编写单元测试用例
- 创建对 UserService 的单元测试用例，通过创建、删除和查询来验证数据库操作的正确性。
@RunWith(SpringRunner.class)
@SpringBootTest
public class Chapter31ApplicationTests {
@Autowired
private UserService userSerivce;
@Before
public void setUp() {
// 准备，清空user表
userSerivce.deleteAllUsers();
}
@Test
public void test() throws Exception {
// 插入5个用户
userSerivce.create("Tom", 10);
userSerivce.create("Mike", 11);
userSerivce.create("Didispace", 30);
userSerivce.create("Oscar", 21);
userSerivce.create("Linda", 17);
// 查询名为Oscar的用户，判断年龄是否匹配
List<User> userList = userSerivce.getByName("Oscar");
Assert.assertEquals(21, userList.get(0).getAge().intValue());
// 查数据库，应该有5个用户
Assert.assertEquals(5, userSerivce.getAllUsers());
// 删除两个用户
userSerivce.deleteByName("Tom");
userSerivce.deleteByName("Mike");
// 查数据库，应该有5个用户
Assert.assertEquals(3, userSerivce.getAllUsers());
}
}
上面介绍的 JdbcTemplate 只是最基本的几个操作，更多其他数据访问操作的使用请参考：JdbcTemplate API
通过上面这个简单的例子，我们可以看到在 Spring Boot 下访问数据库的配置依然秉承了框架的初衷：简单。我们只需要在 pom.xml 中加入数据库依赖，再到 application.properties 中配置连接信息，不需要像 Spring 应用中创建 JdbcTemplate 的 Bean，就可以直接在自己的对象中注入使用。
代码示例
本文的相关例子可以查看下面仓库中的 chapter3-1 目录：
- Github：https://github.com/dyc87112/SpringBoot-Learning/
- Gitee：https://gitee.com/didispace/SpringBoot-Learning/
如果您觉得本文不错，欢迎 Star 支持，您的关注是我坚持的动力！
欢迎关注我的公众号：程序猿 DD，获得独家整理的学习资源和日常干货推送。 如果您对我的专题内容感兴趣，也可以关注我的博客：didispace.com
原文出处：https://www.cnblogs.com/didispace/p/12268102.html
Spring Boot 2.x基础教程：使用JdbcTemplate访问MySQL数据库
在第2章节中，我们介绍了如何通过Spring Boot来实现HTTP接口，以及围绕HTTP接口相关的单元测试、文档生成等实用技能。但是，这些内容还不足以帮助我们构建一个动态应用的服务端程序。不论我们是要做App、小程序、还是传统的Web站点，对于用户的信息、相关业务的内容，通常都需要对其进行存储，而不是像第2章节中那样，把用户信息存储在内存中（重启就丢了！）。
对于信息的存储，现在已经有非常非常多的产品可以选择，其中不乏许多非常优秀的开源免费产品，比如：MySQL，Redis等。接下来，在第3章节，我们将继续学习在使用Spring Boot开发服务端程序的时候，如何实现对各流行数据存储产品的增删改查操作。
作为数据访问章节的第一篇，我们将从最为常用的关系型数据库开始。通过一个简单例子，学习在Spring Boot中最基本的数据访问工具：JdbcTemplate。
数据源配置
在我们访问数据库的时候，需要先配置一个数据源，下面分别介绍一下几种不同的数据库配置方式。
首先，为了连接数据库需要引入jdbc支持，在pom.xml中引入如下配置：
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-jdbc</artifactid>
</dependency>
嵌入式数据库支持
嵌入式数据库通常用于开发和测试环境，不推荐用于生产环境。Spring Boot提供自动配置的嵌入式数据库有H2、HSQL、Derby，你不需要提供任何连接配置就能使用。
比如，我们可以在pom.xml中引入如下配置使用HSQL
<dependency>
<groupid>org.hsqldb</groupid>
<artifactid>hsqldb</artifactid>
<scope>runtime</scope>
</dependency>
连接生产数据源
以MySQL数据库为例，先引入MySQL连接的依赖包，在pom.xml中加入：
<dependency>
<groupid>mysql</groupid>
<artifactid>mysql-connector-java</artifactid>
<version>5.1.46</version>
</dependency>
在src/main/resources/application.properties中配置数据源信息
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
连接JNDI数据源
当你将应用部署于应用服务器上的时候想让数据源由应用服务器管理，那么可以使用如下配置方式引入JNDI数据源。
spring.datasource.jndi-name=java:jboss/datasources/customers
使用JdbcTemplate操作数据库
Spring的JdbcTemplate是自动配置的，你可以直接使用@Autowired或构造函数（推荐）来注入到你自己的bean中来使用。
下面就来一起完成一个增删改查的例子：
准备数据库
先创建User表，包含属性name、age。可以通过执行下面的建表语句：：
CREATE TABLE `User` (
`name` varchar(100) COLLATE utf8mb4_general_ci NOT NULL,
`age` int NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci
编写领域对象
根据数据库中创建的User表，创建领域对象：
@Data
@NoArgsConstructor
public class User {
private String name;
private Integer age;
}
这里使用了Lombok的@Data和@NoArgsConstructor注解来自动生成各参数的Set、Get函数以及不带参数的构造函数。如果您对Lombok还不了解，可以看看这篇文章：Java开发神器Lombok的使用与原理。
编写数据访问对象
- 定义包含有插入、删除、查询的抽象接口UserService
public interface UserService {
/**
* 新增一个用户
*
* @param name
* @param age
*/
int create(String name, Integer age);
/**
* 根据name查询用户
*
* @param name
* @return
*/
List<user> getByName(String name);
/**
* 根据name删除用户
*
* @param name
*/
int deleteByName(String name);
/**
* 获取用户总量
*/
int getAllUsers();
/**
* 删除所有用户
*/
int deleteAllUsers();
}
- 通过
JdbcTemplate实现UserService中定义的数据访问操作
@Service
public class UserServiceImpl implements UserService {
private JdbcTemplate jdbcTemplate;
UserServiceImpl(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public int create(String name, Integer age) {
return jdbcTemplate.update("insert into USER(NAME, AGE) values(?, ?)", name, age);
}
@Override
public List<user> getByName(String name) {
List<user> users = jdbcTemplate.query("select NAME, AGE from USER where NAME = ?", (resultSet, i) -> {
User user = new User();
user.setName(resultSet.getString("NAME"));
user.setAge(resultSet.getInt("AGE"));
return user;
}, name);
return users;
}
@Override
public int deleteByName(String name) {
return jdbcTemplate.update("delete from USER where NAME = ?", name);
}
@Override
public int getAllUsers() {
return jdbcTemplate.queryForObject("select count(1) from USER", Integer.class);
}
@Override
public int deleteAllUsers() {
return jdbcTemplate.update("delete from USER");
}
}
编写单元测试用例
- 创建对UserService的单元测试用例，通过创建、删除和查询来验证数据库操作的正确性。
@RunWith(SpringRunner.class)
@SpringBootTest
public class Chapter31ApplicationTests {
@Autowired
private UserService userSerivce;
@Before
public void setUp() {
// 准备，清空user表
userSerivce.deleteAllUsers();
}
@Test
public void test() throws Exception {
// 插入5个用户
userSerivce.create("Tom", 10);
userSerivce.create("Mike", 11);
userSerivce.create("Didispace", 30);
userSerivce.create("Oscar", 21);
userSerivce.create("Linda", 17);
// 查询名为Oscar的用户，判断年龄是否匹配
List<user> userList = userSerivce.getByName("Oscar");
Assert.assertEquals(21, userList.get(0).getAge().intValue());
// 查数据库，应该有5个用户
Assert.assertEquals(5, userSerivce.getAllUsers());
// 删除两个用户
userSerivce.deleteByName("Tom");
userSerivce.deleteByName("Mike");
// 查数据库，应该有5个用户
Assert.assertEquals(3, userSerivce.getAllUsers());
}
}
上面介绍的JdbcTemplate只是最基本的几个操作，更多其他数据访问操作的使用请参考：JdbcTemplate API
通过上面这个简单的例子，我们可以看到在Spring Boot下访问数据库的配置依然秉承了框架的初衷：简单。我们只需要在pom.xml中加入数据库依赖，再到application.properties中配置连接信息，不需要像Spring应用中创建JdbcTemplate的Bean，就可以直接在自己的对象中注入使用。
代码示例
本文的相关例子可以查看下面仓库中的chapter3-1目录：
- Github：https://github.com/dyc87112/SpringBoot-Learning/
- Gitee：https://gitee.com/didispace/SpringBoot-Learning/
如果您觉得本文不错，欢迎Star支持，您的关注是我坚持的动力！
欢迎关注我的公众号：程序猿DD，获得独家整理的学习资源和日常干货推送。如果您对我的专题内容感兴趣，也可以关注我的博客：didispace.com
Spring Boot 使用 SQL 关系型数据库-JdbcTemplate
一、 配置数据源：
嵌入式数据库的支持：Spring Boot 可以自动配置 H2, HSQL and Derby 数据库，不需要提供任何的
链接 URLs，只需要加入相应的jar 包，Spring boot 可以自动发现装配
<!-- 数据库 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
mysql 配置：
spring.datasource.url=jdbc:mysql://localhost/spring_boot_demo?useUnicode=true&character
Encoding=utf-8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
注：
1.可以不指定 driver-class-name，spring boot 会自动识别 url。
2.数据连接池默认使用 tomcat-jdbc
连接池的配置： spring.datasource.tomcat.*
二、 JdbcTemplate 模板
// 自动注册
@Autowired
private JdbcTemplate jdbcTemplate;
三、 脚本
CREATE TABLE `gus_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`create_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT=''用户表'';
四、实体类
/**
* 实体类
*
*/
public class GusUser {
private int id;
private String name;
private Date createTime;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
@Override
public String toString() {
return "RoncooUser [id=" + id + ", name=" + name + ", createTime=" + createTime
+ "]";
}
}
五、 接口
int insert(GusUser gusUser );
int deleteById(int id);
int updateById(GusUser gusUser );
GusUser selectById(int id);
六、实现类代码
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public int insert(GusUser gusUser) {
String sql = "insert into gus_user (name, create_time) values (?, ?)";
return jdbcTemplate.update(sql, gusUser.getName(),
gusUser.getCreateTime());
}
@Override
public int deleteById(int id) {
String sql = "delete from gus_user where id=?";
return jdbcTemplate.update(sql, id);
}
@Override
public int updateById(GusUser gusUser) {
String sql = "update gus_user set name=?, create_time=? where id=?";
return jdbcTemplate.update(sql, gusUser.getName(),
gusUser.getCreateTime(), gusUser.getId());
}
@Override
public GusUser selectById(int id) {
String sql = "select * from gus_user where id=?";
return jdbcTemplate.queryForObject(sql, new RowMapper<GusUser>() {
@Override
public GusUser mapRow(ResultSet rs, int rowNum) throws SQLException {
GusUser gusUser= new GusUser();
gusUser.setId(rs.getInt("id"));
gusUser.setName(rs.getString("name"));
gusUser.setCreateTime(rs.getDate("create_time"));
return gusUser;
}
}, id);
}
七、测试类代码
@Autowired
private GusUserDao gusUserDao;
@Test
public void insert() {
GusUser gusUser = new GusUser();
gusUser.setName("测试");
gusUser.setCreateTime(new Date());
int result = gusUserDao.insert(gusUser);
System.out.println(result);
}
@Test
public void delete() {
int result = gusUserDao.deleteById(1);
System.out.println(result);
}
@Test
public void update() {
GusUser gusUser= new GusUser();
gusUser.setId(2);
gusUser.setName("测试2");
gusUser.setCreateTime(new Date());
int result = gusUserDao.updateById(roncooUser);
System.out.println(result);
}
@Test
public void select() {
GusUser result = gusUserDao.selectById(2);
System.out.println(result);
}
}打印 sql 语句，添加如下
<logger name="org.springframework.jdbc.core.JdbcTemplate" level="debug"/>
八、封装 spring jdbc，带分页
/**
* 获取当前事务最后一次更新的主键值
*/
public Long getLastId() {
return jdbcTemplate.queryForObject("select last_insert_id() as id", Long.class);
}
/**
* 获取对象信息
*/
public <T> T queryForObject(String sql, Class<T> clazz, Object... args) {
Assert.hasText(sql, "sql 语句不能为空");
return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<T>(clazz), args);
}
/**
* 获取对象集合信息
*/
public <T> List<T> queryForObjectList(String sql, Class<T> clazz, Object... args) {
Assert.hasText(sql, "sql 语句不能为空");
return jdbcTemplate.query(sql, args, new BeanPropertyRowMapper<T>(clazz));
}
/**
* 分页，jdbcTemplate 不支持 like 自定义，只能拼装
*/
public Page<Map<String, Object>> queryForPage(String sql, int pageCurrent, int
pageSize, Object... args) {
Assert.hasText(sql, "sql 语句不能为空");
Assert.isTrue(pageCurrent >= 1, "pageNo 必须大于等于 1");
String sqlCount = Sql.countSql(sql);
int count = jdbcTemplate.queryForObject(sqlCount, Integer.class, args);
pageCurrent = Sql.checkPageCurrent(count, pageSize, pageCurrent);
pageSize = Sql.checkPageSize(pageSize);
int totalPage = Sql.countTotalPage(count, pageSize);
String sqlList = sql + Sql.limitSql(count, pageCurrent, pageSize);
List<Map<String, Object>> list = jdbcTemplate.queryForList(sqlList, args);
return new Page<Map<String, Object>>(count, totalPage, pageCurrent, pageSize,
list);
}
/**
* 分页，jdbcTemplate 不支持 like 是定义，只能拼装
*/
public <T> Page<T> queryForPage(String sql, int pageCurrent, int pageSize, Class<T>
clazz, Object... args) {
Assert.hasText(sql, "sql 语句不能为空");
Assert.isTrue(pageCurrent >= 1, "pageNo 必须大于等于 1");
Assert.isTrue(clazz != null, "clazz 不能为空");
String sqlCount = Sql.countSql(sql);
int count = jdbcTemplate.queryForObject(sqlCount, Integer.class, args);
pageCurrent = Sql.checkPageCurrent(count, pageSize, pageCurrent);
pageSize = Sql.checkPageSize(pageSize);
int totalPage = Sql.countTotalPage(count, pageSize);
String sqlList = sql + Sql.limitSql(count, pageCurrent, pageSize);
List<T> list = jdbcTemplate.query(sqlList, new BeanPropertyRowMapper<T>(clazz),
args);
return new Page<T>(count, totalPage, pageCurrent, pageSize, list);
}
测试 :
@Test
public void select2() {
GusUser result = gusUserDao.selectById(7);
System.out.println(result);
}
// 分页测试
@Test
public void queryForPage(){
Page<GusUser> result = gusUserDao.queryForPage(1,20, "测试");
System.out.println(result.getList());
}
实现类 :
@Override
public Page<GusUser> queryForPage(int pageCurrent, int pageSize, String name){
// 若要like查询，如下
StringBuffer sql = new StringBuffer("select * from gus_user where 1");
if(!StringUtils.isNullOrEmpty(name)){
// Sql.checkSql 的作用是防止sql注入
sql.append(" and name like ''%").append(Sql.checkSql(name)).append("%'' ");
}
return queryForPage(sql.toString(), pageCurrent, pageSize, GusUser.class);
} }
Mysql-Front 下载地址： http://www.mysqlfront.de/
今天关于Spring Boot 与 Kotlin 使用JdbcTemplate连接MySQL数据库的方法的讲解已经结束，谢谢您的阅读，如果想了解更多关于Spring boot + jdbcTemplate + MySQL实现增删改查、Spring Boot 2.x 基础教程：使用 JdbcTemplate 访问 MySQL 数据库、Spring Boot 2.x基础教程：使用JdbcTemplate访问MySQL数据库、Spring Boot 使用 SQL 关系型数据库-JdbcTemplate的相关知识，请在本站搜索。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
