Spring Boot

项目开发

Spring Boot原理

Spring Boot有一个全局配置文件：application.properties或application.yml。

通过这个配置文件，我们可以对其中的一些配置按照自己的意愿进行配置。

在使用配置文件之前需要了解一下Spring Boot的自动装配过程，可以让我们对配置文件有更深层次的了解。

在Spring Boot启动类中有一个注解@SpringBootApplication，该注解中有两个比较重要的注解

@SpringBootConfiguration
@EnableAutoConfiguration

• @EnableAutoConfiguration

  • 该注解的意思是开启自动配置，该注解也是一个派生注解

  • 在该注解中也有两个重要的注解

    @AutoConfigurationPackage
    @Import({AutoConfigurationImportSelector.class})
    

  • @AutoConfigurationPackage：自动配置包

    • @Import({Registrar.class})：自动注册包

  • @Import({AutoConfigurationImportSelector.class})自动配置导入选择（自动导入包的核心）

    • 通过注解导入的类AutoConfigurationImportSelector：自动导入选择器

    • 在此类中：

    • //获取获选的配置
      List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
      

    • 核心方法：getCandidateConfigurations 获取候选的配置

      protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
          List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
          Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
          return configurations;
      }
      

      

      • 上述的getSpringFactoriesLoaderFactoryClass()方法返回了一个EnableAutoConfiguration.class，该注解就是@SpringBootApplication中的两大核心注解。标注了EnableAutoConfiguration注解的类，也就是主启动类。

      • 上述的第一个方法中调用了loadFactoryNames()方法

        • 该方法获取所有的加载配置，方法返回的loadSpringFactories方法中加载了META-INF/spring.factories配置文件

      

    • spring.factories为核心配置文件

      

      • 里面包含了很多XxxxAutoConfiguration格式的自动配置类，就是这些类给容器中导入了这个场景需要的所有组件。

      • 这些配置类中包含了一个核心的注解@ConditionalOnClass，如果该注解中的条件都满足，当前配置类才会生效。

        • 常见的条件注解

          @ConditionalOnBean：当容器里有指定的bean的条件下。
          
          @ConditionalOnMissingBean：当容器里不存在指定bean的条件下。
          
          @ConditionalOnClass：当类路径下有指定类的条件下。
          
          @ConditionalOnMissingClass：当类路径下不存在指定类的条件下。
          
          @ConditionalOnProperty：指定的属性是否有指定的值，比如@ConditionalOnProperties(prefix=”xxx.xxx”, value=”enable”, matchIfMissing=true)，代表当xxx.xxx为enable时条件的布尔值为true，如果没有设置的情况下也为true。
          

    • 上述这些操作就是为了让Spring Boot的启动类下的所有资源被加载

application.properties配置文件

• 通过该配置文件可以修改自动配置类的一些属性，实现配置的自定义。
• XxxxAutoConfiguration格式的自动配置类中通过@EnableConfigurationProperties({XxxxProperties.class})注解来绑定到对应的Properties类中，在XxxxProperties类中有一个注解@ConfigurationProperties，它的作用就是从配置文件中绑定属性到对应的bean上，以实现对属性的配置。
  • 给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可。
  • @ConfigurationProperties注解中可以指定前缀，通过这个前缀可以更加便捷的引用到当前配置文件中。
  • 在全局配置的属性如：server.port等，通过@ConfigurationProperties注解，绑定到对应的XxxxProperties配置实体类上封装为一个bean，然后再通过@EnableConfigurationProperties注解导入到Spring容器中。
    • xxxxAutoConfigurartion：自动配置类；给容器中添加组件；
    • xxxxProperties:封装配置文件中相关属性；
    • @EnableConfigurationProperties注解：开启配置属性

总结：

Spring Boot所有配置都是在启动的时候扫描并加载：spring.factories其中包含了所有的自动配置类，自动配置类不一定会生效，因为这些类中都有一个@ConditionalOnClass注解，只有满足这个注解中所有的条件，自动配置类才会生效，可以通过在依赖中导入对应的start，来得到对应的启动器，有了启动器，注解中的条件就能满足，自动配置类就能生效了。

Spring Boot启动的时候会通过@EnableAutoConfiguration注解找到META-INF/spring.factories配置文件中的所有自动配置类，并对其进行加载，而这些自动配置类都是以AutoConfiguration结尾来命名的，它实际上就是一个JavaConfig形式的Spring容器配置类，它能通过以Properties结尾命名的类中取得在全局配置文件中配置的属性如：server.port，而XxxxProperties类是通过@ConfigurationProperties注解与全局配置文件中对应的属性进行绑定的。

1、项目搭建

• 在java文件下新建config文件夹
  • 主要是对Spring Boot一些功能的重写和扩展
    • 例如拦截器，实现页面的国际化（页面中英文切换），进行一些简单的视图控制跳转，将自定义的功能注入到容器中。
• resources文件夹主要存放前端页面，templates文件夹存放前端页面，static文件夹存放一些静态资源，如css样式，图片等等。
  • 在templates文件夹下，可以对页面进一步分类。

2、Thymeleaf

Thymeleaf是一个适用于Web和独立环境的现代服务器端Java模板引擎。

Thymeleaf的主要目标是为您的开发工作流程带来优雅的自然模板 - 可以在浏览器中正确显示的HTML，也可以用作静态原型，从而在开发团队中实现更强大的协作。

通过Spring Framework模块，与您喜欢的工具的大量集成，以及插入您自己的功能的能力，Thymeleaf是现代HTML5 JVM Web开发的理想选择 - 尽管它可以做得更多。

我们只需要把我们的html页面放在类路径下的templates文件夹下，thymeleaf就可以帮我们自动渲染了。

• 导入对应的依赖

  <!--thymeleaf-->
  <dependency>
  	<groupId>org.springframework.boot</groupId>
  	<artifactId>spring-boot-starter-thymeleaf</artifactId>
  </dependency>
  

• 在需要使用Thymeleaf的页面上需要导入命名空间

  xmlns:th="http://www.thymeleaf.org"
  

• 基础语法

  • 文本标签：th:text/th:utext
    • th:text 进行文本替换 不会解析html
    • th:utext 进行文本替换 会解析html
  • 字符串拼接

• 拼接字符串通过 + 或者 | 进行拼接

• 基础表达式

  • ${.}表示获取变量的值。
    • 正常情况下 *{…} 和 ${…}是一样的，但是 *{…} 一般和 th:object 进行一起使用来完成对象属性的简写。
  • #{.}表示消息表达式，用于国际化message.properties 属性读取。
  • @{.}表示获取URL链接
  • ~{.}表示片段表达式，可以引用片段到页面

• 常用表达式

  • 条件判断

    • th:if 当条件为true则显示。
    • th:unless 当条件为false 则显示。

  • 循环

    • th:each 遍历集合

      <!--遍历的结果存放在dept中-->
      th:each="dept:${departments}" 
      

  • th:href

    • 用于声明在a 标签上的href属性的链接 该语法会和@{…} 表达式一起使用。

3、基础功能实现

• 用户输入用户和密码以实现用户登录，通过提交表单的方式实现用户的信息验证

• 表单：通过提交表单的方式来对页面中的数据进行传递

  <form class="form-signin" th:action="@{/user/login}">
      具体功能的实现
  </form>
  

• 页面公共部分的抽取

  • 在编写一个网站的时候，我们可以将一些公共的页面片段抽取出来，达到复用的功能。

  • 新建conmmons.html用于存放公共页面

  • 在标签中添加th:fragment=“属性名”，标记为fragment片段

  • 引用：

    <!--使用replace可以达到同样的效果
    	~{包名/文件名::片段属性名}
    -->
    th:insert="~{commons/conmmons.html::topbar}"
    

• MVC配置类

  • 编写自定义类实现WebMvcConfigurer接口，再添加一个@Configuration注解，表明该类是一个配置类。

    • 通过对接口中一些方法的重写，从而实现对Spring MVC的扩展。

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.LocaleResolver;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    //MVC的配置
    @Configuration
    public class MyMvcConfig implements WebMvcConfigurer {
    
        //控制视图的跳转
        @Override
        public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/").setViewName("index");
            registry.addViewController("/index.html").setViewName("index");
            registry.addViewController("/main.html").setViewName("dashboard");
        }
    }
    

• 页面国际化

  • 在resources文件夹下编写i18n文件夹用于存放需要切换的文字。

    • 在i18n文件夹下新建login.properties用于存放默认显示的文字。
    • 新建login_en_US.properties用于存放英文文字。
    • 新建login_zh_CN.properties用于存放中文文字。

  • 在login_en_US.properties和login_zh_CN.properties文件下存放对应的文字。

    • 在IDEA中点击文件下方的Resource Bundle可以更加便捷的编写对应的文字。

  • 在application.properties配置文件中进行配置

    spring.messages.basename=i18n.login
    

  • 在页面对应的文字处进行引用

    <!--对对应的文字进行取值-->
    #{属性名}
    

  • 编写自定义类实现页面语言的自主切换

    import org.springframework.web.servlet.LocaleResolver;
    import org.thymeleaf.util.StringUtils;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.Locale;
    
    //实现页面的国际化
    public class MyLocaleResolver implements LocaleResolver {
    
        //解析请求
        @Override
        public Locale resolveLocale(HttpServletRequest httpServletRequest) {
            //获取请求中的语言参数
            String language = httpServletRequest.getParameter("l");
            Locale locale = Locale.getDefault();    //如果没有就是用默认的
            //如果请求的链接携带了国际化的参数
            if (!StringUtils.isEmpty(language)) {
                //zh_CN
                String[] split = language.split("_");
                //国家，地区
                locale = new Locale(split[0], split[1]);
            }
    
            return locale;
        }
    
        @Override
        public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {
    
        }
    }
    

  • 在MVC配置类中将自己写的组件配置到容器中

     //自动化的国家组件就生效了
    @Bean
    public LocaleResolver localeResolver() {
    	return new MyLocaleResolver();
    }
    

  • 在前端页面中接收参数

    <a class="btn btn-sm" th:href="@{/index.html(l='zh_CN')}">中文</a>
    <a class="btn btn-sm" th:href="@{/index.html(l='en_US')}">English</a>
    

  • 容器自动帮我将页面中的文字进行配对，实现页面的国际化。

• 拦截器

  • 编写自定义类实现HandlerInterceptor接口

    import org.springframework.web.servlet.HandlerInterceptor;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    //编写拦截器，实现用户权限控制
    public class LoginHandlerInterceptor implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            //登录成功之后，应该有用户的session
            Object loginUser = request.getSession().getAttribute("loginUser");
    
            if (loginUser == null) {
                //没有登录
                request.setAttribute("msg", "没有权限，请先登录");
                request.getRequestDispatcher("/index.html").forward(request, response);
    
                return false;
            } else {
                return true;
            }
        }
    }
    
    

  • 在MVC配置类中重写addInterceptors方法

    • addPathPatterns：需要拦截的请求
    • excludePathPatterns：哪些请求不需要拦截

    //将自定义的拦截器配置到容器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor())
            .addPathPatterns("/**")
            .excludePathPatterns("/index.html", "/", "/user/login","/css/**","/js/**", "/img/**");
    }
    

• 侧边栏点击高亮实现

  <!--其中的list.html是需要高亮页面所携带的参数
  -->
  <a th:class="${active=='list.html'?'nav-link active':'nav-link'}">
  

  • 在需要高亮页面中，通过在导入fragment的HTML代码中携带参数然后传递给侧边栏，然后在侧边栏模块中进行判断。

  <div th:insert="~{commons/conmmons.html::sidebar(active='list.html')}"></div>
  

4、Druid数据源

• 导入Druid数据源依赖

  <!--druid数据源-->
  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.3</version>
  </dependency>
  

• Spring Boo 2.0 以上默认使用的数据源是Hikari，可以通过spring.datasource.type 指定数据源。

  spring:
    datasource:
      username: root
      password: root
      url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.alibaba.druid.pool.DruidDataSource
  

• 对Druid数据源进行配置

  #SpringBoot默认是不注入这些的，需要自己绑定
  #druid数据源专有配置
  initialSize: 5
  minIdle: 5
  maxActive: 20
  maxWait: 60000
  timeBetweenEvictionRunsMillis: 60000
  minEvictableIdleTimeMillis: 300000
  validationQuery: SELECT 1 FROM DUAL
  testWhileIdle: true
  testOnBorrow: false
  testOnReturn: false
  poolPreparedStatements: true
  #配置监控统计拦截的filters，stat：监控统计、log4j：日志记录、wall：防御sql注入
  #如果允许报错，java.lang.ClassNotFoundException: org.apache.Log4j.Properity
  #则导入log4j 依赖就行
  filters: stat,wall,log4j
  maxPoolPreparedStatementPerConnectionSize: 20
  useGlobalDataSourceStat: true
  connectionoProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
  

  • 要使用log4j就需要导入其对应的依赖

• 我们需要自己为DruidDataSource 绑定全局配置文件中的参数，再添加到容器中，而不再使用 Spring Boot 的自动生成了。

  • 编写配置类，代码大部分是固定，使用时可以按照自己的需求进行添加和修改

  package com.tian.config;
  
  import com.alibaba.druid.pool.DruidDataSource;
  import com.alibaba.druid.support.http.StatViewServlet;
  import org.springframework.boot.context.properties.ConfigurationProperties;
  import org.springframework.boot.web.servlet.ServletRegistrationBean;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  import javax.sql.DataSource;
  import java.util.HashMap;
  
  @Configuration
  public class DruidConfig {
  
      @ConfigurationProperties(prefix = "spring.datasource")
      @Bean
      public DataSource druidDataSource() {
          return new DruidDataSource();
      }
  
      //后台监控
      @Bean
      public ServletRegistrationBean statViewServlet() {
          ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
  
          //后台需要有人登陆
          HashMap<String, String> initParameters = new HashMap();
  
          //增加配置
          initParameters.put("loginUsername", "admin");
          initParameters.put("loginPassword", "123456");
  
          //允许谁可以访问
          initParameters.put("allow", "");
  
          bean.setInitParameters(initParameters); //设置初始化参数
          return bean;
      }
  }
  

• 配置完毕后，可以访问http://localhost:8080/druid/login.html检测是否配置成功。

5、整合Mybatis

• 导入所需要的依赖

  <!--mybatis-->
  <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.2.0</version>
  </dependency>
  

• 配置数据库连接信息（这里默认使用的是Hikari数据源，可以按照自己的需求配置数据源）

  spring:
    datasource:
      username: root
      password: root
      url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
      driver-class-name: com.mysql.cj.jdbc.Driver
  # 整合mybatis
  mybatis:
    type-aliases-package: com.tian.pojo
    mapper-locations: classpath:mybatis/mapper/*.xml
  

• 创建实体类（这里需要导入lombok依赖）

  package com.tian.pojo;
  
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class User {
      private int id;
      private String name;
      private String pwd;
  }
  

• 编写对应的mapper接口

  package com.tian.mapper;
  
  import com.tian.pojo.User;
  import org.apache.ibatis.annotations.Mapper;
  import org.springframework.stereotype.Repository;
  
  import java.util.List;
  
  //@Mapper这个注解表示了这个一个mybatis的Mapper类
  //dao层使用@Repository注解
  @Mapper
  @Repository
  public interface UserMapper {
      //查询所有用户
      List<User> queryUserList();
  
      //查询一个用户
      User queryUserById(int id);
  
      //增加一个用户
      int addUser(User user);
  
      //修改用户
      int update(User user);
  
      //删除用户
      int delete(int id);
  }
  

• 编写对应的mapper映射文件

  • 建议在resources目录下新建mybatis文件夹，再在mybatis文件夹下新建mapper文件夹用于存放映射文件。

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.tian.mapper.UserMapper">
      
      <select id="queryUserList" resultType="User">
          select * from user
      </select>
  
      <select id="queryUserById" resultType="User" parameterType="_int">
          select * from USER where id = #{id}
      </select>
  
      <insert id="addUser" parameterType="User">
          insert into user VALUES (#{id},#{name},#{pwd})
      </insert>
  
      <update id="update" parameterType="User">
          update user set name = #{name}, pwd = #{pwd}
              where id=#{id}
      </update>
  
      <delete id="delete" parameterType="_int">
          delete * from user where id = #{id}
      </delete>
  
  </mapper>
  

• 编写service层

  package com.tian.service;
  
  import com.tian.mapper.UserMapper;
  import com.tian.pojo.User;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  
  import java.util.List;
  
  @Service
  public class UserService {
      @Autowired
      private UserMapper userMapper;
  
      //查询所有用户
      public List<User> queryUserList(){
          return userMapper.queryUserList();
      }
  
      //查询一个用户
      public User queryUserById(int id){
          return userMapper.queryUserById(id);
      }
  
      //增加一个用户
      public int addUser(User user){
          return userMapper.addUser(user);
      }
  
      //修改用户
      public int update(User user){
          return userMapper.update(user);
      }
  
      //删除用户
      public int delete(int id){
          return userMapper.delete(id);
      }
  }
  

• 最后编写controller层进行测试即可。

6、Spring Security

Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它实际上是保护基于spring的应用程序的标准。

Spring Security是一个框架，侧重于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring安全性的真正强大之处在于它可以轻松地扩展以满足定制需求。

• spring security 的核心功能主要包括：

  • 认证 （你是谁）
  • 授权 （你能干什么）
  • 攻击防护 （防止伪造身份）

• 导入Spring Security依赖

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security</artifactId>
  </dependency>
  

• 编写 Spring Security 配置类

  package com.kuang.config;
   
  import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
   
  @EnableWebSecurity // 开启WebSecurity模式
  public class SecurityConfig extends WebSecurityConfigurerAdapter {
   
      @Override
      protected void configure(HttpSecurity http) throws Exception {
          
      }
  }
  

  • 定制请求的授权规则

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 定制请求的授权规则
        // 首页所有人可以访问
        http.authorizeRequests().antMatchers("/").permitAll()
        .antMatchers("/level1/**").hasRole("vip1")
        .antMatchers("/level2/**").hasRole("vip2")
        .antMatchers("/level3/**").hasRole("vip3");
    }
    

  • 在configure()方法中加入以下配置，开启自动配置的登录功能！

    // 开启自动配置的登录功能
    // /login 请求来到登录页
    // /login?error 重定向到这里表示登录失败
    http.formLogin();
    

  • 定义认证规则

    //认证
    /*
            密码编码：PasswordEncoder
            在Spring Security 5.0+新增了许多加密方式，用户必须对密码进行加密，否则不能使用
         */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
            .withUser("tian").password(new BCryptPasswordEncoder().encode("123456")).roles("vip2","vip3")
            .and()
            .withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3")
            .and()
            .withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1");
    }
    

• Spring Security - thymeleaf整合

  • 导入依赖

    <!-- https://mvnrepository.com/artifact/org.thymeleaf.extras/thymeleaf-extras-springsecurity4 -->
    <dependency>
        <groupId>org.thymeleaf.extras</groupId>
        <artifactId>thymeleaf-extras-springsecurity5</artifactId>
        <version>3.0.4.RELEASE</version>
    </dependency>
    

  • 导入命名空间

    xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5"
    

• 定制登录页

  http.formLogin().loginPage("请求地址");
  

7、Swagger

简介：

• 前端和后端间通过API接口进行联系，API文档变成了前后端开发人员联系的纽带。
• Swagger就是一款能很好的书写API文档的框架。
• Restful Api 文档在线自动生成器 => API 文档 与API 定义同步更新。

Spring Boot集成Swagger

• 导入依赖

  <!--swagger-->
  <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
  <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-swagger2</artifactId>
      <version>2.9.2</version>
  </dependency>
  <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
  <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-swagger-ui</artifactId>
      <version>2.9.2</version>
  </dependency>
  

• 编写Swagger配置类SwaggerConfig来配置 Swagger

  @Configuration //表明这个类是一个配置类
  @EnableSwagger2// 开启Swagger2的自动配置
  public class SwaggerConfig {  
  }
  

• 访问：http://localhost:8080/swagger-ui.html ，可测试是否配置完成。

• 在Swagger配置类SwaggerConfig中，自定义Swagger的一些配置。

  //配置Swagger信息=apiInfo，替换掉默认的信息
  private ApiInfo apiInfo() {
      //作者信息
      Contact contact = new Contact("天", "www.baidu.com","2426793192@qq.com");
  
      return new ApiInfo(
          "Swagger学习"
          , "Swagger文档"
          , "1.0"
          , "www.baidu.com"
          , contact
          , "Apache 2.0"
          , "http://www.apache.org/licenses/LICENSE-2.0"
          , new ArrayList());
  }
  

  • Docket实例关联上自定义的apiInfo()

  @Bean
  public Docket docket() {
      return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo());
  }
  

• 配置扫描接口

  • 通过配置扫描接口可以自定义Swagger要扫描哪些包，哪些请求需要显示在API文档上。

  通过在注入Docket实例时配置一些信息

  //配置了Swagger的Docket的bean实例
  @Bean
  public Docket docket(Environment environment) {
      return new Docket(DocumentationType.SWAGGER_2)
          .apiInfo(apiInfo())
          .select()
          //RequestHandlerSelectors 配置要扫描接口的方式
          //basePackage：指定要扫描的包
          .apis(RequestHandlerSelectors.basePackage("com.tian.swagger.controller"))
          .build();
  }
  

• 配置Swagger开关

  • 在实际开发中会存在几个不同的环境，通过新建properties配置文件的方式来规划好不同开发环境需要使用到的配置

  • 开发时会使用Swagger，在项目正式交付运行之后会关闭掉Swagger，不然会泄露该项目的API接口。

  • 在主配置文件application.properties中，可以选择要使用到的开发环境

    # 表示当前使用到的是dev开发环境
    spring.profiles.active=dev
    

  • 通过enable()方法配置是否启用swagger，如果是false，swagger将不能在浏览器中访问了。

  @Bean
  public Docket docket(Environment environment) {
      // 设置要显示swagger的环境
      Profiles profiles = Profiles.of("dev", "test");
      //通过environment.acceptsProfiles判断是否处在自己设定的环境中
      boolean flag = environment.acceptsProfiles(profiles);
      
      return new Docket(DocumentationType.SWAGGER_2)
          .apiInfo(apiInfo())
          .enable(flag) //配置是否启用Swagger，如果是false，在浏览器将无法访问
          .select()// 通过.select()方法，去配置扫描接口,RequestHandlerSelectors配置如何扫描接口
          .apis(RequestHandlerSelectors.basePackage("com.tian.swagger.controller"))
          // 配置如何通过path过滤,即这里只扫描请求以/tian开头的接口
          .paths(PathSelectors.ant("/tian/**"))
          .build();
  }
  

• API分组

  @Bean
  public Docket docket(Environment environment) {
      return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
          .groupName("hello") // 设置分组名称
          // 省略配置....
  }
  

  • 通过配置多个Docket即可实现创建多个组，通过groupName来区分组名。

• 常用注解

  Swagger注解	说明
  @Api(tags = “xxx模块说明”)	作用在模块类上
  @ApiOperation(“xxx接口说明”)	作用在接口方法上
  @ApiModel(“xxxPOJO说明”)	作用在模型类上：如VO、BO
  @ApiModelProperty(value = “xxx属性说明”,hidden = true)	作用在类方法和属性上，hidden设置为true可以隐藏该属性
  @ApiParam(“xxx参数说明”)	作用在参数、方法和字段上，类似@ApiModelProperty