摘要：SQL数据库主要指关系型数据库。本节主要讲解Spring Boot集成MySQL数据库的相关操作。Spring框架为MySQL数据库提供了广泛的技术支持，从封装了JDBC操作的JdbcTemplate，到支持ORM技术的Hibernate等。Spring Da
SQL数据库主要指关系型数据库。本节主要讲解Spring Boot集成MySQL数据库的相关操作。Spring框架为MySQL数据库提供了广泛的技术支持，从封装了JDBC操作的JdbcTemplate，到支持ORM技术的Hibernate等。Spring Data是Spring的一个子项目，它提供了Repository接口，可以通过函数名直接完成SQL语句的查询。
Java的javax.sql.DataSource接口提供了处理数据库连接的标准方法，通过配置一个连接池提供数据库连接，Spring Boot可以完成一些自动配置。首选HikariCP连接池，也可使用Tomcat连接池，如果这两个连接池都不可用，则使用DBCP2。当然，开发者也可以自定义连接池，如采用阿里巴巴的Druid等。
Spring Boot提供了自动配置，因此开发者只需在配置文件中添加数据库的配置信息即可。Spring Boot提供了多种类型的连接池，如spring.datasource.hikari.*、spring.datasource.tomcat.*和spring.datasource.dbcp2.*等。
注意：如果不指定spring.datasource.url属性，则Spring Boot会自动配置内嵌的数据库。
一个简单的DataSoruce配置如下：
spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.tomcat.max-wait=10000
spring.datasource.tomcat.max-active=50
spring.datasource.tomcat.test-on-borrow=true
原生的JDBC操作数据库需要自己创建连接，使用完之后还需要手动关闭。Spring框架为了提高开发效率，对JDBC进行了封装，即提供了JdbcTemplate类。JdbcTemplate是一个模板类，提供了操作数据库的基本方法，如插入、更新、删除及查询等操作，同时还封装了一些固定操作，如连接的创建与关闭。JdbcTemplate类提供了回调接口的方式，用于实现一些可变操作，如ConnectionCallback可以返回一个连接，StatementCallback可以返回一个Statement，还可以在回调接口做一些映射关系的逻辑处理。
JdbcTemplate模板类提供了以下几种类型的方法：
execute方法：可以执行任何SQL语句，一般多用于执行DDL（做数据定义）类型的语句。
update方法：执行新增、修改、删除等语句。
query方法：执行与查询相关的语句。
call方法：执行与数据库存储过程和函数相关的语句。
下面通过一个简单的示例展示JdbcTemplate的操作。
（1）定义一张user表，结构如下：
CREATE TABLE `user` (
`user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户id',
`user_name` varchar(128) NOT NULL COMMENT '用户昵称',
`login_name` varchar(128) NOT NULL COMMENT '登录账户',
`user_head_img` varchar(256) DEFAULT NULL COMMENT '用户头像',
`last_login_time` int(11) DEFAULT NULL COMMENT '上次登录时间'
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
（2）使用JdbcTemplate需要依赖spring-boot-starter-jdbc和mysql-connector-java包。配置文件application.yml如下：
spring:
datasource:
url: jdbc:mysql://localhost:3306/test_db?
useUnicode=true&character
Encoding=UTF8&characterSetResults=UTF8&serverTimezone=UTC
username: root
password: test1111
driver-class-name: com.mysql.cj.jdbc.Driver
（3）定义实体类User，代码如下：
//声明实体类User
public class User {
private Integer userId;
//用户ID
private String userName;
//用户名
private String loginName;
//登录名
private Integer lastLoginTime;
//登录时间
private String userHeadImg;
//用户头像
public Integer getUserId {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getUserName {
return userName;
}
public void setUserName(String userName) {
this.userName = userName == null ? null :
userName.trim;
}
public String getLoginName {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName == null ? null :
loginName.trim;
}
public Integer getLastLoginTime {
return lastLoginTime;
}
public void setLastLoginTime(Integer lastLoginTime) {
this.lastLoginTime = lastLoginTime;
}
public String getUserHeadImg {
return userHeadImg;
}
public void setUserHeadImg(String userHeadImg) {
this.userHeadImg = userHeadImg == null ? null :
userHeadImg.
trim;
}
}
（4）定义Dao层的类UserDao，在其中使用JdbcTemplate操作MySQL数据库，代码如下：
//声明UserDao
@Repository
public class UserDao {
@Autowired
private JdbcTemplate jdbcTemplate; //JdbcTemplate注入
public String add(User user){
//insert语句
String sql = "insert into user(user_name, login_name,
last_
login_time, user_head_img) value (?, ?, ?, ?)";
try {
jdbcTemplate.update(sql,user.getUserName,user.getLogin
Name,user.getLastLoginTime,user.getUserHeadImg);
return "1";
} catch (DataAccessException e) {
e.printStackTrace;
return "0";
}
}
public User findOne(Integer userId){
//查询语句
String sql = "select * from user where user_id = " +
userId;
List userList = jdbcTemplate.query(sql, new
BeanProperty
RowMapper(User.class));
return userList.get(0);
}
public String update(User user){
//更新语句
String sql = "update user set user_name = ?,
login_name = ? where
user_id = ?";
try {
jdbcTemplate.update(sql, user.getUserName,
user.get
LoginName, user.getUserId);
return "1";
return "0";
}
}
public String delete(Integer userId){
//删除语句
String sql = "delete from user where user_id = ?";
try {
jdbcTemplate.update(sql, userId);
return "1";
return "0";
}
}
public List findAll{
//查询多条语句
String sql = "select * from user";
List query = jdbcTemplate.query(sql, new
BeanProperty
return query;
}
}
（5）定义Service层的类UserService，代码如下：
@Service
public class UserService {
@Autowired
private UserDao userDao;
//添加方法
public String add(User user){
return userDao.add(user);
}
//查询方法
public User findOne(Integer userId){
return userDao.findOne(userId);
}
//更新方法
public String update(User user){
return userDao.update(user);
}
//删除操作
public String delete(Integer userId){
return userDao.delete(userId);
}
//查询列表方法
public List findAll{
return userDao.findAll;
}
}
（6）定义Controller层的类HiController，代码如下：
@RestController
@RequestMapping("/hi")
public class HiController {
@Autowired
private UserService userService;
//新增用户接口
@PostMapping("/add")
public String add(@RequestBody User user){
return userService.add(user);
}
//查询用户接口
@GetMapping("/findOne")
public User findOne(Integer userId){
return userService.findOne(userId);
}
//更新用户接口
@PostMapping("/update")
public String update(@RequestBody User user){
return userService.update(user);
}
//删除用户接口
@DeleteMapping("/delete")
public String delete(Integer userId){
return userService.delete(userId);
}
//查询多条用户信息接口
@GetMapping("/findAll")
public List findAll{
return userService.findAll;
}
}
启动服务后，可以使用Postman以POST方式访问http://localhost:8080/hi/add接口，在请求Body中增加如下信息：
{
"userName":"张三",
"loginName":"zhangsan",
"lastLoginTime":"1599032640",
"userHeadImg":"https://image.xxx.com/xxx.jpg"
}
访问http://localhost:8080/hi/findAll接口，即可查看刚才插入的用户信息。同样，访问http://localhost:8080/hi/update接口可以更新用户信息，访问http://localhost:8080/ hi/delete?userId=130接口可以删除用户信息。
当开发一个小型项目或者一些工具时可以使用JdbcTemplate模板类，如果开发的是一个大型项目，推荐使用实现了ORM持久化的框架，如Hibernate或MyBatis。本节主要介绍集成了Hibernate的SpringData JPA组件，它基于ORM框架，实现了JPA标准并简化了持久层操作，可以让开发人员用极其简单的方式完成对数据库的访问与操作。
Spring Data JPA同样实现了基本的CRUD方法，如增、删、改、查等。如果有个性化的查询，则需要自定义SQL语句。Spring Data JPA提供了以下几个核心接口：
Repository接口；
CrudRepository接口，继承自Repository；
PagingAndSortingRepository接口，继承自CrudRepository；
JpaRepository接口，继承自PagingAndSortingRepository。
Spring Data JPA提供了很多注解来声明Entity实体类，如表4.1所示。
下面给出一个Spring Data JPA示例，Spring Boot工程依赖spring-boot-starter-data-jpa模块。
（1）修改application.yml配置文件，代码如下：
spring:
datasource:
url: jdbc:mysql://localhost:3306/test_db?
useUnicode=true&character
Encoding=UTF8&characterSetResults=UTF8&serverTimezone=UTC
username: root
password: test1111
driver-class-name: com.mysql.cj.jdbc.Driver
jpa:
hibernate:
ddl-auto: update
show-sql: true
database-platform:
org.hibernate.dialect.MySQL5InnoDBDialect
注意：spring.jpa.hibernate.ddl-auto的update属性用于根据model类自动更新表结构。
（2）声明实体类UserEntity，代码如下：
//定义UserEntity类
@Entity
@Table(name="user")
//表名
@Data
public class UserEntity {
@Id
//声明主键
//主键ID生成策略
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="user_id") //对应的列
名user_id
private Integer userId;
@Column(name="user_name") //对应的列
名user_name
private String userName;
@Column(name="login_name") //对应的列
名login_name
private String loginName;
@Column(name="last_login_time") //对应的列
名last_login_time
private Integer lastLoginTime;
@Column(name="user_head_img") //对应的列
名user_head_img
private String userHeadImg;
}
（3）声明Dao层的类UserRepository，该类继承自JpaRepository，代码如下：
//继承JpaRepository
@Repository
public interface UserRepository extends
JpaRepository
Integer> {
}
如果默认情况下无法满足查询需求，可以通过@Query注解来解决这个问题。例如下面的示例：
@Repository
public interface UserRepository extends
JpaRepository
Integer> {
//自定义查询语句
@Query(value = "select * from user where user_id = ?",
nativeQuery
= true)
UserEntity queryByUserId(Integer userId);
}
如果需要更新，则需要注解@Modifying。
（4）声明Controller层的类，代码如下：
@RestController
@RequestMapping("/hi")
public class HiController {
@Autowired
private UserRepository userRepository; //注入
UserRepository对象
@GetMapping("/jpa/findOne")
public UserEntity jpaFindOne(Integer userId) {
//根据userId查询
Optional optional =
userRepository.findById(userId);
if (optional.isPresent) {
return optional.get;
} else {
return null;
}
}
@GetMapping("/jpa/findAll")
public Page jpaFindAll {
//分页查询
Pageable pageable = PageRequest.of(1,2,
Sort.by(Sort.Direction.
DESC,"userId"));
userRepository.findAll;
Page page =
userRepository.findAll(pageable);
return page;
}
@PostMapping("/jpa/add")
public UserEntity jpaAdd(@RequestBody UserEntity
userEntity) {
//新增用户
UserEntity uEntity = userRepository.save(userEntity);
return uEntity;
}
@PostMapping("/jpa/update")
public UserEntity jpaUpdate(@RequestBody UserEntity
userEntity) {
//更新语句
UserEntity uEntity =
userRepository.saveAndFlush(userEntity);
return uEntity;
}
@DeleteMapping("/jpa/delete")
@Transactional
public String jpaDelete(Integer userId){
//根据userId删除信息
userRepository.deleteById(userId);
return "1";
}
@GetMapping("/jpa/query")
public UserEntity jpaQuery(Integer userId) {
//自定义查询语句
UserEntity userEntity =
userRepository.queryByUserId(userId);
return userEntity;
}
}
同样使用Postman进行测试，访问http://localhost:8080/hi/jpa/findAll、http://localhost:8080/hi/jpa/update、http://localhost:8080/hi/jpa/delete?userId=2接口，完成查询、更新和删除等操作。
MyBatis同样是一款优秀的持久层框架，支持使用简单的XML文件或注解来配置和映射原生信息，从而将接口和Java的POJO对象映射成数据库中的记录。
Spring Boot也提供了MyBatis的集成模块，即mybatis-springboot-starter。
（1）通过MyBatis提供的mybatis-generator插件工具，可以帮助开发人员自动生成POJO类、Mapper文件和DAO类。具体的generatorConfig.xml配置文件内容如下：
PUBLIC "-//mybatis.org//DTD MyBatis Generator
Configuration
1.0//EN"
"http://mybatis.org/dtd/mybatis-generator
config_1_0.dtd">
/>
/>
driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/
test_db?
useUnicode=true&characterEncoding=UTF8&character
SetResults=UTF8&serverTimezone=UTC"
userId="root"
password="test1111">
/>
targetPackage="com.example.springboot.
model"
targetProject="src/main/java">
/>
targetPackage="com.example.springboot.mapper"
targetProject="src/main/resources">
/>
targetPackage="com.
example.springboot.mapper"
/>
执行插件命令：
即可生成对应的User类、UserMapper.xml及UserMapper类。
（2）生成Dao层的类UserMapper，代码如下：
//定义UserMapper类
public interface UserMapper {
long countByExample(UserExample example);
int deleteByExample(UserExample example);
int deleteByPrimaryKey(Integer userId);
int insert(User record);
int insertSelective(User record);
List selectByExample(UserExample example);
User selectByPrimaryKey(Integer userId);
int updateByExampleSelective(@Param("record") User
record, @Param
("example") UserExample example);
int updateByExample(@Param("record") User record,
@Param("example")
UserExample example);
int updateByPrimaryKeySelective(User record);
int updateByPrimaryKey(User record);
}
（3）在启动类上添加@MapperScan注解，可以自动注入相关的mapper类。具体代码如下：
//扫描mapper类
@MapperScan("com.example.springboot.mapper")
（4）生成Controller层的类HiController，通过MyBatis的方式获取，代码如下：
@RestController
@RequestMapping("/hi")
public class HiController {
@Resource
private UserMapper userMapper;
@GetMapping("/mybatis/findOne")
public User mybatisFindOne(Integer userId) {
//查询操作
User user = userMapper.selectByPrimaryKey(userId);
return user;
}
}
重新启动应用，在浏览器中访问http://localhost:8080/hi/mybatis/findOne?userId=1，即可查询对应的信息。
来源：大数据架构师
