先说一些废话

尽管我的工作中更多的是与数据库打交道，然而作为一个Coder，我感觉把握前后端的Web技术来说是十分有必要的。

不仅能够帮忙咱们在工作中更好的了解其余岗位与你对接的人他的工作痛点，也能在公司须要人手的时候成为一个无力的应急帮手，比方之前公司的数据中台我就参加架构和局部开发工作，更重要的是我私下里能够使用一些疾速框架来搭建一些有意思的网站，比方我的个人主页和集体博客都是我自学java和js所做进去的作品。

所以明天我心愿整合一些我以往的教训和看过的教程文档，来写一篇文章，帮忙你在一天之内通过这篇文章疾速学习SpringBoot框架以及各种开发必备的工具与插件！！！

MVC

什么是MVC

  1. MVC三层架构是指：视图层 View、服务层 Service，与长久层 Dao，它们别离实现不同的性能

    • View 层：用于接管用户提交申请的代码在这里编写
    • Service 层：零碎的业务逻辑次要在这里实现
    • Dao 层：间接操作数据库的代码在这里编写
  2. 为了更好的升高各层间的耦合度，在三层架构程序设计中，采纳面向形象编程，即下层对上层的调用，是通过接口实现的，而上层对下层的真正服务提供者，是上层接口的实现类
  3. 服务规范（接口）是雷同的，服务提供者（实现类）能够更换，这就实现了层间解耦合

MVC 架构程序的工作流程

  1. 用户通过 View 页面向服务端提出申请，能够是表单申请、超链接申请、AJAX 申请等
  2. 服务端 Controller 控制器接收到申请后对申请进行解析，找到相应的 Model 对用户申请进行解决
  3. Model 解决后，将处理结果再交给 Controller
  4. Controller 在接到处理结果后，依据处理结果找到要作为向客户端发回的响应 View 页面，页面经渲染（数据填充）后，再发送给客户端

应用xml还是注解

  1. 利用的根本配置应用xml，比方数据源和资源文件等
  2. 业务开发应用注解，比方service注入bean
  3. 然而xml越来越多导致越来越臃肿，最终倒退到应用齐全基于注解开发

注解

申明Bean注解

@Component 组件没有明确规定其角色，作用在类级别上申明以后类为一个业务组件，被Spring IOC 容器保护
@Service 在业务逻辑层（Service）类级别进行申明
@Registory 在数据拜访层（Dao）类级别进行申明
@Controller 在展示层（MVC）应用，标注以后类为一个控制器

注入Bean注解

@Autowired 它能够对类成员变量、办法及构造函数进行标注，实现主动拆卸的工作，通过@Autowired的应用来打消set、get办法
@Inject 作用同上，是JSR-330 规范
@Resource 作用同上，是JSR-250 规范
以上三种注解在Set办法或属性上申明，个别状况下更习惯申明在属性上，代码简洁清晰

配置与获取Bean注解

@Configuration 将以后类申明为一个配置类，相当于一个xml配置文件
@ComponentScan 主动扫描包下标注有@Repository @Service @Controller
@Component 注解的类并有Spring IOC 容器进行实例化和保护
@Bean 作用于办法上，申明以后办法的返回值是一个Bean对象，相当于xml文件中<bean>申明以后办法返回一个bean对象
@Value 获取properties文件指定的key/value

pom.xml

作用是增加坐标相干配置，次要是各种依赖jar包

组合注解和元注解

所谓元注解其实就是能够注解到别的注解上的注解，被注解的注解称之为组合注解，组合注解具备元注解的性能，次要的作用是打消反复注解

自定义注解

个性化的定义本人所须要的性能并申明一个注解，简化工程，能够参考文章————SPRINGBOOT自定义注解学习

罕用注解

能够参考文章————SpringBoot罕用注解汇合具体学习，这里前期会补上阐明

@RestController、@ResponseBody、@RequestBody

  1. 相当于@Controller + @ResponseBody两个注解的联合，返回JSON数据不须要在办法后面加@ResponseBody注解了，
    但应用@RestController这个注解，就不能返回jsp、html页面，视图解析器无奈解析jsp、html页面v
  2. @ResponseBody示意该办法的返回后果间接写入HTTP response body中，个别在异步获取数据时应用（也就是AJAX），
    在应用@RequestMapping后，返回值通常解析为跳转门路，然而加上@ResponseBody后返回后果不会被解析为跳转门路，而是间接写入HTTP response body中，
    比方异步获取JSON数据，加上@ResponseBody后，会间接返回JSON数据

  3. @RequestBody将 HTTP 申请注释插入方法中，应用适宜的 HttpMessageConverter 将申请体写入某个对象

    @MapperScan、@Mapper

  4. @Mapper注解：

    • 作用：在接口类上增加了@Mapper，在编译之后会生成相应的接口实现类
    • 增加地位：接口类下面
    • 如果想要每个接口都要变成实现类，那么须要在每个接口类上加上@Mapper注解，比拟麻烦，解决这个问题用@MapperScan注解

  5. @MapperScan注解：

    • 作用：指定要变成实现类的接口所在的包，而后包上面的所有接口在编译之后都会生成相应的实现类
    • 增加地位：是在Springboot启动类下面增加
    • 增加@MapperScan("com.winter.da")注解当前，com.winter.dao包上面的接口类，在编译之后都会生成相应的实现类

习惯大于配置指标

Spring Boot 的指标是疾速运行，疾速创立web利用，并独立机型部署（jar包形式，war包形式），相比于Spring框架是全新重写的框架

外围配置

批改Banner图标

次要是通过批改/src/main/resources目录下的banner.txt文件，如果没有则默认应用SpringBoot初始Banner
能够个性化制作Banner的网站制订相应的txt文件

全局配置

默认是application.properties或者application.yml
坐标依赖都配置在pom.xml中，如果增加了依赖当前标红能够应用Maven -> Reload project即可

入口类依附组合注解@SpringBootApplication

@SpringBootConfiguration 自身是一个配置类，启动类启动的时候会加载
@EnableAutoConfiguration 组合了@AutoConfigurationPackage&@Import(AutoConfigurationImportSelector.class)
@AutoConfigurationPackage 底层是一个@Import(AutoConfigurationPackage.Registrar.class)，其会把启动类的包下组合都扫描到Spring容器中
@AutoConfigurationImportSelector 读取大量的主动配置类，实现主动配置，其读取的是classpath下的META-INF/spring.factories下的配置文件
@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(    excludeFilters = {@Filter(    type = FilterType.CUSTOM,    classes = {TypeExcludeFilter.class}), @Filter(    type = FilterType.CUSTOM,    classes = {AutoConfigurationExcludeFilter.class})})

Profile配置————辨别生产和开发环境

通过在application.yml中设置spring.profiles.active=test/dev/prod来动静切换不同环境，例如：

# 开发环境配置文件application-dev.ymlserver:  prot: 8098# 测试环境配置文件application-test.ymlserver:  prot: 8097# 生产环境配置文件application-prod.ymlserver:  prot: 8099# 主配置文件application.ymlspring:  profiles:    active: dev

日志配置

SpringBoot默认应用LogBack日志零碎，个别支流的日志都是用log4j日志零碎

如果反复启动Spring我的项目，可能会有端口占用的报错

  1. 思路是杀死占用端口的过程即可，次要是上面两个命令
  2. 应用netstat -aon|findstr "被占用的端口"或者tasklist |findstr "过程名称"查问到端口的过程号
  3. 应用taskkill /f /t /im "过程名称"或者taskkill /f /t /pid "过程PID"杀死过程即可

事务管制

申明式事务

能够参考文章————SpringBoot申明式事务的简略使用具体学习，这里前期会补上阐明
次要利用在新增批改删除上，利用注解即可

全局异样

应用@ControllerAdvice配合@ExceptionHandler

能够参考文章————Springboot系列-@ControllerAdvice应用具体学习，这里前期会补上阐明
此注解其实是一个加强的Controller，应用这个Controller，可实现三个方面的性能，因为这是SpringMVC提供的性能，所以能够在springboot中间接应用

  1. 全局异样解决 （@ExceptionHandler）
  2. 全局数据绑定 （@InitBinder）

  3. 全局数据预处理 （@ModelAttribute）

    package com.fx67ll.springboot.exceptions;import com.fx67ll.springboot.po.vo.ResultInfo;import org.springframework.web.bind.annotation.ControllerAdvice;import org.springframework.web.bind.annotation.ExceptionHandler;import org.springframework.web.bind.annotation.ResponseBody;@ControllerAdvicepublic class TestGlobalExceptionHandler { @ExceptionHandler(value = Exception.class) @ResponseBody public ResultInfo exceptionHandler(Exception exception) {     ResultInfo resultInfo = new ResultInfo();     resultInfo.setCode(978);     resultInfo.setMsg("全局异样拦挡，操作失败！");//        if (exception instanceof ParamsException) {//            ParamsException paramsException = (ParamsException) exception;//            resultInfo.setMsg(paramsException.getMsg());//            resultInfo.setCode(paramsException.getCode());//        }     return resultInfo; }}

数据校验

为什么要进行后端数据校验

数据的校验是交互式网站一个不可或缺的性能，前端的js校验能够涵盖大部分的校验职责，如用户名唯一性，生日格局，邮箱格局校验等等罕用的校验。
然而个别前端传来的数据是不可信的，前端校验过了，后端也应该从新校验，因为不排除用户绕过浏览器间接通过Http工具向后端申请的状况。
所以服务端的数据校验也是必要的，能够避免脏数据落到数据库中，如果数据库中呈现一个非法的邮箱格局，也会让运维人员头疼不已。

如何进行后端数据校验

  1. SpringBoot中个别应用Spring Validation来进行后端数据校验，它是对Hibernate Validation进行了二次封装，
    在SpringMVC模块中增加了主动校验，并将校验信息封装进了特定的类中
  2. 在应用时咱们只须要引入spring-boot-starter-web依赖即可，该模块会主动依赖spring-boot-starter-validation

Spring Validation 罕用注解

@Null：被正文的元素必须为null
@NotNull：被正文的元素不能为null，能够为空字符串
@AssertTrue：被正文的元素必须为true
@AssertFalse：被正文的元素必须为false
@Min(value)：被正文的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value)：被正文的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value)：被正文的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value)：被正文的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max,min)：被正文的元素的大小必须在指定的范畴内
@Digits(integer,fraction)：被正文的元素必须是一个数字，其值必须在可承受的范畴内
@Past：被正文的元素必须是一个过来的日期
@Future：被正文的元素必须是一个未来的日期
@Pattern(value)：被正文的元素必须合乎指定的正则表达式
@Email：被正文的元素必须是电子邮件地址
@Length：被正文的字符串的大小必须在指定的范畴内
@Range：被正文的元素必须在适合的范畴内
@URL：被注解的元素必须是一个URL
@NotEmpty：用在汇合类上，不能为null，并且长度必须大于0
@NotBlank：只能作用在String上，不能为null，而且调用trim()后，长度必须大于0

自定义注解

能够参考文章————Spring自定义注解(validation)具体学习，这里前期会补上阐明

示例代码

  1. /com/fx67ll/springboot/controller/UserController.java在传参的地位增加@Vaild注解示意这里的参数须要校验，须要留神JSON格局和表单格局传过来的参数异样会有些区别，须要在前面留神

    // 增加用户@PutMapping("/adduser")public ResultInfo saveUser(@RequestBody @Valid User user) {    ResultInfo resultInfo = new ResultInfo();    userService.saveUser(user);    return resultInfo;}

  2. 在Bean文件/com/fx67ll/springboot/dao/User.java中公有字段上应用注解来校验，不贴所有代码了，仅贴局部重点代码

    @NotBlank(message = "用户名称不能为空！")private String userName;@NotBlank(message = "用户明码不能为空！")@Length(min = 6, max = 20, message = "明码长度起码六位且最多二十位！")private String userPwd;

  3. 在全局自定义异样拦挡中/com/fx67ll/springboot/exceptions/TestGlobalExceptionHandler.java向用户返回错误代码和信息

    package com.fx67ll.springboot.exceptions;import com.fx67ll.springboot.po.vo.ResultInfo;import org.springframework.web.bind.MethodArgumentNotValidException;import org.springframework.web.bind.annotation.ControllerAdvice;import org.springframework.web.bind.annotation.ExceptionHandler;import org.springframework.web.bind.annotation.ResponseBody;@ControllerAdvicepublic class TestGlobalExceptionHandler {    @ExceptionHandler(value = Exception.class)    @ResponseBody    public ResultInfo exceptionHandler(Exception exception) {        ResultInfo resultInfo = new ResultInfo();        resultInfo.setCode(978);        resultInfo.setMsg("全局异样拦挡，操作失败！");        // 全局数据校验，留神！！！应用 json 申请体调用接口，校验异样抛出 MethodArgumentNotValidException        if (exception instanceof MethodArgumentNotValidException) {            MethodArgumentNotValidException methodArgumentNotValidException = (MethodArgumentNotValidException) exception;            resultInfo.setCode(1023);            resultInfo.setMsg(methodArgumentNotValidException.getBindingResult().getFieldError().getDefaultMessage());        }        return resultInfo;    }}

动态资源

默认配置下，咱们能够在resources资源目录下寄存web利用动态资源文件
自定义动态资源门路，能够通过在spring.resources.static-locations前面追加一个配置classpath:/你自定义的配置目录/，例如：

# application.ymlspring:  resources:    # 多个目录应用逗号隔开    static-loaction: classpath:/public/,classpath:/static/,classpath:/fx67ll/

打包和部署

jar包

  1. 个别用于编写依赖工具包

  2. 打包

    • 在IDEARun/Debug Configurations下Command line配置clean complie package -Dmaven.test.skip=true执行打包命令
    • target目录失去待部署的我的项目文件

  3. 部署

    • 在dos窗口中，执行命令java -jar jar包所在的本地目录

war包

  1. 在生产环境中最为常见的部署形式

  2. 批改pom.xml，设置打包模式为war包

    <groupId>com.fx67ll</groupId><artifactId>springboot-quickstart</artifactId><version>0.1.0</version><!--设置为war包模式--><packaging>war</packaging>

  3. 疏忽内嵌Tomcat

    <!--设置为内部已提供，示意疏忽--><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-tomcat</artifactId>    <scope>provided</scope></dependency>

  4. 配置生成的war包名称

    <build><!--设置war包名称-->    <finalName>fx67ll-springboot-quickstart-test</finalName>    <plugins>        <plugin>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-maven-plugin</artifactId>        </plugin>    </plugins></build>

  5. 批改Starter类，增加容器启动加载文件（相似读取web.xml文件）

    • 这里通过继承SpringBootServletInitiallizer类并重写configure办法来实现

    • 在部署我的项目的时候指定内部Tomcat读取我的项目入口办法

      @SpringBootApplicationpublic class Starter extends SpringBootServletInitializer {  public static void main(String[] args) {     SpringApplication.run(Starter.class); }  @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {     return builder.sources(Starter.class); }}

  6. 打包

    • 在IDEARun/Debug Configurations下Command line配置clean complie package -Dmaven.test.skip=true执行打包命令
    • target目录失去待部署的我的项目文件

  7. 部署并拜访

    • 搁置到内部tomcat中，执行bin目录下start脚本即可

热部署

热部署，就是在利用正在运行的时候降级软件，却不须要重新启动利用，次要利用在开发过程中

热部署原理

  1. spring-boot-devtools是一个为开发者服务的一个模块，其中最重要的性能就是主动利用代码更改到最新的App下面去，
    原理是在发现代码有更改之后，重新启动利用，然而速度比手动进行后再启动还要更快，更快指的不是节俭进去的手工操作的工夫

  2. 其深层原理是应用了两个ClassLoader，一个Classloader加载那些不会扭转的类（第三方Jar包），另一个ClassLoader加载会更改的类，称为restart ClassLoader，
    这样在有代码更改的时候，原来的restart ClassLoader被抛弃，从新创立一个restart ClassLoader，因为须要加载的类相比拟少，所以实现了较快的重启工夫，大略在5秒以内

    devtools原理

  3. devtools会监听classpath下的文件变动，并且会立刻重启利用（产生在保留机会）留神：因为其采纳的虚拟机机制，该项重启是很快的

  4. devtools能够实现页面热部署（即页面批改后会立刻失效，这个能够间接在application文件中配置spring.thymeleaf.cache=false来实现 留神：不同的模板配置不一样

    热部署次要步骤

  5. 在pom.xml中增加依赖，同时增加devtools失效标记插件

    <!--热部署插件devtools--><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-devtools</artifactId>    <!--示意以后这个我的项目被继承之后，这个不向下传递-->    <optional>true</optional></dependency><plugin>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-maven-plugin</artifactId>    <!--在原有的根底上增加-->    <configuration>        <!--如果没有该配置，热部署插件devtools不失效-->        <fork>true</fork>    </configuration></plugin>

  6. 批改application.yml全局配置文件，在application.yml中配置spring.devtools.restart.enable=false，此时restart类加载器还会初始化，但不会监督文件更新

    spring:  # 热部署配置  devtools:    restart:      enabled: true      # 设置重启的目录，增加目录的文件须要restart      additional-paths: src/main/java      # 解决我的项目启动从新编译后接口报404的问题      poll-interval: 3000      quiet-period: 1000

  7. 批改 IDEA 配置

    • 批改了java类之后，IDEA 默认是不主动编译的，而spring-boot-devtools又是监测classpath下的文件发生变化才会重启利用，所以须要设置 IDEA 的主动编译
    • 设置主动配置 File -> Settings -> Build -> Complier -> Build Project automatically
    • 批改Register属性，执行快捷键ctrl + shift + alt + /，抉择Register，勾上Complier autoMake allow when app running
    • 留神 IDEA 2021.2.3 版本中没有下面的选项，迁徙到了File -> Settings -> Tools -> Advanced Settings -> Complier -> Allow auto-make to start......

  8. 配置完须要重启一下，而后有批改的话我的项目会自动更新，然而如果是主动触发的话，会造成频繁更新，对硬件有肯定的累赘，所以能够改成手动触发模式

    • 点击右上角 Run/Debug Configurations
    • 抉择下拉 Configuration -> Spring Boot -> Running Application Update Policies -> On 'Update' action
    • 抉择 Update classes and resources
    • 如果有更新能够，应用快捷键 Ctrl + F10 从新编译
  9. 快捷键Ctrl + F9，应用热部署重新启动

单元测试

依赖

<!--单元测试--><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-test</artifactId>    <scope>test</scope></dependency>

Service业务层————业务逻辑办法测试

须要留神的是：

  1. 如果在和main文件夹平级的test文件夹下新建了java文件夹，然而无奈新建java class文件

  2. 那么就须要右键文件夹 Mark Directory as -> Test Sources Root之后，文件夹变绿即可

    # 示例代码package com.fx67ll.springboot.service;import com.fx67ll.springboot.Starter;import com.fx67ll.springboot.po.User;import com.fx67ll.springboot.query.UserQuery;import com.fx67ll.springboot.srevice.UserService;import com.github.pagehelper.PageInfo;import org.junit.After;import org.junit.Before;import org.junit.Test;import org.junit.runner.RunWith;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.test.context.junit4.SpringRunner;import javax.annotation.Resource;/** * Service业务办法测试 * * Junit中的RunWith注解 示意该类是单元测试的执行类 * SpringRunner 是 spring-test 提供的测试执行单元类（是Spring单元测试中SpringJUnit4ClassRunner的新名字） * SpringBootTest注解 是执行测试程序的疏导类 */@RunWith(SpringRunner.class)@SpringBootTest(classes = {Starter.class})public class TestUserService { // 日志的应用 private Logger logger = LoggerFactory.getLogger(TestUserService.class); @Resource private UserService userService; @Before public void before() {     logger.info("单元测试开始......"); } @Test public void testQueryUserById() {     logger.info("测试依据用户id查问......");     User user = userService.queryUserById(1);     logger.info("用户记录: {}", user.toString()); } @Test public void testSelectUserListByParams() {     logger.info("测试依据分页条件查问用户列表......");     UserQuery userQuery = new UserQuery();     PageInfo<User> pageInfo = userService.selectUserListByParams(userQuery);     logger.info(pageInfo.toString()); } @After public void after() {     logger.info("单元测试完结......"); }}

controller管制层————接口办法测试

应用MockMVC进行测试

MockMvc是由spring-test包提供，实现了对Http申请的模仿，可能间接应用网络的模式，转换到Controller的调用，使得测试速度快、不依赖网络环境。
同时提供了一套验证的工具，后果的验证非常不便

什么是Mock

在面向对象的程序设计中，模仿对象mock object是以可控的形式模仿实在对象行为的假对象。
在编程过程中，通常通过模仿一些输出数据，来验证程序是否达到预期后果

接口MockMvcBuilder

提供一个惟一的build办法，用来结构MockMvc。
次要有两个实现：StandaloneMockMvcBuilder和DefaultMockMvcBuilder，别离对应两种测试形式，
即独立装置和集成Web环境测试（并不会集成真正的web环境，而是通过相应的Mock API进行模仿测试，毋庸启动服务器）。
MockMvcBuilders提供了对应的创立办法standaloneSetup办法和webAppContextSetup办法，在应用时间接调用即可。

# 示例代码# PS：尽管提醒测试通过，然而控制台始终没有打印出返回信息的记录，前期有空看看package com.fx67ll.springboot.controller;import com.fx67ll.springboot.Starter;import org.junit.Test;import org.junit.runner.RunWith;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.http.MediaType;import org.springframework.mock.web.MockHttpServletResponse;import org.springframework.test.context.junit4.SpringRunner;import org.springframework.test.web.servlet.MockMvc;import org.springframework.test.web.servlet.MvcResult;import org.springframework.test.web.servlet.ResultActions;import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;import org.springframework.test.web.servlet.result.MockMvcResultMatchers;@RunWith(SpringRunner.class)@SpringBootTest(classes = {Starter.class})@AutoConfigureMockMvcpublic class TestUserController {    // 日志的应用    private Logger logger = LoggerFactory.getLogger(TestUserController.class);    @Autowired    private MockMvc mockMvc;    /**     * 模仿测试用户列表查问     * 其实就在模仿实在环境下前端对后端发动的申请     */    @Test    public void apiTestSelectUserListByParams() throws Exception {        logger.info("开始模仿发送查问用户列表的申请......");        // 构建申请        MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.get("/user/list")                .contentType("text/html") // 设置申请头信息                .accept(MediaType.APPLICATION_JSON); // 设置申请Accept头信息        // 发送申请        ResultActions perform = mockMvc.perform(requestBuilder);        // 校验申请后果        perform.andExpect(MockMvcResultMatchers.status().isOk());        // 获取执行实现后返回的后果        MvcResult mvcResult = perform.andReturn();        // 失去执行后的响应        MockHttpServletResponse response = mvcResult.getResponse();        // 打印后果        logger.info(String.valueOf(response.getContentLength()));        logger.info("响应状态: ", response.getStatus());        logger.info("响应信息: ", response.getContentAsString());        logger.info("完结模仿发送查问用户列表的申请......");    }    @Test    public void apiTestQueryUserByUsername() throws Exception {        logger.info("开始模仿依据用户名查问用户记录的申请......");        // 构建申请并发送        MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get("/user/name/admin"))                .andExpect(MockMvcResultMatchers.status().isOk()).andReturn();        // 打印后果        logger.info("响应状态: ", mvcResult.getResponse().getStatus());        logger.info("响应信息: ", mvcResult.getResponse().getContentAsString());        logger.info("完结模仿依据用户名查问用户记录的申请......");    }}

Swagger2文档工具

依赖

在pom.xml中增加以下代码

<dependency>    <groupId>io.springfox</groupId>    <artifactId>springfox-swagger2</artifactId>    <version>2.9.2</version></dependency><dependency>    <groupId>io.springfox</groupId>    <artifactId>springfox-swagger-ui</artifactId>    <version>2.9.2</version></dependency>

罕用注解

能够参考文章————swagger2 注解阐明具体学习，这里前期会补上阐明

@Api

次要是用在申请类上，用于阐明该类的作用

# 示例@Api(tags = "xx模块")

@ApiOperation

次要是用在申请的办法上，阐明办法的作用

# 示例@ApiOperation(value = "xx办法的作用", notes = "xx办法的备注阐明")

@ApiImplicitParams、@ApiImplicitParam

次要是用在申请的办法上，阐明办法的参数

# 具体参数阐明@ApiImplicitParams：用在申请的办法上，蕴含一组参数阐明    @ApiImplicitParam：对单个参数的阐明                name：参数名        value：参数的阐明、形容        required：参数是否必须必填        paramType：参数放在哪个中央            · query --> 申请参数的获取：@RequestParam            · header --> 申请参数的获取：@RequestHeader                      · path（用于restful接口）--> 申请参数的获取：@PathVariable            · body（申请体）-->  @RequestBody User user            · form（一般表单提交）               dataType：参数类型，默认String，其它值dataType="Integer"               defaultValue：参数的默认值    # 单个参数示例    @ApiImplicitParam(name = "xxx", value = "xxx", required = true, paramType = "path", dataType = "String", defaultValue = "")# 多个参数示例@ApiImplicitParams({    @ApiImplicitParam(name = "xxxa", value = "xxxa", required = true, paramType = "body", dataType = "String", defaultValue = ""),    @ApiImplicitParam(name = "xxxb", value = "xxxb", required = true, paramType = "body", dataType = "String", defaultValue = ""),})

@ApiResponses、@ApiResponse

次要是用在申请的办法上，阐明谬误响应的信息

# 具体参数阐明@ApiResponses：响应状态的阐明。是个数组，可蕴含多个 @ApiResponse    @ApiResponse：每个参数的阐明        code：数字，例如400        message：信息，例如"申请参数没填好"        response：抛出异样的类    # 多个参数示例，个别响应都是多个code，所以不写单个参数的示例了@ApiResponses({        @ApiResponse(code = 200, message = "申请胜利"),        @ApiResponse(code = 578, message = "申请参数谬误"),        @ApiResponse(code = 404, message = "申请门路没有或页面跳转门路不对")})

@ApiModel、@ApiModelProperty

  1. @ApiModel 常常用于申请的入参对象和响应返回值对象的形容

    • 入参是对象，即 @RequestBody 时， 用于封装申请（包含数据的各种校验）数据
    • 返回值是对象，即 @ResponseBody 时，用于返回值对象的形容

  2. @ApiModelProperty 用于每个属性下面，阐明属性的含意

    # 示例@ApiModel(description = "用户实体类")public class User { @ApiModelProperty(value = "用户名", required = true, example = "0") private Integer id;  @ApiModelProperty(value = "用户ID", required = true, example = "fx67ll") private String userName;  @ApiModelProperty(value = "用户明码", required = true, example = "xxxxxxxx") private String userPwd;}

分布式缓存工具Ehcache

什么是Ehcache

EhCache是一个纯Java的过程内缓存框架，具备疾速、精干等特点，是Hibernate中默认CacheProvider。
Ehcache是一种宽泛应用的开源Java分布式缓存，次要面向通用缓存，Java EE和轻量级容器。
它具备内存和磁盘存储，缓存加载器，缓存扩大，缓存异样处理程序，一个gzip缓存servlet过滤器，反对REST API和SOAP API等特点。

SpringCache相干注解

SpringBoot缓存实现外部应用SpringCache实现缓存管制，这里集成Ehcache实际上是对SpringCache形象的一种实现
能够参考文章————Spring Cache 简介具体学习，这里前期会补上阐明

@EnableCaching

开启缓存性能，个别放在启动类上

@CacheConfig

当咱们须要缓存的中央越来越多，你能够应用@CacheConfig(cacheNames = {"cacheName"})注解在Class之上来对立指定value的值，
这时可省略value，如果你在你的办法仍旧写上了value，那么仍然以办法的value值为准

@Cacheable

依据办法对其返回后果进行缓存，下次申请时，如果缓存存在，则间接读取缓存数据返回；如果缓存不存在，则执行办法，并把返回的后果存入缓存中，个别用在查询方法上
留神value前面要应用ehcache.xml文件中所列的cache.name

# 单个参数示例代码@Cacheable(value = "fx67llCache", key = "#xxx")# 多个参数示例，采纳拼接的形式@Cacheable(value = "fx67llCache", key = "#xxx.xxx + '-' + #xxx.xxx + '-' + #xxx.xxx")

@CachePut

应用该注解标记的办法，每次都会执行，并将后果存入指定的缓存中。其余办法能够间接从响应的缓存中读取缓存数据，而不须要再去查询数据库，个别用在新增办法上

# 示例代码@CachePut(value = "fx67llCache", key = "#xxx.xxx")

@CacheEvict

应用该注解标记的办法，会清空指定的缓存，个别用在更新或者删除办法上

# 示例代码@CacheEvict(value = "fx67llCache", key = "#xxx")

@Caching

该注解能够实现同一个办法上同时应用多种注解

Ehcache的应用

  1. 在pom.xml增加依赖

    <!--Ehcache工具依赖--><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-cache</artifactId></dependency><dependency>    <groupId>net.sf.ehcache</groupId>    <artifactId>ehcache</artifactId></dependency>

  2. 增加ehcache.xml文件

    <?xml version="1.0" encoding="UTF-8"?><ehcache name="fx67llCache">    <!--       diskStore：为缓存门路，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存地位。参数解释如下：       user.home – 用户主目录       user.dir  – 用户当前工作目录       java.io.tmpdir – 默认临时文件门路     -->    <diskStore path="D:\Java\test-ehcache-cache"/>    <!--       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则应用这个缓存策略。只能定义一个。     -->    <!--      name:缓存名称。      maxElementsInMemory:缓存最大数目      maxElementsOnDisk：硬盘最大缓存个数。      eternal:对象是否永恒无效，一但设置了，timeout将不起作用。      overflowToDisk:是否保留到磁盘，当零碎当机时      timeToIdleSeconds:设置对象在生效前的容许闲置工夫（单位：秒）。仅当eternal=false对象不是永恒无效时应用，可选属性，默认值是0，也就是可闲置工夫无穷大。      timeToLiveSeconds:设置对象在生效前容许存活工夫（单位：秒）。最大工夫介于创立工夫和生效工夫之间。仅当eternal=false对象不是永恒无效时应用，默认是0.，也就是对象存活工夫无穷大。      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有本人的一个缓冲区。      diskExpiryThreadIntervalSeconds：磁盘生效线程运行工夫距离，默认是120秒。      memoryStoreEvictionPolicy：当达到maxElementsInMemory限度时，Ehcache将会依据指定的策略去清理内存。默认策略是LRU（最近起码应用）。你能够设置为FIFO（先进先出）或是LFU（较少应用）。      clearOnFlush：内存数量最大时是否革除。      memoryStoreEvictionPolicy:可选策略有：LRU（最近起码应用，默认策略）、FIFO（先进先出）、LFU（起码拜访次数）。           FIFO，first in first out，这个是大家最熟的，先进先出。           LFU， Less Frequently Used，就是下面例子中应用的策略，直白一点就是讲始终以来起码被应用的。如下面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。           LRU，Least Recently Used，最近起码应用的，缓存的元素有一个工夫戳，当缓存容量满了，而又须要腾出中央来缓存新的元素的时候，那么现有缓存元素中工夫戳离以后工夫最远的元素将被清出缓存。   -->    <defaultCache            maxElementsInMemory="10000"            eternal="false"            timeToIdleSeconds="120"            timeToLiveSeconds="120"            maxElementsOnDisk="10000000"            diskExpiryThreadIntervalSeconds="120"            memoryStoreEvictionPolicy="LRU"/>    <cache            name="fx67llCache"            eternal="false"            maxElementsInMemory="100"            overflowToDisk="false"            diskPersistent="false"            timeToIdleSeconds="0"            timeToLiveSeconds="300"            memoryStoreEvictionPolicy="LRU"/></ehcache>

  3. 在application.yml增加缓存配置

    # Ehcache 缓存配置cache:  ehcache:    config: classpath:ehcache.xml
  4. 在入口类增加@EnableCaching注解，示意开启缓存
  5. Java Bean 对象实现序列化，public class User implements Serializable
  6. 在须要应用的中央应用现关注解，实现缓存能够缩小从数据库查问的次数

定时调度工具Quartz

能够参考文章————Quartz定时调度具体学习，这里前期会补上阐明

什么是Quartz

在日常我的项目运行中，咱们总会有需要在某一时间段周期性的执行某个动作，比方每天在某个时间段导出报表，或者每隔多久统计一次当初在线的用户量等。
在SpringBoot中有Java自带的java.util.Timer类，也能够在启动类增加@EnableScheduling注解引入定时工作环境

Quartz的应用

  1. 在pom.xml增加依赖

    <!--Quartz工具依赖--><dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-quartz</artifactId></dependency>

  2. 增加job包并编写job工作，实现job接口，并在execute办法中实现本人的业务逻辑

    package com.fx67ll.springboot.jobs;import org.quartz.*;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.text.SimpleDateFormat;import java.util.Date;public class TestQuartzJob implements Job {    private Logger logger = LoggerFactory.getLogger(TestQuartzJob.class);    @Override    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {        // 获取整顿好的日期工夫        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        // 查问触发器名称和触发器属于哪个分组        TriggerKey triggerKey = jobExecutionContext.getTrigger().getKey();        //打印日志        logger.info("以后触发器是: " + triggerKey.getName() + "，它所属的组别是: " + triggerKey.getGroup() +                "----------触发工夫: " + simpleDateFormat.format(new Date()) +                "-->" + "Hello fx67ll Spring Boot Quartz......");    }}

  3. 构建调度配置类，创立JobDetail实例并定义Trigger注册到scheduler，启动scheduler开启调度

    package com.fx67ll.springboot.conf;import com.fx67ll.springboot.jobs.TestQuartzJob;import org.quartz.*;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;@Configurationpublic class QuartzCOnf {    @Bean    /**     * 具体的能够被执行的调度程序     */    public JobDetail jobDetailTestQuartz(){        return JobBuilder.newJob(TestQuartzJob.class).storeDurably().build();    }    @Bean    /**     * 第一个测试触发器，次要是配置参数提醒什么时候调用     * 利用场景有比方定时发送邮件之类的     */    public Trigger triggerTestQuartzFirst(){        SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule()                // 每五秒执行一次                .withIntervalInSeconds(1)                // 永恒反复，始终执行上来                .repeatForever();        return TriggerBuilder.newTrigger()                // 设置触发器名称和分组                .withIdentity("triggerTestQuartzFirst","groupTestQuartz")                .withSchedule(simpleScheduleBuilder)                .forJob(jobDetailTestQuartz())                .build();    }    @Bean    /**     * 第二个测试触发器     */    public Trigger triggerTestQuartzSecond(){        return TriggerBuilder.newTrigger()                // 设置触发器名称和分组                .withIdentity("triggerTestQuartzSecond","groupTestQuartz")                // 这里是通过定义表达式来示意每5秒执行一次，后续再深入研究下                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ? *"))                .forJob(jobDetailTestQuartz())                .build();    }}

附录

操作代码目录阐明

springboot-quickstartspringboot-mybatisspringboot-mybatis-crudspringboot-mybatis-crud-prod
疾速入门整合mybatis整套crud操作生产环境开发

操作代码资源地址

  1. springboot-quickstart
  2. springboot-mybatis
  3. springboot-mybatis-crud
  4. springboot-mybatis-crud-prod

参考资料

  1. 参考教程 ———— 两天搞定SpringBoot框架
  2. 参考文档 ———— JavaSpringBoot 中 @Autowired用法
  3. 参考文档 ———— SpringBoot - @Configuration、@Bean注解的应用详解（配置类的实现）
  4. 参考文档 ———— 【Spring Boot】Spring根底 —— 组合注解与元注解
  5. 参考文档 ———— @RestController 和 @Controller 的区别
  6. 参考文档 ———— MapperScan注解详解
  7. 参考文档 ———— Mapper.xml详解
  8. 参考文档 ———— MVC三层架构（详解）
  9. 参考文档 ———— 配置devtools热部署
  10. 参考文档 ———— (十三)SpringBoot2.0热部署Devtools原理
  11. 参考文档 ———— 2021版IDEA没有compiler.automake.allow.when.app.running
  12. 参考文档 ———— SpringBoot根底之MockMvc单元测试
  13. 参考文档 ———— Ehcache具体解读
  14. 参考文档 ———— spring boot接入ehcache
  15. 参考文档 ———— SpringBoot(十二)： validation罕用注解
  16. 参考文档 ———— SpringBoot之——Validator校验相干的注解
  17. 参考文档 ———— 强悍的Spring之spring validation
  18. json格局校验并显示谬误_应用 Spring Validation 优雅地进行参数校验

我是 fx67ll.com，如果您发现本文有什么谬误，欢送在评论区探讨斧正，感谢您的浏览！
如果您喜爱这篇文章，欢送拜访我的 本文github仓库地址，为我点一颗Star，Thanks~ :)
转发请注明参考文章地址，非常感谢！！！