java高级--SpringBoot篇

怼烎@ 2023-10-03 21:32 78阅读 0赞

**目录**

一、什么是SpringBoot

二、SpringBoot的特点

三、springboot快速入门

四、介绍配置文件的种类

五、开发环境配置文件的切换

六、读取springboot配置文件中的内容

七、Springboot注册web三大组件

八、SpringBoot的底层原理

8.1 包扫描的原理

8.2 springboot自动装配原理

九、自定义starter依赖

9.1 创建一个springboot工程并引入相关得依赖

9.2 创建一个属性类

9.3 定义一个业务类

9.4 定义一个自动装配类

9.5 在resource下创建一个目录MATE-INF 里面创建一个文件名spring.factories

9.6 打包--maven 配置了本地仓库

十、springboot整合数据源

10.1 引入数据源得启动依赖

10.2 指定数据源得信息

10.3 测试

10.4 springboot整合第三方数据源

10.5 测试

十一、springBoot整合Mybatis

11.1 引依赖

11.2 修改配置文件

11.3 写一个实体类(省略)

11.4 创建Dao接口

11.5 映射文件

11.6 在springboot启动类上加上--dao接口得扫描

11.7 测试---必须为springboot得单元测试【不能使用之前junit得测试】

十二、springboot整合pageHelper

十三、springboot整合定时器

13.1 引入定时器的依赖

13.2 定义定时器的业务类

13.3 开启定时器的注解

十四、 springboot整合swagger2

14.1 我们如何使用swagger2? springboot的版本不能那么高。2.2~2.5之间

14.2 创建一个swagger配置类---所有的功能都集成在Docket类

14.3 开启swagger2注解

14.4 定义相关的接口

14.5 查看swagger2的界面

14.6 最终的配置类完整格式

十五、thymeleaf模板引擎

--------------------

## 一、什么是SpringBoot ##

> **大家想一想，在我们搭建spring应用程序时，你认为什么最麻烦。**
> 
> 1.  **配置xml文件麻烦。---spring的配置文件。web.xml**
> 2.  **很多依赖。**
> 3.  **tomcat启动速度很忙。**
> 
>  **Spring Boot是由Pivotal团队提供的全新[框架][Link 1]，其设计目的是用来[简化][Link 2]新[Spring][]应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置【自动装配类】，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。**

## 二、SpringBoot的特点 ##

> **（1）可以创建独立的[Spring][]应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs；**
> 
> **（2）内嵌Tomcat或Jetty等Servlet容器；**
> 
> **（3）提供自动配置的“starter”项目对象模型（POMS）以简化[Maven][]配置；**
> 
> （4）尽可能自动配置Spring容器；--xml配置文件麻烦
> 
> **（5）提供准备好的特性，如指标、健康检查和外部化配置；**
> 
> **（6）绝对没有代码生成，不需要XML配置。**

## 三、springboot快速入门 ##

>  **具备条件:**
> 
>  **JDK至少1.8以上。**
> 
>  **maven至少3.2.5以上。**
> 
>  **开发工具---idea \[eclipse\]**

![520049b96ef14482b5133fe46e374369.png][]

![5ad4a6de44d84089b8f9223c5d3483b8.png][]

![22fd1f70510049b38c7e16af2912d2ad.png][]

![a2a6c666ee984f6f850cb5822c2c1f5b.png][]

>  **要把pom文件中的版本号更改**

![c7034400baca41ae9a8f2154b76321e2.png][]

>  **创建一个HelloController类，该类所在的包必须是主函数下的包或子包下。**

![56133a9b9e2441aa8ae64e7b55a1b835.png][]

## 四、介绍配置文件的种类 ##

>  **springboot支持两种配置文件的类型:**
> 
>  **第一种: 属性文件\[.properties\] 格式: key=value**
> 
>  **第二种: yaml文件 \[.yml\] 格式： 层级关系 key: value**
> 
>  **不管是哪种，他们的前置必须都是application.**

**属性文件properties:**

# 设置tomcat的端口号
    server.port=8888
    
    # 上下文访问路径
    server.servlet.context-path=/aaa

**yaml文件:**

# 设置端口号
    server:
    port: 8887
    # 设置上下文路径
    servlet:
     context-path: /bbb

>  **上面两种配置文件可以同时存在，里面的内容如果相同，则properties的优先级高于yaml文件。**

## 五、开发环境配置文件的切换 ##

>  **我们在真实开发过程中:会存在很多环境，而且每个环境他们的配置文件的内容可能不同。**
> 
>  **比如: 开发环境 测试环境 线上环境。**

![504dcc0214624d0aac3f34934f9b2422.png][]

>  **我就根据不同的环境给出不同的配置内容，你只需要切换环境---即可变成相应环境下的配置。**
> 
>  **定义多个环境下的不同配置文件: application\-环境名.properties**

![499c3c711f924ceabae1e0b1f6b68048.png][]

**在application.properties配置文件中激活相应的配置**

# 引入相关的环境配置--激活开发环境
    spring.profiles.active=test
    # 写一些不同环境下相同的配置

## 六、读取springboot配置文件中的内容 ##

>  **springboot中提供了两种读取配置文件内容的方式**

>  **第一种: 把读取的内容封装到实体类中**

![28f006fe20344bf3a5d9016930b4362b.png][]

@Autowired
        private AliPay aliPay;
        @RequestMapping("/index")
        public AliPay index(){
            return aliPay;
        }

**测试：**

![96c273e750ce4f888d5efc5844f8b366.png][]

>  **第二种: 单个属性读取**

![2c8e0be9c2774319984a6f023e2c3aec.png][] ![9fa67418d0c2448f8a7c23147bfd4241.png][]

## 七、Springboot注册web三大组件 ##

>  **web三大组件: \[1\] servlet 、\[2\] filter、 \[3\] 监听器 listene**

>  **思考: servlet定义的步骤。**
> 
>  **(1) 创建一个类并继承HttpServlet**
> 
>  **(2) 重写service方法 【doGet 或doPost方法】**
> 
>  **（3）把自定义的servlet注册到web.xml容器中。**
> 
>  **我们现在springboot不存在web.xml文件了。**

>  **注册Servlet组件**

public class MyServlet extends HttpServlet {
    
        @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("~~~~~~~~~~~~~~~~~~~~~~~");
        }
    }

package com.ykq.config;
    
    import com.ykq.servlet.MyServlet;
    import org.springframework.boot.web.servlet.ServletRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.servlet.http.HttpServlet;
    
    @Configuration //====>表示该类为配置类 等价于我们之前的xml文件
    public class MyConfig {
    
    
        @Bean //xml文件中<bean class=""> 把方法返回的对象交于spring容器来管理
        public ServletRegistrationBean<HttpServlet> registrationBean(){
            ServletRegistrationBean<HttpServlet> servletServletRegistrationBean=new ServletRegistrationBean<>();
            servletServletRegistrationBean.setName("my");
            servletServletRegistrationBean.addUrlMappings("/my");
            servletServletRegistrationBean.setServlet(new MyServlet());
            return servletServletRegistrationBean;
        }
    }

>  **注册Filter组件**
> 
>  **步骤: 1.定义一个过滤器类并实现Filter接口**
> 
>  **2.重写接口中的抽象方法**
> 
>  **3. 在web.xml文件中注册过滤器。**

public class MyFilter implements Filter {
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("过滤器编码");
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            
        }
    }

//过滤的注册
        @Bean
        public FilterRegistrationBean<Filter> filterRegistrationBean(){
            FilterRegistrationBean<Filter> filterRegistrationBean=new FilterRegistrationBean<>();
            filterRegistrationBean.setName("encondigFilter");
            filterRegistrationBean.addUrlPatterns("/*");
            filterRegistrationBean.setFilter(new MyFilter());
            return filterRegistrationBean;
        }

## 八、SpringBoot的底层原理 ##

#### 8.1 包扫描的原理 ####

>  **springboot创建的包必须在主类所在的包以及子包下，才可以被容器扫描到。**
> 
> **为什么会在主类所在的包以及子包下扫描?**
> 
> **在主函数中调用run方法，而run方法传递了一个被@SpringBootApplication注解修改的类的反射类对象 该@SpringBootApplication它是复合注解。**

![ce27fc6251c34747b646a313312d11ee.png][]

>  **@EnableAutoConfiguration 开启自动配置的注解，而该注解也是一个复合注解。**

![e035c2a9043c405b90cb6571ab689a65.png][]

>  **这里@AutoConfigurationPackage 该注解完成包的自动扫描。**

![54994a5d77b14c468c3405f2a0851193.png][]

![046f776387944e7da288b8f8b177c4f2.png][]

>  **通过上面的源码分析 我们得到默认扫描的是主类所在的包以及子包。** 
> 
> **我们是否可以自定义包扫描。---可以**

![742d7d6ac0f24518b67995f53a2ad27e.png][]

#### 8.2 springboot自动装配原理 ####

>  **思考: 我们并没有配置DispatcherServlet。 为何为拦截请求路径到相应的mapping中。** 
> 
>  **因为springboot在启动时会加载一个自动装配类，而这些自动装配会完成相应的自动装配功能。**

>  **流程:** 
> 
>  **(1)主函数调用run方法，而run方法加载了一个被@SpringBootApplication注解修饰的类。** 
> 
>  **而该注解是一个复合注解。其中包含@EnableAutoConfiguration该注解可以开启自动装配，而@EnableAutoConfiguration这个也是一个复合注解。其中包含@Import(\{AutoConfigurationImportSelector.class\})而import注解导入了一个AutoConfigurationImportSelector类，该类用来加载需要的自动装配类。而这些自动装配类完成对应的自动装配功能。**

**思考: 根据源码 我们看到上来加载了所有的自动装配了，而所有的自动装配类默认127个。这127个从哪来的。**

![0be4f9a4fdd848b8bd016e6094910358.png][]

> **分析: 自动装配类如何完成自动装配功能** 
> 
>  **（1）DipatchServletAutoConfiguration \[可以完成DispatchServlet的自动装配功能**
> 
> ![f9b7fa7daee9410e97680372bb845fa3.png][]

>  **发现传递中文没有乱码,而且返回的json数据中也没有出现乱码，因为springboot加载了编码过滤的自动装配了，而这个装配类完成了编码设置的自动装配。** 
> 
> ![e7b01d5356d242cb9c410a21bb0ff58e.png][]

## 九、自定义starter依赖 ##

>  **如果想自定义Starter，首选需要实现自动化配置，而要实现自动化配置需要满足以下两个条件：** 
> 
>   **能够自动配置项目所需要的配置信息，也就是自动加载依赖环境**
> 
>  **能够根据项目提供的信息自动生成Bean，并且注册到Bean管理容器中；**

#### 9.1 创建一个springboot工程并引入相关得依赖 ####

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-autoconfigure</artifactId>
                </dependency>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-configuration-processor</artifactId>
                    <optional>true</optional>
                </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>

#### 9.2 创建一个属性类 ####

> **作用:** **解析springboot配置文件中提供得内容。**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/11/17 14:44
     * @Version 1.0
     */
    package com.wjk;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @ConfigurationProperties(prefix = "spring.wjk")
    public class WjkProperties {
    
        private String name;
        private String address;
        private Integer age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }

#### 9.3 定义一个业务类 ####

>  **作用: 完成相关得业务操作**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/11/17 14:46
     * @Version 1.0
     */
    package com.wjk;
    
    public class WjkService {
    
        private WjkProperties wjkProperties;
    
        public WjkService() {
        }
    
        public WjkService(WjkProperties wjkProperties) {
            this.wjkProperties = wjkProperties;
        }
    
        //业务代码
        public void hello(){
            System.out.println("姓名:"+wjkProperties.getName()+"地址:"+wjkProperties.getAddress()+"年龄:"+wjkProperties.getAge());
        }
    }

#### 9.4 定义一个自动装配类 ####

>  **完成自动装配得功能。用于完成Bean创建等工作**

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/11/17 14:49
     * @Version 1.0
     */
    package com.wjk;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration //该类为配置类
    @EnableConfigurationProperties(WjkProperties.class) //开启属性配置
    @ConditionalOnClass(WjkService.class)  //只要wjkService被引后入，当中的这个类才会被创建
    @ConditionalOnProperty(prefix = "spring.wjk",value = "enabled",matchIfMissing = true) //如果引用者没有给定相关的属性值，则采用默认值
    public class WjkAutoConfiguration {
    
        @Autowired
        private WjkProperties wjkProperties;
    
        @Bean
        @ConditionalOnMissingBean
        public WjkService wjkService(){
            return new WjkService(wjkProperties);
        }
    
    }

#### 9.5 在resource下创建一个目录MATE-INF 里面创建一个文件名spring.factories ####

> org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.aaa.YkqAutoConfiguration

![95c892b4e6ca4299adc491315ddfed90.png][]

#### 9.6 打包--maven 配置了本地仓库 ####

[打包--maven 配置了本地仓库![icon-default.png?t=M85B][icon-default.png_t_M85B]https://blog.csdn.net/suo\_jia\_hao/article/details/120759708][--maven _icon-default.png_t_M85B_icon-default.png_t_M85B_https_blog.csdn.net_suo_jia_hao_article_details_120759708]

>  **打包成功后，就可以使用一个新的工程，引入自定义的starter的依赖**

>  **以上自定义starter依赖是一个简单的例子**
> 
>  **想看复杂的例子**：[SpringBoot自定义start启动器图文教程（详细）\_一个考虑转行送外卖的程序员的博客-CSDN博客][SpringBoot_start_-CSDN]

## 十、springboot整合数据源 ##

>  **数据源：指操作数据库**

#### 10.1 引入数据源得启动依赖 ####

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>

#### 10.2 指定数据源得信息 ####

# 指定数据源信息
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
    spring.datasource.username=root
    spring.datasource.password=wjk351066

#### 10.3 测试 ####

@SpringBootTest
    @MapperScan(basePackages = "com.wjk.dao")
    class Java111501ApplicationTests {
    
        /**
         * 该依赖自动装配类 帮你建好DataSource对象 交与容器管理
         */
        @Autowired
        private DataSource dataSource;
        @Test
        void contextLoads() {
            System.out.println(dataSource);
        }
    }

#### 10.4 springboot整合第三方数据源 ####

> **数据源： springboot默认整合得数据源HikariDataSource. 很多公司使用得可能是其他得数据源。比如Druid数据源 C3p0数据源。**
> 
>  **druid案例提供一个starter依赖。只需要引入该依赖。就会有相应得自动装配。**

<dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.2.1</version>
            </dependency>

#### 10.5 测试 ####

@SpringBootTest
    class Qy158Springboot01ApplicationTests {
    
        //数据源对象---自己有没有创建该类对象---因为你引入spring-boot-starter-jdbc启动依赖。
        //该依赖得自动装配类 帮你创建好DataSource对象 交于容器管理
        @Autowired
        private DataSource dataSource;
        @Test
        void contextLoads() throws SQLException {
            System.out.println(dataSource);
        }
    
    }

![9692ca296cbd4420b8b063f34303bff2.png][]

## 十一、springBoot整合Mybatis ##

#### 11.1 引依赖 ####

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

#### 11.2 修改配置文件 ####

# 指定mybatis得配置内容
    mybatis.mapper-locations=classpath:/mapper/*.xml
    # 指定mybatis
    mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#### 11.3 写一个实体类(省略) ####

#### 11.4 创建Dao接口 ####

package com.wjk.dao;
    
    import com.wjk.entity.Student;
    import org.apache.ibatis.annotations.Mapper;
    
    import java.util.List;
    public interface StudentDao {
    
        public List<Student> selectAll();
    
    
         int insert(Student student);
    
         int delete(Integer id);
    
         int update(Student student);
    }

#### 11.5 映射文件 ####

<?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.wjk.dao.StudentDao">
        <insert id="insert">
            insert into t_student values (null ,#{name},#{age},#{address})
        </insert>
    
        <update id="update">
            update t_student set name =#{name},age=#{age},address=#{address} where id=#{id}
        </update>
    
        <delete id="delete">
            delete from t_student where id=#{id}
        </delete>
    
        <select id="selectAll" resultType="com.wjk.entity.Student">
            select * from t_student
        </select>
    
    </mapper>

#### 11.6 在springboot启动类上加上--dao接口得扫描 ####

![0d9dc6e856fa4132af8313dd365f535f.png][]

#### 11.7 测试---必须为springboot得单元测试【不能使用之前junit得测试】 ####

@Resource
        private StudentDao studentDao;
        @Test
        void testSelectAll(){
            PageHelper.startPage(1,3);
            List<Student> list = studentDao.selectAll();
            System.out.println(list);
        }

## 十二、springboot整合pageHelper ##

<dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>1.4.2</version>
            </dependency>

@Resource
        private StudentDao studentDao;
        @Test
        void testSelectAll(){
            PageHelper.startPage(1,3);
            List<Student> list = studentDao.selectAll();
    
            PageInfo<Student> pageInfo = new PageInfo<>(list);
            System.out.println("总条数:"+pageInfo.getTotal());
            System.out.println("当前页的条数:"+pageInfo.getList());
        }

## 十三、springboot整合定时器 ##

> **什么是定时器? 在指定的时间间隔内执行相关的任务。**
> 
> **应用场景：**
> 
>  **比如: 未支付取消订单。**
> 
>  **定时删除OSS中冗余的文件。**
> 
>  **注册成功后，在七天发送短信问候。**

#### 13.1 引入定时器的依赖 ####

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

#### 13.2 定义定时器的业务类 ####

> **在线Cron表达式生成器的链接:[ 在线Cron表达式生成器][_Cron]**

package com.wjk.quartz;
    
    
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    @Component //交与容器管理
    public class MyQuartz {
    
        /**
         * 业务代码 Scheduled规定什么时候执行业务代码
         */
        @Scheduled(cron = "0/5 * * * * ? ")
        public void test(){
            System.out.println("********************");
        }
    }

#### 13.3 开启定时器的注解 ####

## ![bce6b806300a40f9af891c1d7c047f6d.png][] ##

## 十四、 springboot整合swagger2 ##

> **什么是swagger2? 使用Swagger开源和专业工具集简化用户、团队和企业的API开发。了解Swagger如何帮助您大规模设计和记录API文档**
> 
> **为什么使用API文档?**

![4eb3069d1ff54e29b0389924793cffe7.png][]

#### 14.1 我们如何使用swagger2?  springboot的版本不能那么高。2.2~2.5之间  ####

<dependency>
                <groupId>com.spring4all</groupId>
                <artifactId>swagger-spring-boot-starter</artifactId>
                <version>1.9.1.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>com.github.xiaoymin</groupId>
                <artifactId>swagger-bootstrap-ui</artifactId>
                <version>1.9.6</version>
            </dependency>

#### 14.2 创建一个swagger配置类---所有的功能都集成在Docket类 ####

@Configuration  //标记为配置类
    public class SwaggerConfig {
    
        @Bean
        public Docket docket(){
            Docket docket = new Docket(DocumentationType.SWAGGER_2)
    
            return docket;
        }
    }

#### 14.3 开启swagger2注解 ####

package com.wjk;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import springfox.documentation.swagger2.annotations.EnableSwagger2;
    
    @SpringBootApplication
    @EnableScheduling //开启定时器注解
    @EnableSwagger2 //开启swagger2的注解
    public class SpringBoot1118Application {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringBoot1118Application.class, args);
        }
    
    }

#### 14.4 定义相关的接口 ####

@RestController
    public class HelloController {
    
    
        @GetMapping("hello01")
        public String hello01(){
            return "hello01";
        }
    }

#### 14.5 查看swagger2的界面 ####

![e6c1e71dd2fc4fb0b9b8dc9be9cf1865.png][]

#### 14.6 最终的配置类完整格式 ####

/**
     * Created by Intellij IDEA
     *
     * @author 王俊凯
     * @Date: 2022/11/18 10:06
     * @Version 1.0
     */
    package com.wjk.config;
    
    import com.google.common.base.Predicates;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import springfox.documentation.builders.PathSelectors;
    import springfox.documentation.builders.RequestHandlerSelectors;
    import springfox.documentation.service.ApiInfo;
    import springfox.documentation.service.Contact;
    import springfox.documentation.service.VendorExtension;
    import springfox.documentation.spi.DocumentationType;
    import springfox.documentation.spring.web.plugins.Docket;
    
    import java.util.ArrayList;
    
    @Configuration  //标记为配置类
    public class SwaggerConfig {
    
        @Bean
        public Docket docket(){
            Docket docket = new Docket(DocumentationType.SWAGGER_2)
                    //组名
                    .groupName("wjk")
                    //api信息
                    .apiInfo(getInfo())
                    //选择哪些生成api接口--根据请求路径选择 （2）根据包名选择
                    .select()
                    //根据请求路径选择
                    .paths(Predicates.and(PathSelectors.regex("/api/.*")))
                    //根据报名选择
                    .apis(RequestHandlerSelectors.basePackage("com.wjk.controller"))
                    .build()
                    ;
            return docket;
        }
    
    
        private ApiInfo getInfo(){
            Contact DEFAULT_CONTACT = new Contact("王俊凯", "http://www.jd.com", "1315272325@qq.com");
            ApiInfo info = new ApiInfo("在线预约挂号系统", "在线挂号系统", "9.9", "http://www.baidu.com",
                    DEFAULT_CONTACT, "上海富有银行有限公司", "http://www.taobao.com", new ArrayList<VendorExtension>());
            return info;
        }
    }

>  **我们还有另外一个网址 更简洁更容易看懂** [http://localhost:port/doc.html][http_localhost_port_doc.html]

![eea1e3289e0f4bedb13be8464a7967d7.png][]

> **介绍: swagger常用的注解**
> 
>  *  **@Api：修饰整个类，描述Controller的作用**
>  *  **@ApiOperation：描述一个类的一个方法，或者说一个接口**
>  *  **@ApiImplicitParam：一个请求参数**
>  *  **@ApiImplicitParams：多个请求参数**
>  *  **@ApiModel：用对象来接收参数**
>  *  **@ApiModelProperty：用对象接收参数时，描述对象的一个字段**

## 十五、thymeleaf模板引擎 ##

>  **就是一个网页模板【jsp 现在不能使用jsp的原因:springboot中内置的tomcat 不支持jsp模板引擎】。**

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

@RestController
    public class PageController {
    
        @RequestMapping("/index")
        public String index(){
            return "index";
        }
    }

![fecaaa70df26444c88d05e2a90b5ca96.png][]

> [Thymeleaf\_洋葱爱代码的博客-CSDN博客\_thymeleaf][Thymeleaf_-CSDN_thymeleaf] **具体使用请看文档  懒得写了**

[Link 1]: https://baike.baidu.com/item/%E6%A1%86%E6%9E%B6/1212667?fromModule=lemma_inlink
[Link 2]: https://baike.baidu.com/item/%E7%AE%80%E5%8C%96/3374416?fromModule=lemma_inlink
[Spring]: https://baike.baidu.com/item/Spring/85061?fromModule=lemma_inlink
[Maven]: https://baike.baidu.com/item/Maven/6094909?fromModule=lemma_inlink
[520049b96ef14482b5133fe46e374369.png]: https://img-blog.csdnimg.cn/520049b96ef14482b5133fe46e374369.png
[5ad4a6de44d84089b8f9223c5d3483b8.png]: https://img-blog.csdnimg.cn/5ad4a6de44d84089b8f9223c5d3483b8.png
[22fd1f70510049b38c7e16af2912d2ad.png]: https://img-blog.csdnimg.cn/22fd1f70510049b38c7e16af2912d2ad.png
[a2a6c666ee984f6f850cb5822c2c1f5b.png]: https://img-blog.csdnimg.cn/a2a6c666ee984f6f850cb5822c2c1f5b.png
[c7034400baca41ae9a8f2154b76321e2.png]: https://img-blog.csdnimg.cn/c7034400baca41ae9a8f2154b76321e2.png
[56133a9b9e2441aa8ae64e7b55a1b835.png]: https://img-blog.csdnimg.cn/56133a9b9e2441aa8ae64e7b55a1b835.png
[504dcc0214624d0aac3f34934f9b2422.png]: https://img-blog.csdnimg.cn/504dcc0214624d0aac3f34934f9b2422.png
[499c3c711f924ceabae1e0b1f6b68048.png]: https://img-blog.csdnimg.cn/499c3c711f924ceabae1e0b1f6b68048.png
[28f006fe20344bf3a5d9016930b4362b.png]: https://img-blog.csdnimg.cn/28f006fe20344bf3a5d9016930b4362b.png
[96c273e750ce4f888d5efc5844f8b366.png]: https://img-blog.csdnimg.cn/96c273e750ce4f888d5efc5844f8b366.png
[2c8e0be9c2774319984a6f023e2c3aec.png]: https://img-blog.csdnimg.cn/2c8e0be9c2774319984a6f023e2c3aec.png
[9fa67418d0c2448f8a7c23147bfd4241.png]: https://img-blog.csdnimg.cn/9fa67418d0c2448f8a7c23147bfd4241.png
[ce27fc6251c34747b646a313312d11ee.png]: https://img-blog.csdnimg.cn/ce27fc6251c34747b646a313312d11ee.png
[e035c2a9043c405b90cb6571ab689a65.png]: https://img-blog.csdnimg.cn/e035c2a9043c405b90cb6571ab689a65.png
[54994a5d77b14c468c3405f2a0851193.png]: https://img-blog.csdnimg.cn/54994a5d77b14c468c3405f2a0851193.png
[046f776387944e7da288b8f8b177c4f2.png]: https://img-blog.csdnimg.cn/046f776387944e7da288b8f8b177c4f2.png
[742d7d6ac0f24518b67995f53a2ad27e.png]: https://img-blog.csdnimg.cn/742d7d6ac0f24518b67995f53a2ad27e.png
[0be4f9a4fdd848b8bd016e6094910358.png]: https://img-blog.csdnimg.cn/0be4f9a4fdd848b8bd016e6094910358.png
[f9b7fa7daee9410e97680372bb845fa3.png]: https://img-blog.csdnimg.cn/f9b7fa7daee9410e97680372bb845fa3.png
[e7b01d5356d242cb9c410a21bb0ff58e.png]: https://img-blog.csdnimg.cn/e7b01d5356d242cb9c410a21bb0ff58e.png
[95c892b4e6ca4299adc491315ddfed90.png]: https://img-blog.csdnimg.cn/95c892b4e6ca4299adc491315ddfed90.png
[icon-default.png_t_M85B]: https://csdnimg.cn/release/blog_editor_html/release2.2.0/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=M85B
[--maven _icon-default.png_t_M85B_icon-default.png_t_M85B_https_blog.csdn.net_suo_jia_hao_article_details_120759708]: https://blog.csdn.net/suo_jia_hao/article/details/120759708
[SpringBoot_start_-CSDN]: https://blog.csdn.net/sdaawafg/article/details/120427882
[9692ca296cbd4420b8b063f34303bff2.png]: https://img-blog.csdnimg.cn/9692ca296cbd4420b8b063f34303bff2.png
[0d9dc6e856fa4132af8313dd365f535f.png]: https://img-blog.csdnimg.cn/0d9dc6e856fa4132af8313dd365f535f.png
[_Cron]: https://cron.qqe2.com/
[bce6b806300a40f9af891c1d7c047f6d.png]: https://img-blog.csdnimg.cn/bce6b806300a40f9af891c1d7c047f6d.png
[4eb3069d1ff54e29b0389924793cffe7.png]: https://img-blog.csdnimg.cn/4eb3069d1ff54e29b0389924793cffe7.png
[e6c1e71dd2fc4fb0b9b8dc9be9cf1865.png]: https://img-blog.csdnimg.cn/e6c1e71dd2fc4fb0b9b8dc9be9cf1865.png
[http_localhost_port_doc.html]: http://localhost/doc.html
[eea1e3289e0f4bedb13be8464a7967d7.png]: https://img-blog.csdnimg.cn/eea1e3289e0f4bedb13be8464a7967d7.png
[fecaaa70df26444c88d05e2a90b5ca96.png]: https://img-blog.csdnimg.cn/fecaaa70df26444c88d05e2a90b5ca96.png
[Thymeleaf_-CSDN_thymeleaf]: https://blog.csdn.net/qq_48788523/article/details/123942193