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
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);
}
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