SpringBoot

Spring Boot 概念&特点

框架概念

  1. 随着动态语言流行(Ruby,Scala,NodeJs等)，Java 开发变得相对笨重，配置繁琐，开发效率低下，部署流程复杂，以及第三方集成难度也相对较大，针对该环境，Spring Boot被开发出来，其使用“习惯大于配置目标”,借助Spring Boot 能够让项目快速运行起来，同时借助Spring Boot可以快速创建web 应用并独立进行部署(jar包 war 包方式，内嵌servlet 容器)，同时借助Spring Boot 在开发应用时可以不用或很少去进行相关xml环境配置，简化了开发，大大提高项目开发效率。
  3.     Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，让Spring Boot在蓬勃发展的快速应用开发领域(rapid application development)成为领导者.

框架特点

创建独立Spring应用程序、嵌入式Tomcat，Jetty容器、无需部署WAR包、简化Maven及Gradle配置、尽可能自动化配置Spring、直接植入产品环境下的实用功能，比如度量指标、健康检查及扩展配置、无需代码生成及XML配置等，同时Spring Boot不仅对web应用程序做了简化，还提供一系列的依赖包来把其它一些工作做成开箱即用。

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.2.2.RELEASE</version>
  5. </parent>
  6. <dependencies>
  7.     <dependency>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-web</artifactId>
  10.     </dependency>
  11. </dependencies>

Spring Boot的项目必须要将parent设置为Spring Boot的parent，该parent包含了大量默认的配置，简化程序的开发。

导入Spring Boot的web坐标与相关插件

  1. <plugin>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-maven-plugin</artifactId>
  4. </plugin>

添加源代码

  1. @Controller
  2. public class HelloController {
  3.     @RequestMapping("hello")
  4.     @ResponseBody
  5.     public  String hello(){
  6.         return "Hello Spring Boot";
  7.     }
  8. }

创建启动程序

在HelloController.java 所在包下创建StarterApplication.java

  1. @SpringBootApplication
  2. public class StarterApplication
  3. {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(Starter.class);
  6.     }
  7. }

Spring Boot 配置文件

  1.     Spring Boot 默认会读取全局配置文件，配置文件名固定为:application.properties或application.yml，放置在src/main/resources资源目录下,使用配置文件来修改SpringBoot自动配置的默认值；

在resources 资源目录下添加application.properties 文件,配置信息如下:

  1. ## 项目启动端口号配置
  2. server.port=8989
  3. ## 项目访问上下文路径
  4. server.servlet-path=/mvc
  6. ## 数据源配置
  7. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  8. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/hr?useUnicode=true&characterEncoding=utf8
  9. spring.datasource.username=root
  10. spring.datasource.password=root

或者application.yml 文件

  1. ## 端口号  上下文路径
  2. server:
  3.   port: 8989
  4.   servlet:
  5.     context-path: /mvc
  7. ## 数据源配置
  8. spring:
  9.   datasource:
  10.     type: com.mchange.v2.c3p0.ComboPooledDataSource
  11.     driver-class-name: com.mysql.cj.jdbc.Driver
  12.     url: jdbc:mysql://127.0.0.1:3306/hr
  13.     username: root
  14.     password: root

Starter 坐标 & 自动化配置

Starter坐标配置

  1.     Spring Boot 引入了全新的Starter坐标体系，简化企业项目开发大部分场景的Starter pom,应用程序引入指定场景的Start pom 相关配置就可以消除 ，通过Spring Boot就可以得到自动配置的Bean。

Web starter

使用Spring MVC来构建RESTful Web应用，并使用Tomcat作为默认内嵌容器

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>

Freemarker Starter & Thymeleaf starter

集成视图技术，引入Freemarker Starter ,Thymeleaf Starter

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-freemarker</artifactId>
  4. </dependency>
  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-thymeleaf</artifactId>
  4. </dependency>

JavaMail邮件发送 Starter
  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-mail</artifactId>
  4. </dependency>

引入AOP环境
  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-aop</artifactId>
  4. </dependency>
  • 相关starter系列坐标参考 | 名称 | 描述 | | :—- | :—-: | | spring-boot-starter | 核心Spring Boot starter，包括自动配置支持，日志和YAML | | spring-boot-starter-actuator | 生产准备的特性，用于帮我们监控和管理应用 | | spring-boot-starter-amqp | 对”高级消息队列协议”的支持，通过spring-rabbit实现 | | spring-boot-starter-aop | 对面向切面编程的支持，包括spring-aop和AspectJ | | spring-boot-starter-batch | 对Spring Batch的支持，包括HSQLDB数据库 | | spring-boot-starter-cloud-connectors | 对Spring Cloud Connectors的支持，简化在云平台下（例如，Cloud Foundry 和Heroku）服务的连接 | | spring-boot-starter-data-elasticsearch | 对Elasticsearch搜索和分析引擎的支持，包括spring-data-elasticsearch | | spring-boot-starter-data-gemfire | 对GemFire分布式数据存储的支持，包括spring-data-gemfire | | spring-boot-starter-data-jpa | 对”Java持久化API”的支持，包括spring-data-jpa，spring-orm和Hibernate | | spring-boot-starter-data-mongodb | 对MongoDB NOSQL数据库的支持，包括spring-data-mongodb | | spring-boot-starter-data-rest | 对通过REST暴露Spring Data仓库的支持，通过spring-data-rest-webmvc实现 | | spring-boot-starter-data-solr | 对Apache Solr搜索平台的支持，包括spring-data-solr | | spring-boot-starter-freemarker | 对FreeMarker模板引擎的支持 | | spring-boot-starter-groovy-templates | 对Groovy模板引擎的支持 | | spring-boot-starter-hateoas | 对基于HATEOAS的RESTful服务的支持，通过spring-hateoas实现 | | spring-boot-starter-hornetq | 对”Java消息服务API”的支持，通过HornetQ实现 | | spring-boot-starter-integration | 对普通spring-integration模块的支持 | | spring-boot-starter-jdbc | 对JDBC数据库的支持 | | spring-boot-starter-jersey | 对Jersey RESTful Web服务框架的支持 | | spring-boot-starter-jta-atomikos | 对JTA分布式事务的支持，通过Atomikos实现 | | spring-boot-starter-jta-bitronix | 对JTA分布式事务的支持，通过Bitronix实现 | | spring-boot-starter-mail | 对javax.mail的支持 | | spring-boot-starter-mobile | 对spring-mobile的支持 | | spring-boot-starter-mustache | 对Mustache模板引擎的支持 | | spring-boot-starter-redis | 对REDIS键值数据存储的支持，包括spring-redis | | spring-boot-starter-security | 对spring-security的支持 | | spring-boot-starter-social-facebook | 对spring-social-facebook的支持 | | spring-boot-starter-social-linkedin | 对spring-social-linkedin的支持 | | spring-boot-starter-social-twitter | 对spring-social-twitter的支持 | | spring-boot-starter-test | 对常用测试依赖的支持，包括JUnit, Hamcrest和Mockito，还有spring-test模块 | | spring-boot-starter-thymeleaf | 对Thymeleaf模板引擎的支持，包括和Spring的集成 | | spring-boot-starter-velocity | 对Velocity模板引擎的支持 | | spring-boot-starter-web | 对全栈web开发的支持， 包括Tomcat和spring-webmvc | | spring-boot-starter-websocket | 对WebSocket开发的支持 | | spring-boot-starter-ws | 对Spring Web服务的支持 |

传统的maven坐标这里同样适用，如果引入传统maven坐标需要考虑相关配置类的编写

如果引入相关starter坐标这里不存在，可以到这里搜索。

自动化配置

SpringBoot Starter坐标版本查看
  1.     前面介绍了SpringBoot Starter相关坐标，引入Starter坐标来简化应用环境的配置。这里以环境搭建spring-boot-starter-web坐标来简单分析SpringBoot 自动化配置过程。
  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  1.     这里引入的web环境坐标不像传统的maven坐标那样包含坐标的版本号，项目中引入的starter 系列坐标对应的版本库统一由父工程坐标统一控制即项目中引入的parent标签。
  1. <parent>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-parent</artifactId>
  4.   <!--
  5.      父类项目统一对项目依赖版本统一控制!
  6.   -->  
  7.   <version>2.2.2.RELEASE</version>
  8. </parent>

这里spring-boot-starter-parent 继承spring-boot-dependencies 项目,在spring-boot-dependencies项目中定义了spring-boot-starter-web坐标的版本!

日志配置

  1.     在开发企业项目时，日志的输出对于系统bug 定位无疑是一种比较有效的方式，也是项目后续进入生产环境后快速发现错误解决错误的一种有效手段，所以日志的使用对于项目也是比较重要的一块功能。
  3.     Spring Boot默认使用LogBack日志系统，如果不需要更改为其他日志系统如Log4j2等，则无需多余的配置，LogBack默认将日志打印到控制台上。如果要使用LogBack，原则上是需要添加dependency依赖的
  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-logging</artifactId>
  4. </dependency>

因为新建的Spring Boot项目一般都会引用spring-boot-starter或者spring-boot-starter-web，而这两个起步依赖中都已经包含了对于spring-boot-starter-logging的依赖，所以，无需额外添加依赖。

项目中日志信息输出

Starter 启动类中添加Log 日志类,控制台打印日志信息。

  1. package com.xxxx;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class Starter {
  8.     private static Logger logger = LoggerFactory.getLogger(Starter.class);
  9.     public static void main(String[] args) {
  10.         logger.info("SpringBoot 应用开始启动...");
  11.         SpringApplication.run(Starter.class);
  12.     }
  13. }

日志输出格式配置

  1.     修改application.yml文件添日志输出格式信息配置，可以修改application.yml文件来控制控制台日志输出格式，同时可以设置日志信息输出到外部文件。
  1. logging:
  2.   pattern:
  3.     console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger- %msg%n"
  4.     level: debug
  5.   file:
  6.     path: "."
  7.     name: "springboot.log"

SpringBoot 静态资源访问

从入门项目中可以看到:对于Spring Mvc 请求拦截规则为‘/’,Spring Boot 默认静态资源路径如下:

  1. public class ResourceProperties {
  2.     private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[]{"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};
  3.     private String[] staticLocations;
  4.     private boolean addMappings;
  5.     private final ResourceProperties.Chain chain;
  6.     private final ResourceProperties.Cache cache;

即:我们可以在resources 资源目录下存放web 应用静态资源文件。

在resources 目录下创建static 或者public 存放images、js、css等静态资源文件

Mybatis整合&数据访问

  1.     使用SpringBoot开发企业项目时，持久层数据访问是前端页面数据展示的基础，SpringBoot支持市面上常见的关系库产品(Oracle,Mysql,SqlServer,DB2等)对应的相关持久层框架，当然除了对于关系库访问的支持，也支持当下众多的非关系库(Redis,Solr,MongoDB等)数据访问操作,这里主要介绍SpringBoot集成Mybatis并实现持久层数据基本增删改查操作。

SpringBoot 整合Mybatis

环境整合配置

  • Idea 下创建Maven 普通工程 springboot_mybatis

  • pom.xml 添加核心依赖

  1. <properties>
  2.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  3.     <maven.compiler.source>1.8</maven.compiler.source>
  4.     <maven.compiler.target>1.8</maven.compiler.target>
  5. </properties>
  7. <parent>
  8.     <groupId>org.springframework.boot</groupId>
  9.     <artifactId>spring-boot-starter-parent</artifactId>
  10.     <version>2.2.2.RELEASE</version>
  11. </parent>
  12. <dependencies>
  13.     <dependency>
  14.         <groupId>org.springframework.boot</groupId>
  15.         <artifactId>spring-boot-starter-web</artifactId>
  16.     </dependency>
  17.     <!--
  18.           mybatis 集成
  19.         -->
  20.     <dependency>
  21.         <groupId>org.mybatis.spring.boot</groupId>
  22.         <artifactId>mybatis-spring-boot-starter</artifactId>
  23.         <version>2.1.1</version>
  24.     </dependency>
  25.     <!-- springboot分页插件 -->
  26.     <dependency>
  27.         <groupId>com.github.pagehelper</groupId>
  28.         <artifactId>pagehelper-spring-boot-starter</artifactId>
  29.         <version>1.2.13</version>
  30.     </dependency>
  32.     <!--mysql 驱动-->
  33.     <dependency>
  34.         <groupId>mysql</groupId>
  35.         <artifactId>mysql-connector-java</artifactId>
  37.     </dependency>
  38.     <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
  39.     <dependency>
  40.         <groupId>com.mchange</groupId>
  41.         <artifactId>c3p0</artifactId>
  42.         <version>0.9.5.5</version>
  43.     </dependency>
  44. </dependencies>
  46. <build>
  47.     <plugins>
  48.         <plugin>
  49.             <groupId>org.springframework.boot</groupId>
  50.             <artifactId>spring-boot-maven-plugin</artifactId>
  51.         </plugin>
  52.     </plugins>
  53. </build>
  • application.yml 整合配置
  1. ## 端口号
  2. server:
  3.   port: 9999
  5. ## 数据源配置
  6. spring:
  7.   datasource:
  8.     type: com.mchange.v2.c3p0.ComboPooledDataSource
  9.     driver-class-name: com.mysql.cj.jdbc.Driver
  10.     url: jdbc:mysql://127.0.0.1:3306/springboot_mybatis?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
  11.     username: root
  12.     password: root
  14. ## mybatis 配置
  15. mybatis:
  16.   mapper-locations: classpath:/mappers/*.xml
  17.   type-aliases-package: com.xxxx.springboot.vo
  18.   configuration:
  19.     ## 下划线转驼峰配置
  20.     map-underscore-to-camel-case: true
  22. ## pageHelper
  23. pagehelper:
  24.   helper-dialect: mysql
  26. #显示dao 执行sql语句
  27. logging:
  28.   level:
  29.     com:
  30.       xxxx:
  31.         springboot:
  32.           dao: debug

源代码添加

  • Dao层接口方法定义

com.xxxx.springboot.dao 包下创建UserDao.java 接口声明查询方法

  1. package com.xxxx.springboot.dao;
  3. import com.xxxx.springboot.vo.User;
  5. public interface UserMapper  {
  6.     // 根据用户名查询用户记录
  7.     User queryUserByUserName(String userName);
  8. }
  • SQL映射文件添加
    resources/mappers 目录下添加UserMapper.xml 配置查询statetment
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.xxxx.springboot.dao.UserMapper">
  4.     <select id="queryUserByUserName" parameterType="string" resultType="com.xxxx.springboot.vo.User">
  5.         select
  6.         id,user_name,user_pwd
  7.         from t_user
  8.         where user_name=#{userName}
  9.     </select>
  10. </mapper>
  • 添加service 、controller 对应代码

UserService.java

  1. @Service
  2. public class UserService {
  3.     @Autowired
  4.     private UserMapper userMapper;
  6.     public User queryUserByUserName(String userName){
  7.         return userMapper.queryUserByUserName(userName);
  8.     }
  9. }

UserController.java

  1. @RestController
  2. public class UserController {
  4.     @Resource
  5.     private UserService userService;
  8.     @GetMapping("user/{userName}")
  9.     public User queryUserByUserName(@PathVariable String userName){
  10.         return userService.queryUserByUserName(userName);
  11.     }
  12. }
  • 添加应用启动入口
  1. @SpringBootApplication
  2. @MapperScan("com.xxxx.springboot.dao")
  3. public class Starter {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(Starter.class);
  7.     }
  8. }

启动测试

运行Starter main方法,启动应用浏览器测试查询

后端日志打印效果:

image-20200305105914531

SpringBoot数据访问操作

  1. 完成SpringBoot 与Mybatis 集成后，接下来以用户表为例实现一套用户模块基本数据维护。

接口方法 & Sql映射文件

  • UserDao 接口方法定义

UserDao 接口添加数据访问基本方法

  1. public interface UserMapper  {
  3.     public User queryById(Integer id);
  5.     User queryUserByUserName(String userName);
  7.     public int save(User user);
  9.     public int update(User user);
  11.     public List<User> selectByParams(UserQuery userQuery);
  13. }
  • UserMapper.xml 映射文件配置
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.xxxx.springboot.dao.UserMapper">
  4.     <select id="queryById" parameterType="int" resultType="com.xxxx.springboot.vo.User">
  5.         select *
  6.         from t_user
  7.         where id = #{id,jdbcType=INTEGER}
  8.     </select>
  10.     <select id="queryUserByUserName" parameterType="string" resultType="com.xxxx.springboot.vo.User">
  11.         select *
  12.         from t_user
  13.         where user_name=#{userName}
  14.     </select>
  15.     <insert id="save" parameterType="com.xxxx.springboot.vo.User" useGeneratedKeys="true" keyProperty="id">
  16.         insert into t_user(id,user_name,user_pwd) values(#{id},#{userName},#{userPwd})
  17.     </insert>
  18.     <update id="update" parameterType="com.xxxx.springboot.vo.User">
  19.         update t_user set user_name =#{userName},user_pwd=#{userPwd}
  20.         where id = #{id}
  21.     </update>
  22.     <select id="selectByParams" parameterType="com.xxxx.springboot.query.UserQuery" resultType="com.xxxx.springboot.vo.User">
  23.         select *
  24.         from t_user
  25.         <where>
  26.             <if test="null !=userName and userName !=''">
  27.                 and user_name like concat('%',#{userName},'%')
  28.             </if>
  29.         </where>
  30.     </select>
  31. </mapper>

UserService.java方法实现

  1. public User queryUserByUserName(String userName){
  2.     return userMapper.queryUserByUserName(userName);
  3. }
  5. public User queryUserByUserId(Integer userId){
  6.     return userMapper.queryById(userId);
  7. }
  9. public void saveUser(User user) {
  10.     AssertUtil.isTrue(StringUtils.isBlank(user.getUserName()), "用户名不能为空!");
  11.     AssertUtil.isTrue(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空!");
  12.     User temp = userMapper.queryUserByUserName(user.getUserName());
  13.     AssertUtil.isTrue(null != temp, "该用户已存在!");
  14.     AssertUtil.isTrue(userMapper.save(user)<1,"用户记录添加失败!");
  15. }
  17. public void updateUser(User user) {
  18.     AssertUtil.isTrue(StringUtils.isBlank(user.getUserName()), "用户名不能为空!");
  19.     AssertUtil.isTrue(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空!");
  20.     User temp = userMapper.queryUserByUserName(user.getUserName());
  21.     AssertUtil.isTrue(null != temp && !(temp.getId().equals(user.getId())), "该用户已存在!");
  22.     AssertUtil.isTrue(userMapper.update(user)<1,"用户记录添加失败!");
  23. }
  25. public  void deleteUser(Integer id){
  26.     AssertUtil.isTrue(null == id || null ==userMapper.queryById(id),"待删除记录不存在!");
  27.     AssertUtil.isTrue(userMapper.delete(id)<1,"用户删除失败!");
  28. }
  30. public PageInfo<User> queryUserByParams(UserQuery userQuery){
  31.     PageHelper.startPage(userQuery.getPageNum(),userQuery.getPageSize());
  32.     return new PageInfo<User>(userMapper.selectByParams(userQuery));
  33. }

UserController.java 接口方

  1. @GetMapping("user/{userId}")
  2. public User queryUserByUserId(@PathVariable  Integer userId){
  3.     return userService.queryUserByUserId(userId);
  4. }
  6. @GetMapping("user/list")
  7. public PageInfo<User> list(UserQuery userQuery){
  8.     return userService.queryUserByParams(userQuery);
  9. }
  11. @PutMapping("user")
  12. public ResultInfo saveUser(User user){
  13.     ResultInfo resultInfo=new ResultInfo();
  14.     try {
  15.         userService.saveUser(user);
  16.     } catch (ParamsException e) {
  17.         e.printStackTrace();
  18.         resultInfo.setCode(e.getCode());
  19.         resultInfo.setMsg(e.getMsg());
  20.     }catch (Exception e) {
  21.         e.printStackTrace();
  22.         resultInfo.setCode(300);
  23.         resultInfo.setMsg("记录添加失败!");
  24.     }
  25.     return resultInfo;
  26. }
  29. @PostMapping("user")
  30. public ResultInfo updateUser(User user){
  31.     ResultInfo resultInfo=new ResultInfo();
  32.     try {
  33.         userService.updateUser(user);
  34.     } catch (ParamsException e) {
  35.         e.printStackTrace();
  36.         resultInfo.setCode(e.getCode());
  37.         resultInfo.setMsg(e.getMsg());
  38.     }catch (Exception e) {
  39.         e.printStackTrace();
  40.         resultInfo.setCode(300);
  41.         resultInfo.setMsg("记录更新失败!");
  42.     }
  43.     return resultInfo;
  44. }
  47. @DeleteMapping("user/{userId}")
  48. public ResultInfo deleteUser(@PathVariable  Integer  userId){
  49.     ResultInfo resultInfo=new ResultInfo();
  50.     try {
  51.         userService.deleteUser(userId);
  52.     } catch (ParamsException e) {
  53.         e.printStackTrace();
  54.         resultInfo.setCode(e.getCode());
  55.         resultInfo.setMsg(e.getMsg());
  56.     }catch (Exception e) {
  57.         e.printStackTrace();
  58.         resultInfo.setCode(300);
  59.         resultInfo.setMsg("记录删除失败!");
  60.     }
  61.     return resultInfo;
  62. }

API 文档构建工具-Swagger2

  1.     由于Spring Boot能够快速开发、便捷部署等特性，通常在使用Spring Boot构建Restful 接口应用时考虑到多终端的原因，这些终端会共用很多底层业务逻辑，因此我们会抽象出这样一层来同时服务于多个移动端或者Web前端。对于不同的终端公用一套接口API时对于联调测试时就需要知道后端提供的接口Api 列表文档，对于服务端开发人员来说就需要编写接口文档，描述接口调用地址参数结果等，这里借助第三方构建工具Swagger2来实现Api文档生成功能。

环境整合配置

  • pom.xml 依赖添加
  1. <dependency>
  2.   <groupId>io.springfox</groupId>
  3.   <artifactId>springfox-swagger2</artifactId>
  4.   <version>2.9.2</version>
  5. </dependency>
  6. <dependency>
  7.   <groupId>io.springfox</groupId>
  8.   <artifactId>springfox-swagger-ui</artifactId>
  9.   <version>2.9.2</version>
  10. </dependency>
  • 配置类添加
  1. @Configuration
  2. @EnableSwagger2
  3. public class Swagger2 {
  4.     @Bean
  5.     public Docket createRestApi() {
  6.         return new Docket(DocumentationType.SWAGGER_2)
  7.                 .apiInfo(apiInfo())
  8.                 .select()
  9.                 .apis(RequestHandlerSelectors.basePackage("com.xxxx.springboot.controller"))
  10.                 .paths(PathSelectors.any())
  11.                 .build();
  12.     }
  13.     private ApiInfo apiInfo() {
  14.         return new ApiInfoBuilder()
  15.                 .title("用户管理接口API文档参考")
  16.                 .version("1.0")
  17.                 .build();
  18.     }
  19. }

Swagger2 常用注解说明

@Api 

  1. @Api：用在请求的类上，说明该类的作用
  2.     tags="说明该类的作用"
  1. @Api(tags="APP用户注册Controller")

@ApiOperation 

  1. @ApiOperation："用在请求的方法上，说明方法的作用"
  2.     value="说明方法的作用"
  3.     notes="方法的备注说明"
  1. @ApiOperation(value="用户注册",notes="手机号、密码都是必输项，年龄随边填，但必须是数字")

@ApiImplicitParams 

  1. @ApiImplicitParams：用在请求的方法上，包含一组参数说明
  2.     @ApiImplicitParam：用在 @ApiImplicitParams 注解中，指定一个请求参数的配置信息       
  3.         name：参数名
  4.         value：参数的汉字说明、解释
  5.         required：参数是否必须传
  6.         paramType：参数放在哪个地方
  7.             · header --> 请求参数的获取：@RequestHeader
  8.             · query --> 请求参数的获取：@RequestParam
  9.             · path（用于restful接口）--> 请求参数的获取：@PathVariable
  10.             · body（不常用）
  11.             · form（不常用）    
  12.         dataType：参数类型，默认String，其它值dataType="Integer"       
  13.         defaultValue：参数的默认值
  1. @ApiImplicitParams({
  2.     @ApiImplicitParam(name="mobile",value="手机号",required=true,paramType="form"),
  3.     @ApiImplicitParam(name="password",value="密码",required=true,paramType="form"),
  4.     @ApiImplicitParam(name="age",value="年龄",required=true,paramType="form",dataType="Integer")
  5. })

@ApiResponses 

  1. @ApiResponses：用于请求的方法上，表示一组响应
  2.     @ApiResponse：用在@ApiResponses中，一般用于表达一个错误的响应信息
  3.         code：数字，例如400
  4.         message：信息，例如"请求参数没填好"
  5.         response：抛出异常的类
  1. @ApiOperation(value = "select请求",notes = "多个参数，多种的查询参数类型")
  2. @ApiResponses({
  3.     @ApiResponse(code=400,message="请求参数没填好"),
  4.     @ApiResponse(code=404,message="请求路径没有或页面跳转路径不对")
  5. })

@ApiModel 

  1. @ApiModel：用于响应类上，表示一个返回响应数据的信息
  2.             （这种一般用在post创建的时候，使用@RequestBody这样的场景，
  3.             请求参数无法使用@ApiImplicitParam注解进行描述的时候）
  4.     @ApiModelProperty：用在属性上，描述响应类的属性
  1. @ApiModel(description= "返回响应数据")
  2. public class RestMessage implements Serializable{
  3.     @ApiModelProperty(value = "是否成功")
  4.     private boolean success=true;
  5.     @ApiModelProperty(value = "返回对象")
  6.     private Object data;
  7.     @ApiModelProperty(value = "错误编号")
  8.     private Integer errCode;
  9.     @ApiModelProperty(value = "错误信息")
  10.     private String message;
  11.     /* getter/setter */
  12. }

用户模块注解配置

UserController.java 接口方法注解使用

  1. @GetMapping("user/uname/{userName}")
  2. @ApiOperation(value = "根据用户名查询用户记录")
  3. @ApiImplicitParam(name = "userName",value = "查询参数",required = true,paramType = "path")
  4. public User queryUserByUserName(@PathVariable String userName){
  5.     return userService.queryUserByUserName(userName);
  6. }
  8. @ApiOperation(value = "根据用户id查询用户记录")
  9. @ApiImplicitParam(name = "userId",value = "查询参数",required = true,paramType = "path")
  10. @GetMapping("user/{userId}")
  11. public User queryUserByUserId(@PathVariable  Integer userId, HttpServletRequest request){
  12.     return userService.queryUserByUserId(userId);
  13. }
  15. @GetMapping("user/list")
  16. @ApiOperation(value = "多条件查询用户列表记录")
  17. public PageInfo<User> list(UserQuery userQuery){
  18.     return userService.queryUserByParams(userQuery);
  19. }
  21. @PutMapping("user")
  22. @ApiOperation(value = "用户添加")
  23. @ApiImplicitParam(name = "user",value = "用户实体类",dataType = "User")
  24. public ResultInfo saveUser(@RequestBody  User user){
  25.     ResultInfo resultInfo=new ResultInfo();
  26.     try {
  27.         userService.saveUser(user);
  28.     } catch (ParamsException e) {
  29.         e.printStackTrace();
  30.         resultInfo.setCode(e.getCode());
  31.         resultInfo.setMsg(e.getMsg());
  32.     }catch (Exception e) {
  33.         e.printStackTrace();
  34.         resultInfo.setCode(300);
  35.         resultInfo.setMsg("记录添加失败!");
  36.     }
  37.     return resultInfo;
  38. }
  40. @PostMapping("user")
  41. @ApiOperation(value = "用户更新")
  42. @ApiImplicitParam(name = "user",value = "用户实体类",dataType = "User")
  43. public ResultInfo updateUser(@RequestBody  User user){
  44.     ResultInfo resultInfo=new ResultInfo();
  45.     try {
  46.         userService.updateUser(user);
  47.     } catch (ParamsException e) {
  48.         e.printStackTrace();
  49.         resultInfo.setCode(e.getCode());
  50.         resultInfo.setMsg(e.getMsg());
  51.     }catch (Exception e) {
  52.         e.printStackTrace();
  53.         resultInfo.setCode(300);
  54.         resultInfo.setMsg("记录更新失败!");
  55.     }
  56.     return resultInfo;
  57. }
  59. @PutMapping("user/{userId}")
  60. @ApiOperation(value = "根据用户id删除用户记录")
  61. @ApiImplicitParam(name = "userId",value = "查询参数",required = true,paramType = "path")
  62. public ResultInfo deleteUser(@PathVariable  Integer  userId){
  63.     ResultInfo resultInfo=new ResultInfo();
  64.     try {
  65.         userService.deleteUser(userId);
  66.     } catch (ParamsException e) {
  67.         e.printStackTrace();
  68.         resultInfo.setCode(e.getCode());
  69.         resultInfo.setMsg(e.getMsg());
  70.     }catch (Exception e) {
  71.         e.printStackTrace();
  72.         resultInfo.setCode(300);
  73.         resultInfo.setMsg("记录删除失败!");
  74.     }
  75.     return resultInfo;
  76. }

JavaBean 使用

  • User.java
  1. @ApiModel(description = "响应结果-用户信息")
  2. public class User {
  3.     @ApiModelProperty(value = "用户id",example = "0")
  4.     private Integer id;
  5.     @ApiModelProperty(value = "用户名")
  6.     private String userName;
  7.     @ApiModelProperty(value = "用户密码")
  8.     private String userPwd;
  9.     /*
  10.        省略get|set
  11.     */
  12. }
  • UserQuery.java
  1. @ApiModel(description = "用户模块条件查询类")
  2. public class UserQuery {
  3.     @ApiModelProperty(value = "分页页码",example = "1")
  4.     private Integer pageNum=1;
  5.     @ApiModelProperty(value = "每页大小",example = "10")
  6.     private Integer pageSize=10;
  7.     @ApiModelProperty(value = "用户名")
  8.     private String userName;
  9.     /*
  10.        省略get|set
  11.     */
  12.  }
  • ResultInfo.java
  1. @ApiModel(description = "响应结果-Model信息")
  2. public class ResultInfo {
  4.     @ApiModelProperty(value = "响应状态码",example = "200")
  5.     private Integer code=200;
  6.     @ApiModelProperty(value = "响应消息结果")
  7.     private String msg="success";
  9.     @ApiModelProperty(value = "响应具体结果信息")
  10.     private Object result;
  11.      /*
  12.        省略get|set
  13.     */
  14. }

Swagger2 接口文档访问

启动工程,浏览器访问:http://localhost:9999/swagger-ui.html

分布式缓存Ehcache整合

  1. EhCache是一个比较成熟的Java缓存框架，最早从hibernate发展而来， 是进程中的缓存系统，它提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的cache管理方案，快速简单。
  3. Spring Boot对Ehcache的使用提供支持，所以在Spring Boot中只需简单配置即可使用Ehcache实现数据缓存处理。

Spring Cache 相关注解说明

  1.     SpringBoot 内部使用SpringCache 来实现缓存控制，这里集成Ehcache实际上是对SpringCache 抽象的其中一种实现，这里在使用Ehcache实现缓存控制时相关注解说明如下

@CacheConfig

用于标注在类上，可以存放该类中所有缓存的公有属性，比如设置缓存的名字。

  1. @CacheConfig(cacheNames = "users")
  2. public class UserService {。。。}
  1.     这里也可以不使用该注解，直接使用@Cacheable配置缓存集的名字。

@Cacheable 

  1.     应用到读取数据的方法上，即可缓存的方法，如查找方法，先从缓存中读取，如果没有再调用相应方法获取数据，然后把数据添加到缓存中。

该注解主要有下面几个参数：

  • value、cacheNames：两个等同的参数（cacheNames为Spring 4新增，作为value的别名），用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig，因此在Spring 3中原本必须有的value属性，也成为非必需项了
  • key：缓存对象存储在Map集合中的key值，非必需，缺省按照函数的所有参数组合作为key值，若自己配置需使用SpEL表达式，比如：@Cacheable(key = “#p0”)：使用函数第一个参数作为缓存的key值，更多关于SpEL表达式的详细内容可参考官方文档
  • condition：缓存对象的条件，非必需，也需使用SpEL表达式，只有满足表达式条件的内容才会被缓存，比如：@Cacheable(key = “#p0”, condition = “#p0.length() < 3”)，表示只有当第一个参数的长度小于3的时候才会被缓存。
  • unless：另外一个缓存条件参数，非必需，需使用SpEL表达式。它不同于condition参数的地方在于它的判断时机，该条件是在函数被调用之后才做判断的，所以它可以通过对result进行判断。
  • keyGenerator：用于指定key生成器，非必需。若需要指定一个自定义的key生成器，我们需要去实现org.springframework.cache.interceptor.KeyGenerator接口，并使用该参数来指定。需要注意的是：该参数与key是互斥的
  • cacheManager：用于指定使用哪个缓存管理器，非必需。只有当有多个时才需要使用
  • cacheResolver：用于指定使用那个缓存解析器，非必需。需通过org.springframework.cache.interceptor.CacheResolver接口来实现自己的缓存解析器，并用该参数指定。
  1. @Cacheable(value = "user", key = "#id")
  2. User selectUserById(final Integer id);

@CachePut

应用到写数据的方法上，如新增/修改方法，调用方法时会自动把相应的数据放入缓存，@CachePut的参数与@Cacheable类似，示例如下：

  1. @CachePut(value = "user", key = "#user.id")  
  2. public User save(User user) {  
  3.     users.add(user);  
  4.     return user;  
  5. }

@CacheEvict

应用到移除数据的方法上，如删除方法，调用方法时会从缓存中移除相应的数据，示例如下：

  1. @CacheEvict(value = "user", key = "#id")
  2. void delete(final Integer id);

除了同@Cacheable一样的参数之外，@CacheEvict还有下面两个参数：

  • allEntries：非必需，默认为false。当为true时，会移除所有数据
  • beforeInvocation：非必需，默认为false，会在调用方法之后移除数据。当为true时，会在调用方法之前移除数据。

@Caching

组合多个Cache注解使用。示例：

  1. @Caching( 
  2.     put = { 
  3.         @CachePut(value = "user", key = "#user.id"), 
  4.         @CachePut(value = "user", key = "#user.username"), 
  5.         @CachePut(value = "user", key = "#user.age") 
  6.    } 
  7. }

将id—>user；username—->user；age—->user进行缓存。

定时调度集成-Quartz

  1.     在日常项目运行中，我们总会有需求在某一时间段周期性的执行某个动作。比如每天在某个时间段导出报表，或者每隔多久统计一次现在在线的用户量等。
  3.     在Spring Boot中有Java自带的java.util.Timer类，SpringBoot自带的Scheduled来实现,也有强大的调度器Quartz。Scheduled 在Spring3.X 引入，默认SpringBoot自带该功能,使用起来也很简单，在启动类级别添加@EnableScheduling注解即可引入定时任务环境。但遗憾的是Scheduled  默认不支持分布式环境，这里主要讲解Quartz 时钟调度框架与Spring Boot 集成。

环境整合配置

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-quartz</artifactId>
  4. </dependency>

源代码添加

定义job

com.xxxx.springboot下添加jobs包,定义待执行job任务

  1. public class MyFirstJob implements Job {
  3.     private Logger log = LoggerFactory.getLogger(MyFirstJob.class);
  4.     @Override
  5.     public void execute(JobExecutionContext context) throws JobExecutionException {
  6.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  7.         TriggerKey triggerKey =  context.getTrigger().getKey();
  8.         log.info("触发器:"+triggerKey.getName()+"-->所属组:"+triggerKey.getGroup()+"-->"+sdf.format(new Date())+"-->"+"hello Spring Boot Quartz...");
  9.     }
  10. }

构建调度配置类

  1. @Configuration
  2. public class QuartzConfig {
  4.     @Bean
  5.     public JobDetail jobDetail1(){
  6.         return JobBuilder.newJob(MyFirstJob.class).storeDurably().build();
  7.     }
  9.     @Bean
  10.     public Trigger trigger1(){
  11.         SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
  12.                 //每一秒执行一次
  13.                 .withIntervalInSeconds(1)
  14.                 //永久重复，一直执行下去
  15.                 .repeatForever();
  16.         return TriggerBuilder.newTrigger()
  17.                 .withIdentity("trigger1","group1")
  18.                 .withSchedule(scheduleBuilder)
  19.                 .forJob(jobDetail1())
  20.                 .build();
  21.     }
  23.     // 每两秒触发一次任务
  24.     @Bean
  25.     public Trigger trigger2(){
  26.         return TriggerBuilder.newTrigger()
  27.                 .withIdentity("trigger2", "group1")
  28.                 .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ? *"))
  29.                 .forJob(jobDetail1())
  30.                 .build();
  31.     }
  32. }

启动StarterApplication 查看控制台打印效果

全局异常与事物控制

Spring Boot事物支持

  1.     在使用Jdbc 作为数据库访问技术时，Spring Boot框架定义了基于jdbc 的PlatformTransactionManager 接口的实现DataSourceTransactionManager,并在Spring Boot 应用启动时自动进行配置。如果使用jpa 的话 Spring Boot 同样提供了对应实现。

12SpringBoot - 图2

image-20200304112205932

  1.     这里Spring Boot 集成了Mybatis框架，Mybatis底层数据访问层实现基于jdbc 来实现，所以在Spring Boot 环境下对事物进行控制，事物实现由Spring Boot实现并自动配置，在使用时通过注解方式标注相关方法加入事物控制即可
  • 声明式事物配置
  1. @Transactional(propagation = Propagation.REQUIRED)
  2.     public void saveUser(User user) {
  3.         AssertUtil.isTrue(StringUtils.isBlank(user.getUserName()), "用户名不能为空!");
  4.         AssertUtil.isTrue(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空!");
  5.         User temp = userMapper.queryUserByUserName(user.getUserName());
  6.         AssertUtil.isTrue(null != temp, "该用户已存在!");
  7.         AssertUtil.isTrue(userMapper.save(user)<1,"用户记录添加失败!");
  8.     }
  10.     @Transactional(propagation = Propagation.REQUIRED)
  11.     public void updateUser(User user) {
  12.         AssertUtil.isTrue(StringUtils.isBlank(user.getUserName()), "用户名不能为空!");
  13.         AssertUtil.isTrue(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空!");
  14.         User temp = userMapper.queryUserByUserName(user.getUserName());
  15.         AssertUtil.isTrue(null != temp && !(temp.getId().equals(user.getId())), "该用户已存在!");
  16.         AssertUtil.isTrue(userMapper.update(user)<1,"用户记录添加失败!");
  17.     }
  19.     @Transactional(propagation = Propagation.REQUIRED)
  20.     public  void deleteUser(Integer id){
  21.         AssertUtil.isTrue(null == id || null ==userMapper.queryById(id),"待删除记录不存在!");
  22.         AssertUtil.isTrue(userMapper.delete(id)<1,"用户删除失败!");
  23.     }

Spring Boot 全局异常处理

  1. SpringMvc 中对异常统一处理提供了相应处理方式，推荐大家使用的是实现接口HandlerExceptionResolver的方式，对代码侵入性较小。
  3. 在Spring Boot 应用中同样提供了对异常的全局性处理，相关注解如下:

@ControllerAdvice 

  1.     该注解组合了@Component注解功能,最常用的就是作为全局异常处理的切面类,同时通过该注解可以指定包扫描的范围。@ControllerAdvice约定了几种可行的返回值，如果是直接返回model类的话，需要使用@ResponseBody进行json转换

@ExceptionHandler 

  1.   该注解在Spring 3.X 版本引入，在处理异常时标注在方法级别，代表当前方法处理的异常类型有哪些 具体应用以Restful 接口为例,测试保存用户接口

全局异常应用

异常抛出与全局捕捉

  • UserController 查询接口
  1. @ApiOperation(value = "根据用户id查询用户记录")
  2. @ApiImplicitParam(name = "userId",value = "查询参数",required = true,paramType = "path")
  3. @GetMapping("user/{userId}")
  4. public User queryUserByUserId(@PathVariable  Integer userId){
  5.     return userService.queryUserByUserId(userId);
  6. }
  • UserService 查询业务方法，抛出ParamExceptions 异常
  1. public User queryUserByUserId(Integer userId){
  2.     AssertUtil.isTrue(true,"异常测试...");
  3.     return userMapper.queryById(userId);
  4. }
  • 全局异常处理类GlobalExceptionHandler定义
  1. @ControllerAdvice
  2. public class GlobalExceptionHandler{
  3.     /**
  4.      * 全局异常处理 返回json
  5.      * @param e
  6.      * @return
  7.      */
  8.     @ExceptionHandler(value = Exception.class)
  9.     @ResponseBody
  10.     public ResultInfo exceptionHandler(Exception e){
  11.         ResultInfo resultInfo=new ResultInfo();
  12.         resultInfo.setCode(300);
  13.         resultInfo.setMsg("操作失败!");
  14.         if(e instanceof ParamsException){
  15.             ParamsException pe= (ParamsException) e;
  16.             resultInfo.setMsg(pe.getMsg());
  17.             resultInfo.setCode(pe.getCode());
  18.         }
  19.         return resultInfo;
  20.     }
  21. }
  • Postman 执行测试效果

特定异常处理

通过@ExceptionHandler 标注方法可以处理特定异常，这里以用户未登录异常为例，通过全局异常进行统一处理 

  1. /**
  2.  * 用户未登录异常特殊处理 返回json
  3.  * @param authExceptions
  4.  * @return
  5.  */
  6. @ExceptionHandler(value = NoLoginException.class)
  7. @ResponseBody
  8. public  ResultInfo userNotLoginHandler(NoLoginException authExceptions){
  9.     System.out.println("用户未登录异常处理。。。");
  10.     return new ResultInfo(authExceptions.getCode(),authExceptions.getMsg());
  11. }

在用户添加接口中抛出未登录异常为例进行测试

  1. @PutMapping("user")
  2. @ApiOperation(value = "用户添加")
  3. @ApiImplicitParam(name = "user",value = "用户实体类",dataType = "User")
  4. public ResultInfo saveUser(@RequestBody  User user){
  5.     if(1==1){
  6.         throw  new NoLoginException();
  7.     }
  8.     ResultInfo resultInfo=new ResultInfo();
  9.         userService.saveUser(user);
  10.     return resultInfo;
  11. }

SpringBoot 数据校验-Validation

  1.     日常项目开发中，对于前端提交的表单，后台接口接收到表单数据后，为了程序的严谨性，通常后端会加入业务参数的合法校验操作来避免程序的非技术性bug，这里对于客户端提交的数据校验，SpringBoot通过spring-boot-starter-validation 模块包含了数据校验的工作。
  3. 这里主要介绍Spring Boot中对请求数据进行校验，相关概念如下
  • JSR303/JSR-349: JSR303是一项标准,只提供规范不提供实现，规定一些校验规范即校验注解，如@Null，@NotNull，@Pattern，位于javax.validation.constraints包下。JSR-349是其升级版本，添加了一些新特性。
  • Hibernate Validation：Hibernate Validation是对这个规范的实现，并增加了一些其他校验注解，如@Email，@Length，@Range等等
  • Spring Validation：Spring Validation对Hibernate Validation进行了二次封装，在Spring Mvc模块中添加了自动校验，并将校验信息封装进了特定的类中

环境配置

  1.     实现参数校验，程序必须引入spring-boot-starter-validation 依赖，只是在引入spring-boot-starter-web依赖时，该模块会自动依赖spring-boot-starter-validation，所以程序中引入spring-boot-starter-web 会一并依赖spring-boot-starter-validation到项目中。

校验相关注解

注解 功能
@AssertFalse 可以为null,如果不为null的话必须为false
@AssertTrue 可以为null,如果不为null的话必须为true
@DecimalMax 设置不能超过最大值
@DecimalMin 设置不能超过最小值
@Digits 设置必须是数字且数字整数的位数和小数的位数必须在指定范围内
@Future 日期必须在当前日期的未来
@Past 日期必须在当前日期的过去
@Max 最大不得超过此最大值
@Min 最大不得小于此最小值
@NotNull 不能为null，可以是空
@Pattern 必须满足指定的正则表达式
@Size 集合、数组、map等的size()值必须在指定范围内
@Email 必须是email格式
@Length 长度必须在指定范围内
@NotBlank 字符串不能为null,字符串trin()后也不能等于“”
@NotEmpty 不能为null，集合、数组、map等size()不能为0；字符串trin()后可以等于“”
@Range 值必须在指定范围内
@URL 必须是一个URL

参数校验注解使用

  • User实体类参数校验注解
  1. public class User  implements Serializable {
  2.     private Integer id;
  3.     @NotBlank(message = "用户名不能为空!")
  4.     private String userName;
  6.     @NotBlank(message = "用户密码不能为空!")
  7.     @Length(min = 6, max = 10,message = "密码长度至少6位但不超过10位!")
  8.     private String userPwd;
  9.     @Email
  10.     private String email;
  12.     /*
  13.       省略get set 方法  
  14.     */
  15. }
  • 接口方法形参@Valid注解添加
  1. @PostMapping("user02")
  2. @ApiOperation(value = "用户添加")
  3. @ApiImplicitParam(name = "user02",value = "用户实体类",dataType = "User")
  4. public ResultInfo saveUser02(@Valid  User user){
  5.     ResultInfo resultInfo=new ResultInfo();
  6.     //userService.saveUser(user);
  7.     return resultInfo;
  8. }
  • 全局异常错误信息捕捉
  1. /**
  2.  * 全局异常处理 返回json
  3.  * @param e
  4.  * @return
  5.  */
  6. @ExceptionHandler(value = Exception.class)
  7. @ResponseBody
  8. public ResultInfo exceptionHandler(Exception e){
  9.     ResultInfo resultInfo=new ResultInfo();
  10.     resultInfo.setCode(300);
  11.     resultInfo.setMsg("操作失败!");
  12.     if(e instanceof ParamsException){
  13.         ParamsException pe= (ParamsException) e;
  14.         resultInfo.setMsg(pe.getMsg());
  15.         resultInfo.setCode(pe.getCode());
  16.     }else if(e instanceof BindException){
  17.         BindException be = (BindException) e;
  18.         resultInfo.setResult(be.getBindingResult().getFieldError().getDefaultMessage());
  19.     }
  20.     return resultInfo;
  21. }
  • PostMan 接口测试

总结

  1.     今天课程主要介绍了SpringBoot中各种环境的整合与测试工作，持久层框架Mybatis集成与数据访问基本操作，借助SpringBoot单元测试实现业务方法与控制器接口测试，同时集成了Swagger2 接口文件生成工具来快速生成接口文档的功能。在web项目开发中常见的项目热部署配置，这里集成DevTools工具来帮助web开发者在项目开发中不断手动启动服务器部署项目的繁琐流程，通过引入EhCache 缓存技术来加快应用程序数据的访问效率，然后对于项目中常见的定时任务的执行，这里集成了Quartz 任务调度框架来实现任务定时执行处理，最后提到了SpringBoot 应用中对象项目事物控制与异常统一处理，从而提高项目代码的健壮性与数据的一致性，借助SpringBoot 的Validation 实现后端数据参数的校验机制，结合全局异常来对校验结果进行输出操作，提高后端应参数处理的严谨性。