model, HttpServletRequest request, HttpServletResponse response)
throws Exception {
if (response.isCommitted()) {
String message = getMessage(model);
logger.error(message);
return;
}
response.setContentType(TEXT_HTML_UTF8.toString());
StringBuilder builder = new StringBuilder();
Object timestamp = model.get("timestamp");
Object message = model.get("message");
Object trace = model.get("trace");
if (response.getContentType() == null) {
response.setContentType(getContentType());
}
//系统默认异常页面html代码
builder.append("Whitelabel Error Page ").append(
"This application has no explicit mapping for /error, so you are seeing this as a fallback.
")
.append("").append(timestamp).append("
")
.append("There was an unexpected error (type=").append(htmlEscape(model.get("error")))
.append(", status=").append(htmlEscape(model.get("status"))).append(").
");
if (message != null) {
builder.append("").append(htmlEscape(message)).append("
");
}
if (trace != null) {
builder.append("").append(htmlEscape(trace)).append("
");
}
builder.append("");
response.getWriter().append(builder.toString());
}
private String htmlEscape(Object input) {
return (input != null) ? HtmlUtils.htmlEscape(input.toString()) : null;
}
private String getMessage(Map model) {
Object path = model.get("path");
String message = "Cannot render error page for request [" + path + "]";
if (model.get("message") != null) {
message += " and exception [" + model.get("message") + "]";
}
message += " as the response has already been committed.";
message += " As a result, the response may have the wrong status code.";
return message;
}
@Override
public String getContentType() {
return "text/html";
}
}
}
```
### 55、==错误处理-【源码流程】几种异常处理原理==
* 自定义错误页
* error/404.html error/5xx.html；有精确的错误状态码页面就匹配精确，没有就找 4xx.html；如果都没有就触发白页
* `@ControllerAdvice`+`@ExceptionHandler`处理全局异常；底层是 `ExceptionHandlerExceptionResolver` 支持的
```java
@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler({ArithmeticException.class,NullPointerException.class}) //处理异常
public String handleArithException(Exception e){
log.error("异常是：{}",e);
return "login"; //视图地址
}
}
1234567891011
```
* `@ResponseStatus`+自定义异常 ；底层是 `ResponseStatusExceptionResolver` ，把responseStatus注解的信息底层调用 `response.sendError(statusCode, resolvedReason)`，tomcat发送的`/error`
```java
@ResponseStatus(value= HttpStatus.FORBIDDEN,reason = "用户数量太多")
public class UserTooManyException extends RuntimeException {
public UserTooManyException(){
}
public UserTooManyException(String message){
super(message);
}
}
@Controller
public class TableController {
@GetMapping("/dynamic_table")
public String dynamic_table(@RequestParam(value="pn",defaultValue = "1") Integer pn,Model model){
//表格内容的遍历
List users = Arrays.asList(new User("zhangsan", "123456"),
new User("lisi", "123444"),
new User("haha", "aaaaa"),
new User("hehe ", "aaddd"));
model.addAttribute("users",users);
if(users.size()>3){
throw new UserTooManyException();//抛出自定义异常
}
return "table/dynamic_table";
}
}
```
* Spring自家异常如 `org.springframework.web.bind.MissingServletRequestParameterException`，`DefaultHandlerExceptionResolver` 处理Spring自家异常。
* * `response.sendError(HttpServletResponse.SC_BAD_REQUEST/*400*/, ex.getMessage());`
* 自定义实现 `HandlerExceptionResolver` 处理异常；可以作为默认的全局异常处理规则
```java
@Order(value= Ordered.HIGHEST_PRECEDENCE) //优先级，数字越小优先级越高
@Component
public class CustomerHandlerExceptionResolver implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest request,
HttpServletResponse response,
Object handler, Exception ex) {
try {
response.sendError(511,"我喜欢的错误");
} catch (IOException e) {
e.printStackTrace();
}
return new ModelAndView();
}
}
```
* ```
ErrorViewResolver
```
实现自定义处理异常
* `response.sendError()`，error请求就会转给controller。
* 你的异常没有任何人能处理，tomcat底层调用`response.sendError()`，error请求就会转给controller。
* `basicErrorController` 要去的页面地址是 `ErrorViewResolver` 。
```java
@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {
...
@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
HttpStatus status = getStatus(request);
Map model = Collections
.unmodifiableMap(getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
response.setStatus(status.value());
ModelAndView modelAndView = resolveErrorView(request, response, status, model);
return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
}
protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status,
Map model) {
//这里用到ErrorViewResolver接口
for (ErrorViewResolver resolver : this.errorViewResolvers) {
ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
if (modelAndView != null) {
return modelAndView;
}
}
return null;
}
...
}
@FunctionalInterface
public interface ErrorViewResolver {
ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map model);
}
123456
```
### 56、原生组件注入-原生注解与Spring方式注入
[官方文档 - Servlets, Filters, and listeners](https://docs.spring.io/spring-boot/docs/2.4.2/reference/htmlsingle/#howto-add-a-servlet-filter-or-listener)
#### 使用原生的注解
```java
@WebServlet(urlPatterns = "/my")
public class MyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().write("66666");
}
}
12345678
@Slf4j
@WebFilter(urlPatterns={"/css/*","/images/*"}) //my
public class MyFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
log.info("MyFilter初始化完成");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
log.info("MyFilter工作");
chain.doFilter(request,response);
}
@Override
public void destroy() {
log.info("MyFilter销毁");
}
}
12345678910111213141516171819
@Slf4j
@WebListener
public class MyServletContextListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
log.info("MySwervletContextListener监听到项目初始化完成");
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
log.info("MySwervletContextListener监听到项目销毁");
}
}
123456789101112131415
```
最后还要在主启动类添加注解`@ServletComponentScan`
```java
@ServletComponentScan(basePackages = "com.lun")//
@SpringBootApplication(exclude = RedisAutoConfiguration.class)
public class Boot05WebAdminApplication {
public static void main(String[] args) {
SpringApplication.run(Boot05WebAdminApplication.class, args);
}
}
12345678
```
#### Spring方式注入
```
ServletRegistrationBean`, `FilterRegistrationBean`, and `ServletListenerRegistrationBean
@Configuration(proxyBeanMethods = true)
public class MyRegistConfig {
@Bean
public ServletRegistrationBean myServlet(){
MyServlet myServlet = new MyServlet();
return new ServletRegistrationBean(myServlet,"/my","/my02");
}
@Bean
public FilterRegistrationBean myFilter(){
MyFilter myFilter = new MyFilter();
// return new FilterRegistrationBean(myFilter,myServlet());
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(myFilter);
filterRegistrationBean.setUrlPatterns(Arrays.asList("/my","/css/*"));
return filterRegistrationBean;
}
@Bean
public ServletListenerRegistrationBean myListener(){
MySwervletContextListener mySwervletContextListener = new MySwervletContextListener();
return new ServletListenerRegistrationBean(mySwervletContextListener);
}
}
123456789101112131415161718192021222324252627
```
### 57、原生组件注入-【源码分析】DispatcherServlet注入原理
`org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration`配置类
```java
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
public class DispatcherServletAutoConfiguration {
/*
* The bean name for a DispatcherServlet that will be mapped to the root URL "/"
*/
public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";
/*
* The bean name for a ServletRegistrationBean for the DispatcherServlet "/"
*/
public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";
@Configuration(proxyBeanMethods = false)
@Conditional(DefaultDispatcherServletCondition.class)
@ConditionalOnClass(ServletRegistration.class)
@EnableConfigurationProperties(WebMvcProperties.class)
protected static class DispatcherServletConfiguration {
//创建DispatcherServlet类的Bean
@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
DispatcherServlet dispatcherServlet = new DispatcherServlet();
dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
return dispatcherServlet;
}
@Bean
@ConditionalOnBean(MultipartResolver.class)
@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
public MultipartResolver multipartResolver(MultipartResolver resolver) {
// Detect if the user has created a MultipartResolver but named it incorrectly
return resolver;
}
}
@Configuration(proxyBeanMethods = false)
@Conditional(DispatcherServletRegistrationCondition.class)
@ConditionalOnClass(ServletRegistration.class)
@EnableConfigurationProperties(WebMvcProperties.class)
@Import(DispatcherServletConfiguration.class)
protected static class DispatcherServletRegistrationConfiguration {
//注册DispatcherServlet类
@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet,
WebMvcProperties webMvcProperties, ObjectProvider multipartConfig) {
DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet,
webMvcProperties.getServlet().getPath());
registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
multipartConfig.ifAvailable(registration::setMultipartConfig);
return registration;
}
}
...
}
```
`DispatcherServlet`默认映射的是 `/` 路径，可以通过在配置文件修改`spring.mvc.servlet.path=/mvc`。
### 58、嵌入式Servlet容器-【源码分析】切换web服务器与定制化
* 默认支持的WebServer
* `Tomcat`, `Jetty`, or `Undertow`。
* `ServletWebServerApplicationContext`容器启动寻找`ServletWebServerFactory` 并引导创建服务器。
* 原理
* SpringBoot应用启动发现当前是Web应用，web场景包-导入tomcat。
* web应用会创建一个web版的IOC容器 `ServletWebServerApplicationContext` 。
* `ServletWebServerApplicationContext` 启动的时候寻找 `ServletWebServerFactory` （Servlet 的web服务器工厂——>Servlet 的web服务器）。
* SpringBoot底层默认有很多的WebServer工厂（
```
ServletWebServerFactoryConfiguration
```
内创建Bean），如：
* `TomcatServletWebServerFactory`
* `JettyServletWebServerFactory`
* `UndertowServletWebServerFactory`
* 底层直接会有一个自动配置类`ServletWebServerFactoryAutoConfiguration`。
* `ServletWebServerFactoryAutoConfiguration`导入了`ServletWebServerFactoryConfiguration`（配置类）。
* `ServletWebServerFactoryConfiguration`根据动态判断系统中到底导入了那个Web服务器的包。（默认是web-starter导入tomcat包），容器中就有 `TomcatServletWebServerFactory`
* `TomcatServletWebServerFactory`创建出Tomcat服务器并启动；`TomcatWebServer` 的构造器拥有初始化方法initialize——`this.tomcat.start();`
* 内嵌服务器，与以前手动把启动服务器相比，改成现在使用代码启动（tomcat核心jar包存在）。
Spring Boot默认使用Tomcat服务器，若需更改其他服务器，则修改工程pom.xml：
```xml
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-tomcat
org.springframework.boot
spring-boot-starter-jetty
```
[官方文档 - Use Another Web Server](https://docs.spring.io/spring-boot/docs/2.4.2/reference/htmlsingle/#howto-use-another-web-server)
#### 定制Servlet容器
* 实现`WebServerFactoryCustomizer`
* * 把配置文件的值和`ServletWebServerFactory`进行绑定
* 修改配置文件 `server.xxx`
* 直接自定义 `ConfigurableServletWebServerFactory`
`xxxxxCustomizer`：**定制化器**，可以改变xxxx的默认规则
```java
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.stereotype.Component;
@Component
public class CustomizationBean implements
WebServerFactoryCustomizer {
@Override
public void customize(ConfigurableServletWebServerFactory server) {
server.setPort(9000);
}
}
12345678910111213
```
### 59、定制化原理-SpringBoot定制化组件的几种方式（小结）
#### 定制化的常见方式
* 修改配置文件
* `xxxxxCustomizer`
* 编写自定义的配置类 `xxxConfiguration` + `@Bean`替换、增加容器中默认组件，视图解析器
* Web应用 编写一个配置类实现 `WebMvcConfigurer` 即可定制化web功能 + `@Bean`给容器中再扩展一些组件
```java
@Configuration
public class AdminWebConfig implements WebMvcConfigurer{
}
```
* `@EnableWebMvc`
*
`WebMvcConfigurer`
—
`@Bean`
可以全面接管SpringMVC，所有规则全部自己重新配置； 实现定制和扩展功能（
高级功能，初学者退避三舍
）。
* 原理：
1. `WebMvcAutoConfiguration`默认的SpringMVC的自动配置功能类，如静态资源、欢迎页等。
2. 一旦使用 `@EnableWebMvc` ，会`@Import(DelegatingWebMvcConfiguration.class)`。
3. `DelegatingWebMvcConfiguration`
的作用，只保证SpringMVC最基本的使用
* 把所有系统中的`WebMvcConfigurer`拿过来，所有功能的定制都是这些`WebMvcConfigurer`合起来一起生效。
* 自动配置了一些非常底层的组件，如`RequestMappingHandlerMapping`，这些组件依赖的组件都是从容器中获取如。
* `public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport`。
4. `WebMvcAutoConfiguration`里面的配置要能生效必须 `@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)`。
5. @EnableWebMvc 导致了WebMvcAutoConfiguration 没有生效。
#### 原理分析套路
场景starter - `xxxxAutoConfiguration` - 导入xxx组件 - 绑定`xxxProperties` - 绑定配置文件项。
### 60、数据访问-数据库场景的自动配置分析与整合测试
#### 导入JDBC场景
```xml
org.springframework.boot
spring-boot-starter-data-jdbc
1234
```
接着导入数据库驱动包（MySQL为例）。
```xml
8.0.22
mysql
mysql-connector-java
1.8
5.1.49
123456789101112131415161718
```
#### 相关数据源配置类
* `DataSourceAutoConfiguration` ： 数据源的自动配置。
* 修改数据源相关的配置：`spring.datasource`。
* **数据库连接池的配置，是自己容器中没有DataSource才自动配置的**。
* 底层配置好的连接池是：`HikariDataSource`。
* `DataSourceTransactionManagerAutoConfiguration`： 事务管理器的自动配置。
* `JdbcTemplateAutoConfiguration`： `JdbcTemplate`的自动配置，可以来对数据库进行CRUD。
* 可以修改前缀为`spring.jdbc`的配置项来修改`JdbcTemplate`。
* `@Bean @Primary JdbcTemplate`：Spring容器中有这个`JdbcTemplate`组件，使用`@Autowired`。
* `JndiDataSourceAutoConfiguration`： JNDI的自动配置。
* `XADataSourceAutoConfiguration`： 分布式事务相关的。
#### 修改配置项
```yaml
spring:
datasource:
url: jdbc:mysql://localhost:3306/db_account
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
123456
```
#### 单元测试数据源
```java
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;
@SpringBootTest
class Boot05WebAdminApplicationTests {
@Autowired
JdbcTemplate jdbcTemplate;
@Test//用@org.junit.Test会报空指针异常，可能跟JUnit新版本有关
void contextLoads() {
// jdbcTemplate.queryForObject("select * from account_tbl")
// jdbcTemplate.queryForList("select * from account_tbl",)
Long aLong = jdbcTemplate.queryForObject("select count(*) from account_tbl", Long.class);
log.info("记录总数：{}",aLong);
}
}
1234567891011121314151617181920
```
### 61、数据访问-自定义方式整合druid数据源
[Druid官网](https://github.com/alibaba/druid)
#### Druid是什么？
它是数据库连接池，它能够提供强大的监控和扩展功能。
[官方文档 - Druid连接池介绍](https://github.com/alibaba/druid/wiki/Druid连接池介绍)
Spring Boot整合第三方技术的两种方式：
* 自定义
* 找starter场景
#### 自定义方式
**添加依赖**：
```xml
com.alibaba
druid
1.1.17
12345
```
**配置Druid数据源**：
```java
@Configuration
public class MyConfig {
@Bean
@ConfigurationProperties("spring.datasource")//复用配置文件的数据源配置
public DataSource dataSource() throws SQLException {
DruidDataSource druidDataSource = new DruidDataSource();
// druidDataSource.setUrl();
// druidDataSource.setUsername();
// druidDataSource.setPassword();
return druidDataSource;
}
}
123456789101112131415
```
[更多配置项](https://github.com/alibaba/druid/wiki/DruidDataSource配置)
**配置Druid的监控页功能**：
* Druid内置提供了一个`StatViewServlet`用于展示Druid的统计信息。[官方文档 - 配置\_StatViewServlet配置](https://github.com/alibaba/druid/wiki/配置_StatViewServlet配置)。这个`StatViewServlet`的用途包括：
* 提供监控信息展示的html页面
* 提供监控信息的JSON API
* Druid内置提供一个`StatFilter`，用于统计监控信息。[官方文档 - 配置\_StatFilter](https://github.com/alibaba/druid/wiki/配置_StatFilter)
* `WebStatFilter`用于采集web-jdbc关联监控的数据，如SQL监控、URI监控。[官方文档 - 配置\_配置WebStatFilter](https://github.com/alibaba/druid/wiki/配置_配置WebStatFilter)
* Druid提供了`WallFilter`，它是基于SQL语义分析来实现防御SQL注入攻击的。[官方文档 - 配置 wallfilter](https://github.com/alibaba/druid/wiki/配置-wallfilter)
```java
@Configuration
public class MyConfig {
@Bean
@ConfigurationProperties("spring.datasource")
public DataSource dataSource() throws SQLException {
DruidDataSource druidDataSource = new DruidDataSource();
//加入监控和防火墙功能功能
druidDataSource.setFilters("stat,wall");
return druidDataSource;
}
/**
* 配置 druid的监控页功能
* @return
*/
@Bean
public ServletRegistrationBean statViewServlet(){
StatViewServlet statViewServlet = new StatViewServlet();
ServletRegistrationBean registrationBean =
new ServletRegistrationBean<>(statViewServlet, "/druid/*");
//监控页账号密码：
registrationBean.addInitParameter("loginUsername","admin");
registrationBean.addInitParameter("loginPassword","123456");
return registrationBean;
}
/**
* WebStatFilter 用于采集web-jdbc关联监控的数据。
*/
@Bean
public FilterRegistrationBean webStatFilter(){
WebStatFilter webStatFilter = new WebStatFilter();
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546
```
### 62、数据访问-druid数据源starter整合方式
[官方文档 - Druid Spring Boot Starter](https://blog.csdn.net/u011863024/article/details/113667946)
**引入依赖**：
```xml
com.alibaba
druid-spring-boot-starter
1.1.17
12345
```
**分析自动配置**：
* 扩展配置项 `spring.datasource.druid`
* 自动配置类`DruidDataSourceAutoConfigure`
* `DruidSpringAopConfiguration.class`, 监控SpringBean的；配置项：`spring.datasource.druid.aop-patterns`
* `DruidStatViewServletConfiguration.class`, 监控页的配置。`spring.datasource.druid.stat-view-servlet`默认开启。
* `DruidWebStatFilterConfiguration.class`，web监控配置。`spring.datasource.druid.web-stat-filter`默认开启。
* `DruidFilterConfiguration.class`所有Druid的filter的配置：
```java
private static final String FILTER_STAT_PREFIX = "spring.datasource.druid.filter.stat";
private static final String FILTER_CONFIG_PREFIX = "spring.datasource.druid.filter.config";
private static final String FILTER_ENCODING_PREFIX = "spring.datasource.druid.filter.encoding";
private static final String FILTER_SLF4J_PREFIX = "spring.datasource.druid.filter.slf4j";
private static final String FILTER_LOG4J_PREFIX = "spring.datasource.druid.filter.log4j";
private static final String FILTER_LOG4J2_PREFIX = "spring.datasource.druid.filter.log4j2";
private static final String FILTER_COMMONS_LOG_PREFIX = "spring.datasource.druid.filter.commons-log";
private static final String FILTER_WALL_PREFIX = "spring.datasource.druid.filter.wall";
12345678
```
**配置示例**：
```yaml
spring:
datasource:
url: jdbc:mysql://localhost:3306/db_account
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
druid:
aop-patterns: com.atguigu.admin.* #监控SpringBean
filters: stat,wall # 底层开启功能，stat（sql监控），wall（防火墙）
stat-view-servlet: # 配置监控页功能
enabled: true
login-username: admin
login-password: admin
resetEnable: false
web-stat-filter: # 监控web
enabled: true
urlPattern: /*
exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'
filter:
stat: # 对上面filters里面的stat的详细配置
slow-sql-millis: 1000
logSlowSql: true
enabled: true
wall:
enabled: true
config:
drop-table-allow: false
1234567891011121314151617181920212223242526272829303132
```
### 63、数据访问-整合MyBatis-配置版
[MyBatis的GitHub仓库](https://github.com/mybatis)
[MyBatis官方](https://mybatis.org/mybatis-3/zh/index.html)
**starter的命名方式**：
1. SpringBoot官方的Starter：`spring-boot-starter-*`
2. 第三方的： `*-spring-boot-starter`
**引入依赖**：
```xml
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.1.4
12345
```
**配置模式**:
* 全局配置文件
* `SqlSessionFactory`：自动配置好了
* `SqlSession`：自动配置了`SqlSessionTemplate` 组合了`SqlSession`
* `@Import(AutoConfiguredMapperScannerRegistrar.class)`
* `Mapper`： 只要我们写的操作MyBatis的接口标准了`@Mapper`就会被自动扫描进来
```java
@EnableConfigurationProperties(MybatisProperties.class) ： MyBatis配置项绑定类。
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration{
...
}
@ConfigurationProperties(prefix = "mybatis")
public class MybatisProperties{
...
}
12345678910
```
***
**配置文件**：
```yaml
spring:
datasource:
username: root
password: 1234
url: jdbc:mysql://localhost:3306/my
driver-class-name: com.mysql.jdbc.Driver
# 配置mybatis规则
mybatis:
config-location: classpath:mybatis/mybatis-config.xml #全局配置文件位置
mapper-locations: classpath:mybatis/*.xml #sql映射文件位置
1234567891011
```
**mybatis-config.xml**:
```xml
12345678
```
**Mapper接口**：
```xml
select * from user where id=#{id}
12345678910
import com.lun.boot.bean.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface UserMapper {
public User getUser(Integer id);
}
1234567
```
**POJO**：
```java
public class User {
private Integer id;
private String name;
//getters and setters...
}
123456
```
**DB**：
```sql
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(45) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;
12345
```
**Controller and Service**：
```java
@Controller
public class UserController {
@Autowired
private UserService userService;
@ResponseBody
@GetMapping("/user/{id}")
public User getUser(@PathVariable("id") Integer id){
return userService.getUser(id);
}
}
@Service
public class UserService {
@Autowired
private UserMapper userMapper;//IDEA下标红线，可忽视这红线
public User getUser(Integer id){
return userMapper.getUser(id);
}
}
```
配置`private Configuration configuration;` 也就是配置`mybatis.configuration`相关的，就是相当于改mybatis全局配置文件中的值。（也就是说配置了`mybatis.configuration`，就不需配置mybatis全局配置文件了）
```yaml
# 配置mybatis规则
mybatis:
mapper-locations: classpath:mybatis/mapper/*.xml
# 可以不写全局配置文件，所有全局配置文件的配置都放在configuration配置项中了。
# config-location: classpath:mybatis/mybatis-config.xml
configuration:
map-underscore-to-camel-case: true
1234567
```
#### 小结
* 导入MyBatis官方Starter。
* 编写Mapper接口，需`@Mapper`注解。
* 编写SQL映射文件并绑定Mapper接口。
* 在`application.yaml`中指定Mapper配置文件的所处位置，以及指定全局配置文件的信息 （建议：**配置在`mybatis.configuration`**）。
### 64、数据访问-整合MyBatis-注解配置混合版
你可以通过Spring Initializr添加MyBatis的Starer。
**注解与配置混合搭配，干活不累**：
```java
@Mapper
public interface UserMapper {
public User getUser(Integer id);
@Select("select * from user where id=#{id}")
public User getUser2(Integer id);
public void saveUser(User user);
@Insert("insert into user(`name`) values(#{name})")
@Options(useGeneratedKeys = true, keyProperty = "id")
public void saveUser2(User user);
}
select * from user where id=#{id}
insert into user(`name`) values(#{name})
123456789101112131415
```
* 简单DAO方法就写在注解上。复杂的就写在配置文件里。
* 使用`@MapperScan("com.lun.boot.mapper")` 简化，Mapper接口就可以不用标注`@Mapper`注解。
```java
@MapperScan("com.lun.boot.mapper")
@SpringBootApplication
public class MainApplication {
public static void main(String[] args) {
SpringApplication.run(MainApplication.class, args);
}
}
123456789
```
### 65、数据访问-整合MyBatisPlus操作数据库
[IDEA的MyBatis的插件 - MyBatisX](https://plugins.jetbrains.com/plugin/10119-mybatisx)
[MyBatisPlus官网](https://baomidou.com/)
[MyBatisPlus官方文档](https://baomidou.com/guide/)
#### MyBatisPlus是什么
[MyBatis-Plus](https://github.com/baomidou/mybatis-plus)（简称 MP）是一个 [MyBatis](http://www.mybatis.org/mybatis-3/)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
***
添加依赖：
```xml
com.baomidou
mybatis-plus-boot-starter
3.4.1
12345
```
* `MybatisPlusAutoConfiguration`配置类，`MybatisPlusProperties`配置项绑定。
* `SqlSessionFactory`自动配置好，底层是容器中默认的数据源。
* `mapperLocations`自动配置好的，有默认值`classpath*:/mapper/**/*.xml`，这表示任意包的类路径下的所有mapper文件夹下任意路径下的所有xml都是sql映射文件。 建议以后sql映射文件放在 mapper下。
* 容器中也自动配置好了`SqlSessionTemplate`。
* `@Mapper` 标注的接口也会被自动扫描，建议直接 `@MapperScan("com.lun.boot.mapper")`批量扫描。
* MyBatisPlus**优点**之一：只需要我们的Mapper继承MyBatisPlus的`BaseMapper` 就可以拥有CRUD能力，减轻开发工作。
```java
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.lun.hellomybatisplus.model.User;
public interface UserMapper extends BaseMapper {
}
```
### 66、数据访问-CRUD实验-数据列表展示
[官方文档 - CRUD接口](https://baomidou.com/guide/crud-interface.html)
使用MyBatis Plus提供的`IService`，`ServiceImpl`，减轻Service层开发工作。
```java
import com.lun.hellomybatisplus.model.User;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* Service 的CRUD也不用写了
*/
public interface UserService extends IService {
//此处故意为空
}
import com.lun.hellomybatisplus.model.User;
import com.lun.hellomybatisplus.mapper.UserMapper;
import com.lun.hellomybatisplus.service.UserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl extends ServiceImpl implements UserService {
//此处故意为空
}
```
与下一节联合在一起
### 67、数据访问-CRUD实验-分页数据展示
与下一节联合在一起
### 68、数据访问-CRUD实验-删除用户完成
添加分页插件：
```java
@Configuration
public class MyBatisConfig {
/**
* MybatisPlusInterceptor
* @return
*/
@Bean
public MybatisPlusInterceptor paginationInterceptor() {
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
// 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求 默认false
// paginationInterceptor.setOverflow(false);
// 设置最大单页限制数量，默认 500 条，-1 不受限制
// paginationInterceptor.setLimit(500);
// 开启 count 的 join 优化,只针对部分 left join
//这是分页拦截器
PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
paginationInnerInterceptor.setOverflow(true);
paginationInnerInterceptor.setMaxLimit(500L);
mybatisPlusInterceptor.addInnerInterceptor(paginationInnerInterceptor);
return mybatisPlusInterceptor;
}
}
#
name
age
email
操作
[[${user.name}]]
Win 95+
4
删除
当前第[[${users.current}]]页 总计 [[${users.pages}]]页 共[[${users.total}]]条记录
1234567891011121314151617181920212223242526272829303132333435363738394041424344
```
`#numbers`表示methods for formatting numeric objects.[link](https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#expression-utility-objects)
```java
@GetMapping("/user/delete/{id}")
public String deleteUser(@PathVariable("id") Long id,
@RequestParam(value = "pn",defaultValue = "1")Integer pn,
RedirectAttributes ra){
userService.removeById(id);
ra.addAttribute("pn",pn);
return "redirect:/dynamic_table";
}
@GetMapping("/dynamic_table")
public String dynamic_table(@RequestParam(value="pn",defaultValue = "1") Integer pn,Model model){
//表格内容的遍历
//从数据库中查出user表中的用户进行展示
//构造分页参数
Page page = new Page<>(pn, 2);
//调用page进行分页
Page userPage = userService.page(page, null);
model.addAttribute("users",userPage);
return "table/dynamic_table";
}
1234567891011121314151617181920212223242526
```
### 69、数据访问-准备阿里云Redis环境
**添加依赖**：
```xml
org.springframework.boot
spring-boot-starter-data-redis
redis.clients
jedis
```
* `RedisAutoConfiguration`自动配置类，RedisProperties 属性类 --> spring.redis.xxx是对redis的配置。
* 连接工厂`LettuceConnectionConfiguration`、`JedisConnectionConfiguration`是准备好的。
* 自动注入了`RedisTemplate`，`xxxTemplate`。
* 自动注入了`StringRedisTemplate`，key，value都是String
* 底层只要我们使用`StringRedisTemplate`、`RedisTemplate`就可以操作Redis。
**外网Redis环境搭建**：
1. 阿里云按量付费Redis，其中选择**经典网络**。
2. 申请Redis的公网连接地址。
3. 修改白名单，允许`0.0.0.0/0`访问。
### 70、数据访问-Redis操作与统计小实验
相关Redis配置：
```java
spring:
redis:
# url: redis://lfy:Lfy123456@r-bp1nc7reqesxisgxpipd.redis.rds.aliyuncs.com:6379
host: r-bp1nc7reqesxisgxpipd.redis.rds.aliyuncs.com
port: 6379
password: lfy:Lfy123456
client-type: jedis
jedis:
pool:
max-active: 10
# lettuce:# 另一个用来连接redis的java框架
# pool:
# max-active: 10
# min-idle: 5
1234567891011121314
```
测试Redis连接：
```java
@SpringBootTest
public class Boot05WebAdminApplicationTests {
@Autowired
StringRedisTemplate redisTemplate;
@Autowired
RedisConnectionFactory redisConnectionFactory;
@Test
void testRedis(){
ValueOperations operations = redisTemplate.opsForValue();
operations.set("hello","world");
String hello = operations.get("hello");
System.out.println(hello);
System.out.println(redisConnectionFactory.getClass());
}
}
1234567891011121314151617181920212223
```
Redis Desktop Manager：可视化Redis管理软件。
URL统计拦截器：
```java
@Component
public class RedisUrlCountInterceptor implements HandlerInterceptor {
@Autowired
StringRedisTemplate redisTemplate;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String uri = request.getRequestURI();
//默认每次访问当前uri就会计数+1
redisTemplate.opsForValue().increment(uri);
return true;
}
}
12345678910111213141516
```
注册URL统计拦截器：
```java
@Configuration
public class AdminWebConfig implements WebMvcConfigurer{
@Autowired
RedisUrlCountInterceptor redisUrlCountInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(redisUrlCountInterceptor)
.addPathPatterns("/**")
.excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**",
"/js/**","/aa/**");
}
}
12345678910111213141516
```
Filter、Interceptor 几乎拥有相同的功能？
* Filter是Servlet定义的原生组件，它的好处是脱离Spring应用也能使用。
* Interceptor是Spring定义的接口，可以使用Spring的自动装配等功能。
调用Redis内的统计数据：
```java
@Slf4j
@Controller
public class IndexController {
@Autowired
StringRedisTemplate redisTemplate;
@GetMapping("/main.html")
public String mainPage(HttpSession session,Model model){
log.info("当前方法是：{}","mainPage");
ValueOperations opsForValue =
redisTemplate.opsForValue();
String s = opsForValue.get("/main.html");
String s1 = opsForValue.get("/sql");
model.addAttribute("mainCount",s);
model.addAttribute("sqlCount",s1);
return "main";
}
}
123456789101112131415161718192021222324
```
### 71、单元测试-JUnit5简介
**Spring Boot 2.2.0 版本开始引入 JUnit 5 作为单元测试默认库**
[JUnit 5官方文档](https://junit.org/junit5/docs/current/user-guide/#writing-tests-annotations)
作为最新版本的JUnit框架，JUnit5与之前版本的JUnit框架有很大的不同。由三个不同子项目的几个不同模块组成。
**JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage**
* **JUnit Platform**: Junit Platform是在JVM上启动测试框架的基础，不仅支持Junit自制的测试引擎，其他测试引擎也都可以接入。
* **JUnit Jupiter**: JUnit Jupiter提供了JUnit5的新的编程模型，是JUnit5新特性的核心。内部包含了一个**测试引擎**，用于在Junit Platform上运行。
* **JUnit Vintage**: 由于JUint已经发展多年，为了照顾老的项目，JUnit Vintage提供了兼容JUnit4.x，JUnit3.x的测试引擎。
**注意**：
* SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖。如果需要兼容JUnit4需要自行引入（不能使用JUnit4的功能 @Test）
* JUnit 5’s Vintage已经从`spring-boot-starter-test`从移除。如果需要继续兼容Junit4需要自行引入Vintage依赖：
```xml
org.junit.vintage
junit-vintage-engine
test
org.hamcrest
hamcrest-core
1234567891011
```
* 使用添加JUnit 5，添加对应的starter：
```xml
org.springframework.boot
spring-boot-starter-test
test
12345
```
* Spring的JUnit 5的基本单元测试模板（Spring的JUnit4的是`@SpringBootTest`+`@RunWith(SpringRunner.class)`）：
```java
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;//注意不是org.junit.Test（这是JUnit4版本的）
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SpringBootApplicationTests {
@Autowired
private Component component;
@Test
//@Transactional 标注后连接数据库有回滚功能
public void contextLoads() {
Assertions.assertEquals(5, component.getFive());
}
}
1234567891011121314151617
```
> Jupiter
>
> 英 \[ˈdʒuːpɪtə®] 美 \[ˈdʒuːpɪtər]
>
> n. 木星(太阳系中最大的行星)
> vintage
>
> 英 \[ˈvɪntɪdʒ] 美 \[ˈvɪntɪdʒ]
>
> n. 特定年份(或地方)酿制的酒;酿造年份;采摘葡萄酿酒的期间(或季节);葡萄收获期(或季节)
>
> adj. (指葡萄酒)优质的，上等的，佳酿的;古色古香的(指1917–1930年间制造，车型和品味受人青睐的);(过去某个时期)典型的，优质的;(某人的)最佳作品的
### 72、单元测试-常用测试注解
[官方文档 - Annotations](https://junit.org/junit5/docs/current/user-guide/#writing-tests-annotations)
* **@Test**：表示方法是测试方法。但是与JUnit4的@Test不同，他的职责非常单一不能声明任何属性，拓展的测试将会由Jupiter提供额外测试
* **@ParameterizedTest**：表示方法是参数化测试。
* **@RepeatedTest**：表示方法可重复执行。
* **@DisplayName**：为测试类或者测试方法设置展示名称。
* **@BeforeEach**：表示在**每个**单元测试**之前**执行。
* **@AfterEach**：表示在**每个**单元测试**之后**执行。
* **@BeforeAll**：表示在**所有**单元测试**之前**执行。
* **@AfterAll**：表示在**所有**单元测试**之后**执行。
* **@Tag**：表示单元测试类别，类似于JUnit4中的@Categories。
* **@Disabled**：表示测试类或测试方法不执行，类似于JUnit4中的@Ignore。
* **@Timeout**：表示测试方法运行如果超过了指定时间将会返回错误。
* **@ExtendWith**：为测试类或测试方法提供扩展类引用。
```java
import org.junit.jupiter.api.*;
@DisplayName("junit5功能测试类")
public class Junit5Test {
@DisplayName("测试displayname注解")
@Test
void testDisplayName() {
System.out.println(1);
System.out.println(jdbcTemplate);
}
@ParameterizedTest
@ValueSource(strings = { "racecar", "radar", "able was I ere I saw elba" })
void palindromes(String candidate) {
assertTrue(StringUtils.isPalindrome(candidate));
}
@Disabled
@DisplayName("测试方法2")
@Test
void test2() {
System.out.println(2);
}
@RepeatedTest(5)
@Test
void test3() {
System.out.println(5);
}
/**
* 规定方法超时时间。超出时间测试出异常
*
* @throws InterruptedException
*/
@Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
@Test
void testTimeout() throws InterruptedException {
Thread.sleep(600);
}
@BeforeEach
void testBeforeEach() {
System.out.println("测试就要开始了...");
}
@AfterEach
void testAfterEach() {
System.out.println("测试结束了...");
}
@BeforeAll
static void testBeforeAll() {
System.out.println("所有测试就要开始了...");
}
@AfterAll
static void testAfterAll() {
System.out.println("所有测试以及结束了...");
}
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
```
### 73、单元测试-断言机制
断言Assertion是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言方法都是org.junit.jupiter.api.Assertions的静态方法。检查业务逻辑返回的数据是否合理。所有的测试运行结束以后，会有一个详细的测试报告。
JUnit 5 内置的断言可以分成如下几个类别：
#### 简单断言
用来对单个值进行简单的验证。如：
| 方法 | 说明 |
| --------------- | ------------------ |
| assertEquals | 判断两个对象或两个原始类型是否相等 |
| assertNotEquals | 判断两个对象或两个原始类型是否不相等 |
| assertSame | 判断两个对象引用是否指向同一个对象 |
| assertNotSame | 判断两个对象引用是否指向不同的对象 |
| assertTrue | 判断给定的布尔值是否为 true |
| assertFalse | 判断给定的布尔值是否为 false |
| assertNull | 判断给定的对象引用是否为 null |
| assertNotNull | 判断给定的对象引用是否不为 null |
```java
@Test
@DisplayName("simple assertion")
public void simple() {
assertEquals(3, 1 + 2, "simple math");
assertNotEquals(3, 1 + 1);
assertNotSame(new Object(), new Object());
Object obj = new Object();
assertSame(obj, obj);
assertFalse(1 > 2);
assertTrue(1 < 2);
assertNull(null);
assertNotNull(new Object());
}
12345678910111213141516
```
#### 数组断言
通过 assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等。
```java
@Test
@DisplayName("array assertion")
public void array() {
assertArrayEquals(new int[]{1, 2}, new int[] {1, 2});
}
12345
```
#### 组合断言
`assertAll()`方法接受多个 `org.junit.jupiter.api.Executable` 函数式接口的实例作为要验证的断言，可以通过 lambda 表达式很容易的提供这些断言。
```java
@Test
@DisplayName("assert all")
public void all() {
assertAll("Math",
() -> assertEquals(2, 1 + 1),
() -> assertTrue(1 > 0)
);
}
12345678
```
#### 异常断言
在JUnit4时期，想要测试方法的异常情况时，需要用`@Rule`注解的`ExpectedException`变量还是比较麻烦的。而JUnit5提供了一种新的断言方式`Assertions.assertThrows()`，配合函数式编程就可以进行使用。
```java
@Test
@DisplayName("异常测试")
public void exceptionTest() {
ArithmeticException exception = Assertions.assertThrows(
//扔出断言异常
ArithmeticException.class, () -> System.out.println(1 % 0));
}
1234567
```
#### 超时断言
JUnit5还提供了Assertions.assertTimeout()为测试方法设置了超时时间。
```java
@Test
@DisplayName("超时测试")
public void timeoutTest() {
//如果测试方法时间超过1s将会异常
Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(500));
}
123456
```
#### 快速失败
通过 fail 方法直接使得测试失败。
```java
@Test
@DisplayName("fail")
public void shouldFail() {
fail("This should fail");
}
12345
```
### 74、单元测试-前置条件
Unit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于不满足的**断言assertions**会使得测试方法失败，而**不满足的前置条件只会使得测试方法的执行终止**。
前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要。
```java
@DisplayName("前置条件")
public class AssumptionsTest {
private final String environment = "DEV";
@Test
@DisplayName("simple")
public void simpleAssume() {
assumeTrue(Objects.equals(this.environment, "DEV"));
assumeFalse(() -> Objects.equals(this.environment, "PROD"));
}
@Test
@DisplayName("assume then do")
public void assumeThenDo() {
assumingThat(
Objects.equals(this.environment, "DEV"),
() -> System.out.println("In DEV")
);
}
}
1234567891011121314151617181920
```
`assumeTrue` 和 `assumFalse` 确保给定的条件为 `true` 或 `false`，不满足条件会使得测试执行终止。
`assumingThat` 的参数是表示条件的布尔值和对应的 Executable 接口的实现对象。只有条件满足时，`Executable` 对象才会被执行；当条件不满足时，测试执行并不会终止。
### 75、单元测试-嵌套测试
[官方文档 - Nested Tests](https://junit.org/junit5/docs/current/user-guide/#writing-tests-nested)
JUnit 5 可以通过 Java 中的内部类和`@Nested` 注解实现嵌套测试，从而可以更好的把相关的测试方法组织在一起。在内部类中可以使用`@BeforeEach` 和`@AfterEach`注解，而且嵌套的层次没有限制。
```java
@DisplayName("A stack")
class TestingAStackDemo {
Stack stack;
@Test
@DisplayName("is instantiated with new Stack()")
void isInstantiatedWithNew() {
new Stack<>();
}
@Nested
@DisplayName("when new")
class WhenNew {
@BeforeEach
void createNewStack() {
stack = new Stack<>();
}
@Test
@DisplayName("is empty")
void isEmpty() {
assertTrue(stack.isEmpty());
}
@Test
@DisplayName("throws EmptyStackException when popped")
void throwsExceptionWhenPopped() {
assertThrows(EmptyStackException.class, stack::pop);
}
@Test
@DisplayName("throws EmptyStackException when peeked")
void throwsExceptionWhenPeeked() {
assertThrows(EmptyStackException.class, stack::peek);
}
@Nested
@DisplayName("after pushing an element")
class AfterPushing {
String anElement = "an element";
@BeforeEach
void pushAnElement() {
stack.push(anElement);
}
@Test
@DisplayName("it is no longer empty")
void isNotEmpty() {
assertFalse(stack.isEmpty());
}
@Test
@DisplayName("returns the element when popped and is empty")
void returnElementWhenPopped() {
assertEquals(anElement, stack.pop());
assertTrue(stack.isEmpty());
}
@Test
@DisplayName("returns the element when peeked but remains not empty")
void returnElementWhenPeeked() {
assertEquals(anElement, stack.peek());
assertFalse(stack.isEmpty());
}
}
}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
```
### 76、单元测试-参数化测试
[官方文档 - Parameterized Tests](https://junit.org/junit5/docs/current/user-guide/#writing-tests-parameterized-tests)
参数化测试是JUnit5很重要的一个新特性，它使得用不同的参数多次运行测试成为了可能，也为我们的单元测试带来许多便利。
利用@ValueSource等注解，指定入参，我们将可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试，省去了很多冗余代码。
利用\*\*@ValueSource\*\*等注解，指定入参，我们将可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试，省去了很多冗余代码。
* **@ValueSource**: 为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型
* **@NullSource**: 表示为参数化测试提供一个null的入参
* **@EnumSource**: 表示为参数化测试提供一个枚举入参
* **@CsvFileSource**：表示读取指定CSV文件内容作为参数化测试入参
* **@MethodSource**：表示读取指定方法的返回值作为参数化测试入参(注意方法返回需要是一个流)
当然如果参数化测试仅仅只能做到指定普通的入参还达不到让我觉得惊艳的地步。让我真正感到他的强大之处的地方在于他可以支持外部的各类入参。如:CSV,YML,JSON 文件甚至方法的返回值也可以作为入参。只需要去实现\*\*`ArgumentsProvider`\*\*接口，任何外部文件都可以作为它的入参。
```java
@ParameterizedTest
```