Spring Boot笔记-Spring Boot与数据访问（六）
对于数据访问层，无论是SQL还是NOSQL，Spring Boot默认采用整合Spring Data的方式进行统一处理，添加大量自动配置，屏蔽了很多设置。引入各种xxxTemplate，xxxRepository来简化我们对数据访问层的操作。对我们来说只需要进行简单的设置即可。我们将在数据访问章节测试使用SQL相关、NOSQL在缓存、消息、检索等章节测试。
1.JDBC
创建Spring Boot项目，加入依赖的时候，勾选Spring Web、JDBC API、MySQL Driver。开启虚拟机，并启动MySQL的docker镜像，使用Navicat测试是否可以连接成功。
编写application.yml配置文件。
高版本的MySQL在写url的时候需要带上时区等参数，否则连接的时候会报错，关于driver-class-name的问题，如果使用的是驱动是mysql-connector-java 5，就用com.mysql.jdbc.Driver，如果使用的是mysql-connector-java 6，就用com.mysql.cj.jdbc.Driver。
spring:
datasource:
username: root
password: root
url: jdbc:mysql://192.168.0.123:3306/jdbc?useSSL=true&useUnicode=true&characterEncoding=UTF8&serverTimezone=GMT
driver-class-name: com.mysql.cj.jdbc.Driver
initialization-mode: always # 启动Spring Boot项目主程序启动的时候，执行初始化方法
通过测试类测试配置是否正确，Spring Boot 1.x的数据源默认是org.apache.tomcat.jdbc.pool.DataSource，Spring Boot 2.x改成了com.zaxxer.hikari.HikariDataSource。因为HikariDataSource更高效。
package com.atguigu.springboot;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
@SpringBootTest
class SpringBoot06DataJdbcApplicationTests {
@Autowired
DataSource dataSource;
@Test
void contextLoads() throws SQLException {
System.out.println(dataSource.getClass());
Connection connection = dataSource.getConnection();
System.out.println(connection);
connection.close();
}
}
自动配置原理：查看org.springframework.boot.autoconfigure.jdbc下的代码。
1.默认支持的数据源
打开DataSourceConfiguration类，通过注解的判断，自动注入的DataSource。默认支持org.apache.commons.dbcp2.BasicDataSource、com.zaxxer.hikari.HikariDataSource、org.apache.tomcat.jdbc.pool.DataSource。
2.自定义数据源
也可以在配置文件中，使用spring.datasource.type来手动指定。通过DataSourceBuilder类的build()方法，通过反射创建数据源。
3.DataSourceInitializer
查看DataSourceInitializer类的getScripts()方法，这个方法在Spring Boot项目启动的时候，会扫描类路径下有没有schema-*.sql或data-*.sql文件，如果有，就执行里面的SQL语句。
private List getScripts(String propertyName, List resources, String fallback) {
if (resources != null) {
return this.getResources(propertyName, resources, true);
} else {
String platform = this.properties.getPlatform();
List fallbackResources = new ArrayList();
fallbackResources.add("classpath*:" + fallback + "-" + platform + ".sql");
fallbackResources.add("classpath*:" + fallback + ".sql");
return this.getResources(propertyName, fallbackResources, false);
}
} 我们可以在类路径下，创建一个schema-all.sql文件，添加建表语句，在配置文件中加入initialization-mode: always，再启动项目，可以发现在数据库里创建了一张表。
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for department
-- ----------------------------
DROP TABLE IF EXISTS `department`;
CREATE TABLE `department` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`departmentName` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
如果在初始化的时候，需要执行多条SQL，并且这些SQL位于不同的文件中，可以在配置文件中指定这些schema，比如，我有两个SQL需要执行：department.sql和employee.sql。可以在配置文件中加入下面的内容，就可以初始化的时候，运行这些SQL。
spring:
datasource:
schema: classpath:department.sql, employee.sql4.测试JDBC
注释掉配置文件中的初始化相关内容，在数据库中加入几条数据，编写Controller，发送请求获取数据。
package com.atguigu.springboot.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
import java.util.Map;
@Controller
public class HelloController {
@Autowired
JdbcTemplate jdbcTemplate;
@ResponseBody
@GetMapping("/query")
public Map query() {
return jdbcTemplate.queryForList("SELECT * FROM department LIMIT 1").get(0);
}
}
2.整合Druid数据源
视频中讲解的内容是Spring Boot 1.x版本的，做一下记录，了解一下，后面的是Spring Boot 2.x版本的。
1.Spring Boot 1.x版本
pom文件中加入Druid依赖。
com.alibaba
druid
1.1.10
修改application.yml，指定数据源，也就是type的值。再加入一些DataSource的配置。
spring:
datasource:
username: root
password: root
url: jdbc:mysql://192.168.0.123:3306/jdbc?useSSL=true&useUnicode=true&characterEncoding=UTF8&serverTimezone=GMT
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
# 数据源其他配置
initialSize: 5
minIdle: 5
maxActive: 20
maxWait: 60000
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: SELECT 1
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
filters: stat,wall,slf4j
maxPoolPreparedStatementPerConnectionSize: 20
useGlobalDataSourceStat: true
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
# initialization-mode: always # 启动Spring Boot项目主程序启动的时候，执行初始化方法
# schema: classpath:department.sql, classpath:employee.sql继续运行测试类，发现数据源已经由原来默认的HikariDataSource变为DruidDataSource了。在配置数据源的时候，通常还需要指定其他参数，这里需要些一个配置类DruidConfig.java，用于读取配置文件中的内容，否则，设置不进去。
package com.atguigu.springboot.config;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class DruidConfig {
@ConfigurationProperties(prefix = "spring.datasource")
@Bean
public DataSource dataSource() {
return new DruidDataSource();
}
// 配置Druid的监控
// 1.配置管理后台的Servlet
@Bean
public ServletRegistrationBean servletRegistrationBean() {
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
Map map = new HashMap();
map.put("loginUsername", "root");// 后台监控的用户名
map.put("loginPassword", "root");// 后台监控的密码
map.put("allow", "");// 默认允许所有访问
map.put("deny", "127.0.0.1");// 把本机ip设置成拒绝访问用于测试，在访问的时候也要用127.0.0.1，不能用localhost
// 访问http://127.0.0.1:8080/druid，会提示“Sorry, you are not permitted to view this page.”
servletRegistrationBean.setInitParameters(map);
return servletRegistrationBean;
}
// 2.配置一个web监控的Filter
@Bean
public FilterRegistrationBean filterRegistrationBean() {
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
filterRegistrationBean.setFilter(new WebStatFilter());
Map map = new HashMap();
map.put("exclusions", "*.js,*.css,/druid/*");
filterRegistrationBean.setInitParameters(map);
filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
return filterRegistrationBean;
}
}
访问http://127.0.0.1:8080/druid，输入账号密码，就可以登陆到Druid的后台监控了。
2.Spring Boot 2.x版本
引入Druid的依赖，这里的依赖是starter的形式。
com.alibaba
druid-spring-boot-starter
1.1.10
修改yml文件，添加DataSource的配置，可以和上面的Spring Boot 1.x对比下，其实没什么差别，这么做的好处是不需要写DruidConfig类了，需要的配置，都在yml里写好即可。
spring:
datasource:
username: root
password: root
url: jdbc:mysql://192.168.0.123:3306/jdbc?useSSL=true&useUnicode=true&characterEncoding=UTF8&serverTimezone=GMT
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
druid:
# Druid数据源配置
initial-size: 5
min-idle: 5
max-active: 20
max-wait: 60000
time-between-eviction-runs-millis: 300000
validation-query: SELECT 1
test-while-idle: true
test-on-borrow: false
test-on-return: false
pool-prepared-statements: true
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
filters: stat,wall,slf4j
max-pool-prepared-statement-per-connection-size: 20
use-global-data-source-stat: true
connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
# 之前在servletRegistrationBean里设置的参数
stat-view-servlet:
login-username: root
login-password: root
deny: 127.0.0.1
# 之前在filterRegistrationBean里设置的参数
web-stat-filter:
exclusions: "*.js,*.css,/druid/*"
# initialization-mode: always # 启动Spring Boot项目主程序启动的时候，执行初始化方法
# schema: classpath:department.sql, classpath:employee.sql
可以发现Spring Boot 2.x版本更加简单了。
3.整合Mybatis
创建Spring Boot项目，添加Spring Web、JDBC API、Mybatis Framework、MySQL Driver依赖。新建一个mybatis数据库，添加yml配置文件对Druid进行配置，这里采用Spring Boot 2.x的方式了，因为这样比较简单。
spring:
datasource:
username: root
password: root
url: jdbc:mysql://192.168.0.123:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF8&serverTimezone=GMT
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
druid:
# Druid数据源配置
initial-size: 5
min-idle: 5
max-active: 20
max-wait: 60000
time-between-eviction-runs-millis: 300000
validation-query: SELECT 1
test-while-idle: true
test-on-borrow: false
test-on-return: false
pool-prepared-statements: true
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
filters: stat,wall,slf4j
max-pool-prepared-statement-per-connection-size: 20
use-global-data-source-stat: true
connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
# 之前在servletRegistrationBean里设置的参数
stat-view-servlet:
login-username: root
login-password: root
deny: 127.0.0.1
# 之前在filterRegistrationBean里设置的参数
web-stat-filter:
exclusions: "*.js,*.css,/druid/*"
在mybatis数据库里创建department和employee两张表，用于测试。创建对应的JavaBean。
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for department
-- ----------------------------
DROP TABLE IF EXISTS `department`;
CREATE TABLE `department` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`departmentName` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for employee
-- ----------------------------
DROP TABLE IF EXISTS `employee`;
CREATE TABLE `employee` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`lastName` varchar(255) DEFAULT NULL,
`email` varchar(255) DEFAULT NULL,
`gender` int(2) DEFAULT NULL,
`d_id` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
1.注解版
编写DepartmentMapper.java和DepartmentController用于测试。
package com.atguigu.springboot.controller;
import com.atguigu.springboot.bean.Department;
import com.atguigu.springboot.mapper.DepartmentMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DepartmentController {
@Autowired
DepartmentMapper departmentMapper;
@GetMapping("/department/{id}")
public Department getDepartment(@PathVariable("id") int id) {
return departmentMapper.getDepartmentById(id);
}
@GetMapping("/department")
public Department insertDepartment(Department department) {
departmentMapper.insertDepartment(department);
return department;
}
}
发送请求http://localhost:8080/department?departmentName=AA会往数据库里插入一条Department记录，再请求http://localhost:8080/department/1，就能得到刚才的那条记录。
package com.atguigu.springboot.mapper;
import com.atguigu.springboot.bean.Department;
import org.apache.ibatis.annotations.*;
@Mapper
public interface DepartmentMapper {
@Select("SELECT * FROM department where id = #{id}")
public Department getDepartmentById(int id);
@Delete("DELETE FROM department where id = #{id}")
public int deleteDepartmentById(int id);
// 表示使用自动生成的主键，主键对应的字段是id，在执行插入操作后，会将id进行返回
// 注意，这里的返回是指封装到department里面，而不是作为方法的返回值，方法的返回值是1代表，此次SQL对表的影响行数是1
@Options(useGeneratedKeys = true, keyProperty = "id")
@Insert("INSERT INTO department(departmentName) VALUES (#{departmentName})")
public int insertDepartment(Department department);
@Update("UPDATE department SET departmentName = #{departmentName} WHERE id = #{id}")
public int updateDepartment(Department department);
}
到这里，提一句mybatis里的知识点。
在发送http://localhost:8080/department?departmentName=AA请求的时候，会把departmentName作为参数传给insertDepartment()方法，但是insertDepartment()方法接收的是Department类型的参数，这时候Mybatis会帮我们调用setDepartmentName()方法把传过来的departmentName给赋值进去，因为没有传id，所以id取默认值0，然后调用Mapper的时候，传递的也是department对象，并且这个对象只有departmentName属性。
再看DepartmentMapper里面，@Insert里面直接取的departmentName，此时会调用department.getDepartMent()方法获取值。
假设在Mapper的某个方法里面，只有一个基本类型的参数id，那么在SQL上取参数，就使用#{id}的方式即可。
@Select("SELECT * FROM table WHERE id = #{id}")
public void fun(int id);假设在Mapper的某个方法里面，只有一个引用类型的参数，也就是只有一个对象，那么在SQL上取参数的，直接使用属性取值，比如这里的#{id}，这里直接用属性即可，因为只有一个对象参数。如果，在Mapper接口的参数上带了@Param("department")，那么这里就不能直接使用#{id}了，必须使用#{department.id}才行。
@Select("SELECT * FROM table WHERE id = #{id}")
public void fun(Department department);
或
@Select("SELECT * FROM table WHERE id = #{department.id}")
public void fun(@Param("department") Department department);假设在Mapper的某个方法里面，有多个参数（不管是基本类型还是引用类型）的时候，必须在Mapper接口上给每个参数带上@Param("key")的注解，这些key就是在SQL中的标识，Mybatis是通过@Param里指定的key找到对应的参数，这里又要分两种情况。
假设这个@Param标注的参数是基本类型id，那么在SQL里，直接使用#{id}即可。
假设这个@Param标注的参数是引用类型department，那么在SQL里，需要使用#{department.departmentName}来获取属性值，这里的department是要带着的。
@Select("SELECT * FROM table WHERE id = #{id} AND departmentName = #{department.departmentName}")
public void fun(@Param("department") Department department, @Param("id") int id);通常，数据库里的字段是小写加下划线分隔的，JavaBean里是驼峰命名法，会出现对应不上的情况，如果采用配置文件的方式，可以修改配置文件将驼峰命名和下划线命名匹配。
如果没有配置文件呢？查看MybatisAutoConfiguration类的applyConfiguration()方法，里面有一个ConfigurationCustomizer类用于自定义设置的。我们可以自己写一个ConfigurationCustomizer类，将自定义的设置添加进去，这里就是给mapUnderscoreToCamelCase属性赋值，最后把ConfigurationCustomizer注入到容器中。
package com.atguigu.springboot.config;
import org.apache.ibatis.session.Configuration;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.springframework.context.annotation.Bean;
@org.springframework.context.annotation.Configuration
public class MybatisConfig {
@Bean
public ConfigurationCustomizer configurationCustomizer() {
return new ConfigurationCustomizer() {
@Override
public void customize(Configuration configuration) {
configuration.setMapUnderscoreToCamelCase(true);
}
};
}
}
测试发现，从数据库获取的department_name也可以映射到JavaBean里的departmentName了，说明自定义配置生效了。
另外再提一句，一种更简便的方式，也就是在yml里做配置。
mybatis:
configuration:
map-underscore-to-camel-case: true在后序的开发中，可能会有很多的Mapper文件，如果在每个Mapper文件上都标注@Mapper，就是一个重复的工作，于是，我们可以使用一个新的注解，减少这种工作量。这个注解要加在项目的主启动类上，代表在项目启动的时候，就指明了mapper文件的位置，
package com.atguigu.springboot;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@MapperScan(value = "com.atguigu.spring.mapper")
@SpringBootApplication
public class SpringBoot06DataMybatisApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBoot06DataMybatisApplication.class, args);
}
}
2.配置文件版
创建EmployeeMapper.java。
package com.atguigu.springboot.mapper;
import com.atguigu.springboot.bean.Department;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface EmployeeMapper {
public Department getEmployeeById(int id);
public int insertEmployee(Department department);
}
在resources下创建mybatis文件夹，放入mybatis-config.xml全局配置文件，在mybatis文件夹下创建mapper文件夹，用来存放SQL。
INSERT INTO employee(lastName, email, gender, d_id) VALUES (#{lastName}, #{email}, #{gender}, #{dId})
在yml下对指定mybatis全局文件的位置和mapper文件的位置。如果还需要在yml里配置其他参数，参照官网：http://mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/。
mybatis:
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml编写EmployeeController.java进行测试。
package com.atguigu.springboot.controller;
import com.atguigu.springboot.bean.Employee;
import com.atguigu.springboot.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class EmployeeController {
@Autowired
EmployeeMapper employeeMapper;
@GetMapping("/employee/{id}")
public Employee getDepartment(@PathVariable("id") int id) {
return employeeMapper.getEmployeeById(id);
}
@GetMapping("/employee")
public Employee insertDepartment(Employee employee) {
employeeMapper.insertEmployee(employee);
return employee;
}
}
在数据库里加入一条记录，发送http://localhost:8080/employee/1请求，可以拿到数据库中刚刚添加的那条记录，测试通过。
4.整合Spring Data JPA
1.Spring Data简介
Spring Data 项目的目的是为了简化构建基于 Spring 框架应用的数据访问技术，包括非关系数据库、Map-Reduce 框架、云数据服务等等；另外也包含对关系数据库的访问支持。
Spring Data 包含多个子项目：
- Spring Data Commons
- Spring Data JPA
- Spring Data KeyValue
- Spring Data LDAP
- Spring Data MongoDB
- Spring Data Gemfire
- Spring Data REST
- Spring Data Redis
- Spring Data for Apache Cassandra
- Spring Data for Apache Solr
- Spring Data Couchbase (community module)
- Spring Data Elasticsearch (community module)
- Spring Data Neo4j (community module)
1、Spring Data特点
Spring Data为我们提供使用统一的API来对数据访问层进行操作；这主要是Spring Data Commons项目来实现的。Spring Data Commons让我们在使用关系型或者非关系型数据访问技术时都基于Spring提供的统一标准，标准包含了CRUD（创建、获取、更新、删除）、查询、排序和分页的相关操作。
2、统一的Repository接口
Repository
RevisionRepository
CrudRepository
PagingAndSortingRepository
3、提供数据访问模板类 xxxTemplate；
如：MongoTemplate、RedisTemplate等。
4、JPA与Spring Data
- JpaRepository基本功能：编写接口继承JpaRepository既有crud及分页等基本功能
- 定义符合规范的方法命名：在接口中只需要声明符合规范的方法，即拥有对应的功能
- @Query自定义查询，定制查询SQL
- Specifications查询（Spring Data JPA支持JPA2.0的Criteria查询）
2.整合SpringData JPA
新建Spring Boot项目，勾选Spring Web、JDBC API、Spring JPA、MySQL Driver。创建jpa数据库。
1.编写实体列和数据表进行映射，配置好映射关系
package com.atguigu.springboot.entity;
import javax.persistence.*;
@Entity
@Table(name = "user")
public class User {
@Id // 标注这是一个主键
@GeneratedValue(strategy = GenerationType.IDENTITY) // 自增主键
private int id;
@Column(name = "name", length = 50)
private String name;
@Column // 不带name属性，默认就是属性名
private String email;
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 String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
2.编写Dao接口操作实体类对应的数据表
package com.atguigu.springboot.repository;
import com.atguigu.springboot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
// 继承JpaRepository完成对数据库的操作
public interface UserRepository extends JpaRepository {
}
记得带上JpaRepository后面的泛型，否则启动会报错。
3.在yml里做基本配置
spring:
datasource:
url: jdbc:mysql://192.168.0.123:3306/jpa?useSSL=true&useUnicode=true&characterEncoding=UTF8&serverTimezone=GMT
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
jpa:
hibernate:
# 更新或创建数据表结构
ddl-auto: update
# 控制台显示SQL
show-sql: true4.写一个Controller做测试
package com.atguigu.springboot.controller;
import com.atguigu.springboot.entity.User;
import com.atguigu.springboot.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@Autowired
UserRepository userRepository;
@GetMapping("/user/{id}")
public User getUser(@PathVariable("id") int id) {
User user = userRepository.findById(id).get();
return user;
}
@GetMapping("/user")
public User insertUser(User user) {
User saveUser = userRepository.save(user);
return saveUser;
}
}
发送http://localhost:8080/[email protected]请求插入一条数据，发送http://localhost:8080/user/1请求获取到数据。同时，我们可以在控制台看到打印的SQL。