SpringBoot笔记之入门教程

电玩女神 2022-05-15 04:19 149阅读 0赞

# SpringBoot入门 #

## 一、SpringBoot简介 ##

### 1.SpringBoot是什么？ ###

产生背景：Spring开发变的越来越笨重，大量的XML文件，繁琐的配置，复杂的部署流程，整合第三方框架难度大等，导致开发效率低下

SpringBoot是一个用来简化Spring应用的初始创建和开发过程的框架，简化配置，实现快速开发

整合了整个Spring技术栈，JavaEE开发的一站式解决方案

### 2. 为什么使用SpringBoot？ ###

优点：

*  快速创建独立运行的Spring项目并与主流框架集成
 *  内置Servlet容器，应用无需打成war包
 *  使用starter(启动器)管理依赖并进行版本控制
 *  大量的自动配置，简化开发
 *  提供准生产环境的运行时监控，如指标、健康检查、外部配置等
 *  无需配置XML，没有冗余代码生成，开箱即用

## 二、第一个SpringBoot程序 ##

### 1. 简介 ###

环境：

*  SpringBoot 2.0（基于Spring 5.0）
 *  JDK1.8及以上
 *  Maven 3.2及以上
 *  Tomcat 8.5及以上
 *  IDEA较新版本

### 2. 操作步骤 ###

步骤：

1.  创建一个maven的java工程
    
    传统的web应用需要创建web工程，后期要打包war包，然后放到tomcat中，太麻烦
    
    而SpringBoot应用只需要创建一个java工程，后期直接打包可执行的jar包，其内置tomcat
2.  导入SpringBoot的相关依赖
    
        
           <parent>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-parent</artifactId>
               <version>2.0.3.RELEASE</version>
           </parent>
        
           
           <dependencies>
               <dependency>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-starter-web</artifactId>
               </dependency>
           </dependencies>
3.  编写Service、Controller等
    
        @Controller
        public class HelloController { 
        
           @RequestMapping("/hello")
           @ResponseBody
           public String hello() {
               return "Hello World";
           }
        }
4.  编写主程序类，用来启动Spring应用
    
        /** * Author：xx * Date：2018-07-09 10:28 * Description：使用@SpringBootApplication标注主程序类，表示这是一个SpringBoot应用 */
        @ComponentScan("com.itany.controller")
        @SpringBootApplication
        public class MainApplication { 
           public static void main(String[] args) {
               // 启用SpringBoot应用
               SpringApplication.run(MainApplication.class, args); //传入主程序类的Class对象
           }
        }
    
    **注：默认只扫描主程序类所在的包及其子包**
5.  部署打包
    
    添加插件，将应用打包成可执行的jar，执行`java -jar springboot01-helloworld-1.0-SNAPSHOT.jar`
    
        
        <build>
         <plugins>
           <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
         </plugins>
        </build>

### 3. 分析Hello World ###

#### 3.1 POM文件 ####

*  父工程spring-boot-starter-parent
    
        <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
        </parent>
    
    父工程的父工程是spring-boot-dependencies，用来管理SpringBoot应用中的依赖的版本，进行版本控制
    
        <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-dependencies</artifactId>
         <version>2.0.3.RELEASE</version>
         <relativePath>../../spring-boot-dependencies</relativePath>
        </parent>
 *  通过**starter**指定依赖
    
        <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        </dependencies>
    
    SpringBoot提供了许多starter（启动器），分别对应不同的功能场景，当在项目中引入这些starter时相应场景的依赖就会被导入进来

#### 3.2 主程序类 ####

*  @SpringBootApplication
    
    标注在类上，表示这个是SpringBoot的主配置类，通过运行该类的main方法来启动SpringBoot应用
    
        @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}
        )}
        )
        public @interface SpringBootApplication {
 *  @SpringBootConfiguration
    
    标注在类上，表示这个类是SpringBoot的配置类
    
    层级关系：@SpringBootConfiguration——>@Configuration——>@Component
    
    @Configuration标注在类上，表示这个类是Spring的配置类，相当于是一个xml配置文件
 *  @EnableAutoConfiguration
    
    开启**自动配置**功能，SpringBoot会自动完成许多配置，简化了以前繁琐的配置
    
    SpringBoot在启动时会类路径下/META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类添加到容器中，这些**自动配置类**会帮我们完成许多配置工作。
 *  @ComponentScan
    
    标注在类上，指定要扫描的包

## 三、快速创建SpringBoot项目 ##

### 1. 简介 ###

使用Spring Initinalizer快速创建SpringBoot项目

### 2. 基本操作 ###

*  POM文件和主程序类已经生成好了，直接写业务逻辑即可
 *  resources文件夹的目录结果
    
        |-static   存放静态资源，如css、js、image等
        |-templates  存储模板页面，可以使用模板引擎，如freemarker、thymeleaf等
        |-application.properties SpringBoot应用的配置文件,可以修改一些默认设置

## 四、配置文件 ##

### 1. 简介 ###

SpringBoot的默认全局配置文件有两种：

*  application.properties
 *  application.yml

文件名固定，存放在classpath:/ 或 classpath:/config/ 目录下

可以通过配置文件修改SpringBoot的默认配置

配置项可参考：[https://docs.spring.io/spring-boot/docs/2.0.3.RELEASE/reference/htmlsingle/\#common-application-properties][https_docs.spring.io_spring-boot_docs_2.0.3.RELEASE_reference_htmlsingle_common-application-properties]

注：在SpringBoot2.0中，部分配置项与SpringBoot1.0中有所不同，有的被重命名或被删除

### 2. YAML用法 ###

#### 2.1 简介 ####

YAML是”YAML Ain’t a Markup Language”的缩写，表示YAML不是一种标记语言

YAML是专门用来写配置文件的语言，以数据为中心，简洁和强大，比xml、properties等更合适做配置文件

YAML文件的后缀名为.yml或.yaml

#### 2.2 语法规则 ####

*  大小写敏感
 *  使用缩进表示层级关系
 *  缩进时不允许使用Tab键，只能使用空格
 *  缩进的空格数目不重要，只要相同层级的元素左侧要对齐
 *  `#`表示注释

server:
      port: 8881  #　写法key:value，冒号后面必须有空格
      servlet:
        context-path: /springboot03

#### 2.3 基本用法 ####

YAML支持的数据结构有三种：

*  字面量：单个的，不可再分的值
 *  对象：键值对的集合
 *  数组：一组按次序排列的值

三种数据结构的用法：

1.  字面量：普通的值，如数字、字符串、布尔值
    
        number: 12.5
        str: hello
        name: 'tom cruise' # 如果字符串包含空格或特殊字符，则必须使用引号引起来，单引号或双引号都可以
        name: 'tom \n cruise' # 不对对特殊字符进行转义，结果：tom 换行 cruise
        name: "tom \n cruise" # 对特殊字符进行转义，会作为普通字符输出，结果为:tom \n cruise
2.  对象：也称为映射Map，包含属性和值
    
        # 写法1：换行写
        
        user:
         name: tom
         age: 20
         sex: male
        
        # 写法2：行内写法
        
        user: {name: tom,age: 20,sex: male}
3.  数组，如List、Set等
    
        #　写法１：一组短横线开头的行
        
        names:
         - tom  - jack  - alice 
        # 写法2：行内写法
        
        name: [tom,jack,alice]

### 3. 为属性注入值 ###

通过加载配置文件，为类中的属性注入值

#### 3.1 使用.yml配置文件 ####

application.yml文件

user:
      username: admin
      age: 18
      status: true
      birthday: 2018/2/14
      address:
        province: 江苏省
        city: 南京市
      lists:
        - list1     - list2     - list3   maps: {k1: v1,k2: v2}

User类

// 必须将当前类添加到容器中
    @Component
    // 默认读取全局配置文件获取值，将当前类中的所有属性与配置文件中的user进行绑定
    @ConfigurationProperties(prefix = "user")
    public class User { 
    
        private String username;
        private Integer age;
        private Boolean status;
        private Date birthday;
        private Address address;
        private List<String> lists;
        private Map<String,Object> maps;

可以添加配置文件处理器的依赖（**可选**）

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-configuration-processor</artifactId>
      <optional>true</optional>
    </dependency>

#### 3.2 使用properties配置文件 ####

application.properties文件

user.username=alice
    user.age=22
    user.status=false
    user.birthday=2018/7/2
    user.address.province=广东省
    user.address.city=东莞市
    user.lists=list1,list2,list3
    user.maps.k1=v1
    user.maps.k2=v2

注：在IDEA中properties文件默认使用utf8/gbk编码，会出现中文乱码

#### 3.3 使用@Value为属性注入值 ####

// 必须将当前类添加到容器中
    @Component
    // 默认读取全局配置文件获取值，将当前类中的所有属性与配置文件中的user进行绑定
    // @ConfigurationProperties(prefix = "user")
    public class User { 
    
        @Value("${user.username}")
        private String username;
        @Value("${user.age}")
        private Integer age;
        @Value("${user.status}")
        private Boolean status;
        @Value("${user.birthday}")
        private Date birthday;
        //@Value不支持复杂类型封装
        private Address address;
        @Value("${user.lists}")
        private List<String> lists;
        private Map<String,Object> maps;

@Value和@ConfigurationProperties的比较：

*  @Value只能一个个为属性注入值，而@ConfigurationProperties可以批量为属性注入值
 *  @Value不支持为复杂类型封装，而@ConfigurationProperties支持

### 4. 多环境配置 ###

可以为不同环境提供不同的配置信息，如开发环境、测试环境、生产环境等

两种方式：

*  创建多个properties文件
 *  定义yml文档块

#### 4.1 创建多个properties文件 ####

步骤：

1.  创建不同环境的properties文件
    
    文件命名必须符合application-xxx.properties格式
    
    application-dev.properties
    
    application-test.properties
    
    application-prod.properties
2.  在application.properties文件中指定要激活的配置
    
        # 指定要激活的配置
        
        spring.profiles.active=prod

#### 4.2 定义yml文档块 ####

在yml文件中使用三个短横线定义多个文档块

步骤：

1.  在yml文件中定义多个文档块，表示不同的环境配置
    
    “\`yaml
    
    --------------------
    
    spring:  
    profiles: dev  
    server:  
    port: 9991

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

spring:  
profiles: test  
server:  
port: 9992  
“\`

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

spring:  
profiles: prod  
server:  
port: 9993

“\`

1.  在第一个文档块中指定要激活的配置
    
        spring:
         profiles:
           active: test

### 5. 加载外部配置文件 ###

#### 5.1 加载properties属性文件 ####

问题：@ConfigurationProperties默认是从全局配置文件中获取值，如果想从外部的自定义属性文件中获取值怎么办？

解决：使用@PropertySource加载外部的属性文件

// 必须将当前类添加到容器中
    @Component
    // 加载外部的属性文件
    @PropertySource({
       "classpath:user.properties"})
    // 默认读取全局配置文件获取值，将当前类中的所有属性与配置文件中的user进行绑定
    @ConfigurationProperties(prefix = "user")
    public class User {

#### 5.2 加载spring配置文件 ####

问题：如果确实需要将配置写在Spring的xml配置文件中，想加载xml文件怎么办？

解决：使用@ImportResource加载外部的Spring配置文件

// 加载外部的Spring配置文件
    @ImportResource({
       "classpath:spring.xml"})
    @SpringBootApplication
    public class Springboot03ConfigApplication {

#### 5.3 使用注解方式添加组件 ####

推荐使用全注解方式向容器中添加组件，@Configuration和@Bean

// 标注在类上，表示这是一个配置类，相当于以前编写的Spring配置文件
    @Configuration
    public class SpringConfig { 
    
        // 标注在方法上，向容器中添加一个组件，将方法的返回值添加到容器中，方法名作为组件id
        @Bean
        public Address address(){
            Address address = new Address();
            address.setProvince("山东");
            address.setCity("日照");
            return address;
        }
    }

## 五、自动配置的原理 ##

### 1. 执行流程 ###

1.  SpringBoot启动时加载主配置类，开启了自动配置功能@EnableAutoConfiguration
2.  @EnableAutoConfiguration作用
    
    利用@Import(\{AutoConfigurationImportSelector.class\})向容器中添加一些组件（自动配置类）
    
    查看AutoConfigurationImportSelector中的selectImports()方法
    
    查看List configurations = this.**getCandidateConfigurations**(annotationMetadata, attributes);获取候选的配置
    
    查看SpringFactoriesLoader.loadFactoryNames方法
    
    查看loadSpringFactories()方法
    
    查看classLoader.getResources(“META-INF/spring.factories”)
    
    扫描所有Jar包类路径下的加载META-INF/spring.factories文件，获取EnableAutoConfiguration对应的值（在spring-boot-autoconfigure-2.0.3.RELEASE.jar中）
    
    将这些**自动配置类（xxxAutoConfiguration）**添加到容器中
3.  通过这些自动配置类来完成相应的自动配置功能

### 2. 原理分析 ###

以HttpEncodingAutoConfiguration为例，就是以前我们在web.xml文件中配置的CharacterEncodingFilter过滤器

// 表示这是一个配置类，相当于以前我们编写的spring配置文件
    @Configuration
    // 启用HttpEncodingProperties类的ConfigurationProperties功能，通过配置文件为属性注入值，并将其添加到容器中
    @EnableConfigurationProperties({HttpEncodingProperties.class})
    // 如果当前应用是Web应用，则该配置类生效，否则不生效
    @ConditionalOnWebApplication(
        type = Type.SERVLET
    )
    // 如果当前应用有CharacterEncodingFilter类，则该配置类生效，否则不生效
    @ConditionalOnClass({CharacterEncodingFilter.class})
    // 如果配置文件中有spring.http.encoding.endabled选项，则该配置生效，否则不生效，默认已经设置为true，所以默认生产
    @ConditionalOnProperty(
        prefix = "spring.http.encoding",
        value = {
       "enabled"},
        matchIfMissing = true
    )
    public class HttpEncodingAutoConfiguration { 
        private final HttpEncodingProperties properties;
    
        // 将容器中的HttpEncodingProperties注入
        public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
            this.properties = properties;
        }
    
        // 将返回的CharacterEncodingFilter对象添加到容器中，作为一个bean
        @Bean
        // 如果容器中没有这个组件，则添加
        @ConditionalOnMissingBean
        public CharacterEncodingFilter characterEncodingFilter() {
            CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
            filter.setEncoding(this.properties.getCharset().name());
            filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.REQUEST));
            filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.RESPONSE));
            return filter;
        }

// 从配置文件中获取指定的属性值，然后绑定到当前类中的属性
    @ConfigurationProperties(
        prefix = "spring.http.encoding"
    )
    public class HttpEncodingProperties { 
        public static final Charset DEFAULT_CHARSET;
        private Charset charset;
        private Boolean force;
        private Boolean forceRequest;
        private Boolean forceResponse;
        private Map<Locale, Charset> mapping;

注意：

*  根据当前不同的条件判断，决定自动配置类是否生产，即并不是所有的自动配置类都会生效
 *  自动配置类xxxAutoConfiguration的属性是从对应的xxxProperties类中获取的
 *  xxxProperties类中的所有属性是通过配置文件注入绑定的，我们可以通过配置文件指定这些属性的值

### 3. 总结 ###

*  SpringBoot启动时会加载大量的自动配置类
 *  通过这些自动配置类来向添加中添加组件
 *  通过这些组件来自动完成许多功能，简化配置

## 六、Web开发 ##

### 1. 简介 ###

使用SpringBoot开发Web应用的步骤：

1.  创建SpringBoot应用，选择需要的starter
2.  在配置文件中指定必要的少量配置
3.  编写业务代码

Web开发的自动配置类：WebMvcAutoConfiguration

### 2. 静态资源的映射 ###

#### 2.1 静态资源位置 ####

查看WebMvcAutoConfiguration——>addResourceHandlers()——>getStaticLocations()——>staticLocations

静态资源的默认位置：

*  “classpath:/META-INF/resources/”,
 *  “classpath:/resources/”
 *  “classpath:/static/”
 *  “classpath:/public/”
 *  “classpath:/” 在SpringBoot2.0中已经被删除，在SpringBoot1.0中有效

当访问静态资源时会到所有静态资源文件夹中查找

可以修改静态资源的位置：

# 指定静态资源的位置
    spring.resources.static-locations=classpath:/static,classpath:/public

#### 2.2 欢迎页 ####

查看WebMvcAutoConfiguration——>welcomePageHandlerMapping()——>getWelcomePage()

将index.html页面放到任意一个静态资源文件夹中即可

#### 2.3 图标 ####

查看WebMvcAutoConfiguration——>内部类FaviconConfiguration——>faviconHandlerMapping

将favicon.ico放到任意一个静态资源文件夹中即可

## 七、模板引擎 ##

### 1. 简介 ###

目前Java Web开发推荐使用模板引擎，不建议使用JSP页面

*  JSP缺点：本质上就是Servlet，需要后台编译，耗时，效率低
 *  模板引擎：不需要编译，速度快

常用的模板引擎：Freemarker、Velocity、Thymeleaf等

SpringBoot推荐使用Thymeleaf，且默认不支持JSP页面，因为JSP必须要打成war包

**补充：目前主流的Web开发更推荐采用前后端分离，前端使用MVVM框架：Vue.js、Angular、React等**

### 2. Thymeleaf的使用 ###

步骤：

1.  添加thymeleaf的依赖
    
        
        <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
2.  将HTML页面放到templates目录中
    
    templates目录下的HTML页面默认不能直接访问，需要通过controller来访问，由thymeleaf渲染
    
    查看：ThymeleafAutoConfiguration——>ThymeleafProperties——>DEFAULT\_PREFIX/DEFAULT\_SUFFIX
3.  使用thymeleaf
    
    参考手册：usingthymeleaf.pdf
    
        <!DOCTYPE html>
        
        <html lang="en" xmlns:th="http://www.thymeleaf.org">
        <head>
           <meta charset="UTF-8">
           <title>Title</title>
        </head>
        <body>
           <h2>success</h2>
           
           <div th:text="${name}"></div>
        </body>
        </html>
4.  修改页面后，让其实时生效
    
    由于thymeleaf默认启用了缓存
    
        # 禁用thymeleaf的缓存
        
        spring.thymeleaf.cache=false
    
    
    
    **补充：还需要开启IDEA的自动编译，IDEA默认保存时不会自动编译**
    
    Setting——>搜索Compiler——>勾选Build Project automatically
    
    Fild——>Find Action——>搜索Registry——>勾选Compiler.automake……

### 3. 语法规则 ###

#### 3.1 常用属性 ####

参考手册：`10 Attribute Precedence`

*  th:text、th:utext
    
    设置元素中的文本内容
    
    th:text 对特殊字符进行转义，等价于内联方式\[\[$\{\}\]\]
    
    th:utext 对特殊字符不进行转义，等价于内联方式\[($\{\})\]
 *  th:html原生属性
    
    用来替换指定的原生属性的值
 *  th:if、th:unless、th:switch、th:case
    
    条件判断，类似于c:if
 *  th:each
    
    循环，类似于c:forEach
 *  th:object、th:with
    
    定义变量，类似c:set
    
    需要和\*\{\}表达式配合使用

#### 3.2 表达式 ####

参考手册：`4 Standard Expression Syntax`

*  $\{\}
    
    获取对象的属性
    
    获取对象的方法
    
    调用内置的基本对象，如session、application等
    
    调用内置的工具对象，如\#strings、\#dates、\#arrays、\#lists等
 *  \*\{\}
    
    需要和th:object配合使用，简化获取对象的属性
 *  @\{\}
    
    定义url
 *  运算符

### 4. 热部署 ###

使用SpringBoot提供devtools实现热部署

原理：实时监控classpath下文件的变化，如果发生变化则自动重启

配置：添加devltools依赖

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      
      <optional>true</optional>
    </dependency>

## 八、扩展默认的SpringMVC功能 ##

### 1. 简介 ###

以前在SpringMVC中通过如下代码实现一些功能，如视图跳转、拦截器等

<mvc:view-controller path="/showLogin" view-name="login"/>
    <mvc:interceptors>
      <mvc:interceptor>
        <mvc:mapping path="/hello"/>
        <bean class="com.itany.interceptor.MyInterceptor"/>
      </mvc:interceptor>  
    </mvc:interceptors>

SpringBoot自动配置默认并没有提供以上功能配置，需要自己扩展，使用WebMvcConfigurer接口

### 2. 基本操作 ###

步骤：

1.  定义一个配置类（@Configuration），实现WebMvcConfigurer接口
2.  根据需要实现相应的方法
    
        /** * Author：汤小洋 * Date：2018-07-11 10:51 * Description：扩展默认的SpringMVC功能 * 要求： * 1.使用@Configuration标注为配置类 * 2.实现WebMvcConfigurer接口 * 3.根据需要实现相应的方法 * * 注：这个接口中的方法都加了jdk1.8中的default方法修饰，不强制实现所有方法（jdk1.8新特性） * 在SpringBoot1.0版本中是继承WebMvcConfigurerAdapter类，在SpringBoot2.0中该类已过时 */
        @Configuration
        public class CustomMvcConfig implements WebMvcConfigurer { 
        
           // 添加ViewController
           @Override
           public void addViewControllers(ViewControllerRegistry registry) {
               //访问/showLogin时跳转到login视图
               registry.addViewController("/showLogin").setViewName("login");
           }
        
           // 添加Interceptor
           @Override
           public void addInterceptors(InterceptorRegistry registry) {
               registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**").excludePathPatterns("/showLogin","/test1");
           }
        }

## 九、全局异常处理 ##

### 1. 简介 ###

当程序出现异常时要进行全局处理

两种方式：

*  定义错误码页面
 *  定义异常通知

### 2. 定义错误码页面 ###

创建`错误状态码.html`页面，放在templates/error目录中，当发生错误时会自动到该目录下查找对应的错误页面

可以创建如`4xx.html`或`5xx.html`页面，用来匹配所有该类型的错误

可以在错误页面获取异常相关信息：

<h3>状态码：[[${status}]]</h3>
    <h3>错误提示：[[${error}]]</h3>
    <h3>异常消息：[[${message}]]</h3>
    <h3>时间戳：[[${timestamp}]]</h3>
    <h3>异常对象：[[${exception}]]</h3>

### 3. 定义异常通知 ###

/** * Author：汤小洋 * Date：2018-07-11 11:18 * Description：异常通知，处理全局异常 */
    @ControllerAdvice
    public class ExceptionAdvice { 
    
        @ExceptionHandler(ArithmeticException.class)
        public String arithmetic(Exception e){
            System.out.println("警报，程序出现异常啦，发短信："+e.getMessage());
            return "error/arithmetic";
        }
    
        @ExceptionHandler(Exception.class)
        public String excetion(Exception e){
            System.out.println("警报，程序出现异常啦，发短信："+e.getMessage());
            return "error/error";
        }
    
    }

## 十、关于Servlet容器 ##

### 1. 简介 ###

SpringBoot默认内置了Servlet容器：Tomcat

问题：SpringBoot默认是以jar包的方式启动内置的Servlet容器，没有web.xml文件，如何注册Servlet、Filter、Listener?

解决：通过自定义Servlet配置，使用ServletRegistrationBean、FilterRegistrationBean、ServletListenerRegistrationBean

### 2. 注册Servlet组件 ###

步骤：

1.  定义一个配置类（@Configuration）
2.  自定义方法，用来注册bean
    
        /** * Author：xx * Date：2018-07-11 11:50 * Description：自定义Servlet配置，注册Servlet三大组件:Servlet、Filter、Listener */
        @Configuration
        public class CustomServletConfig { 
        
           // 注册Servlet
           @Bean
           public ServletRegistrationBean myServlet() {
               ServletRegistrationBean<MyServlet> bean = new ServletRegistrationBean<>();
               bean.setServlet(new MyServlet());
               bean.addUrlMappings("/myServlet");
               return bean;
           }
        
           // 注册Filter
           @Bean
           public FilterRegistrationBean myFilter() {
               FilterRegistrationBean<MyFilter> bean = new FilterRegistrationBean<>();
               bean.setFilter(new MyFilter());
               bean.setUrlPatterns(Arrays.asList("/showLogin", "/test1"));
               return bean;
           }
        
           // 注册Listener
           @Bean
           public ServletListenerRegistrationBean myListener() {
               return new ServletListenerRegistrationBean<>(new MyListener());
           }
        
        }

### 3. 使用外部的Servlet容器 ###

#### 3.1 优缺点 ####

使用内置Servlet容器：将应用打成可执行的jar包，直接运行

优点：简单、方便

缺点：不支持JSP、可定制性差

使用外部Servlet容器：将应用打成war包，然后部署到外部的Tomcat

优点：支持JSP、可定制性强

#### 3.2 操作步骤 ####

步骤：

1.  创建一个war工程
    
    有如下三个变化：
    
     *  打包方式为war
        
            <packaging>war</packaging>
     *  将内置Tomcat的scope配置为provided
        
            <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
            </dependency>
     *  定义了一个SpringBootServletInitinalizer的子类
        
            /** * 要求： * 1.必须继承SpringBootServletInitializer类 * 2.重写configure方法 * 3.调用SpringApplicationBuilder的sources()方法，传入SpringBoot应用的主程序类 */
            public class ServletInitializer extends SpringBootServletInitializer { 
            
             @Override
             protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
                 //传入SpringBoot应用的主程序类
                 return application.sources(Springboot05WarApplication.class);
             }
            
            }
2.  创建web目录结构
3.  配置前缀和后缀
    
        spring.mvc.view.prefix=/WEB-INF/views/
        spring.mvc.view.suffix=.jsp
4.  配置Tomcat并启动
    
    需要使用Tomcat 8.5及以上版本

## 十五、SpringBoot数据访问 ##

### 1. JDBC ###

步骤：

1.  创建一个工程，勾选 Web、MySQL、JDBC
2.  配置数据库连接信息
    
        spring.datasource.driver-class-name=com.mysql.jdbc.Driver
        spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8
        spring.datasource.username=root
        spring.datasource.password=
        
        spring.datasource.type=org.apache.commons.dbcp.BasicDataSource
3.  配置连接池参数
    
        # 指定连接池信息
        
        spring.datasource.initialSize=10
        spring.datasource.maxActive=100
        spring.datasource.minIdle=5
        spring.datasource.maxIdle=20
        spring.datasource.maxWait=50000
    
    问题：添加上面的连接池参数后并不会生效，因为SpringBoot默认并不支持 这些参数，即DataSourceProperties类中没有这些属性
    
    解决：自定义数据源配置
    
        @Configuration
        public class DataSourceConfig { 
           @Bean
           // 从配置文件中读取spring.datasource属性，并注入给数据源的属性
           @ConfigurationProperties(prefix = "spring.datasource")
           public DataSource dataSource(){
               DruidDataSource dataSource = new DruidDataSource(); // 自己创建数据源对象
               return dataSource;
           }
        }
4.  使用JdbcTemplate操作数据库
    
        @RestController
        public class UserController { 
        
           @Autowired
           private JdbcTemplate jdbcTemplate;
        
           @RequestMapping("/findAll")
           public List<Map<String, Object>> findAll() {
               List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from t_user");
               return list;
           }
        
        }

### 2. MyBatis ###

#### 2.1 基本用法 ####

步骤：

1.  创建一个工程，勾选：Web、MySQL、MyBatis
2.  配置applilcation.yml
    
        # 配置DataSource:
        
        spring:
         datasource:
           driver-class-name: com.mysql.jdbc.Driver
           url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8
           username: root
           password:
           initialSize: 10
           maxActive: 100
           minIdle: 5
           maxIdle: 20
           maxWait: 50000
        
        
        # 配置MyBatis
        
        mybatis:
         type-aliases-package: com.itany.pojo
         mapper-locations: classpath:mapper/*.xml
3.  编写Mapper、Service、Controller等
4.  配置MyBatisConfig
    
        @Configuration
        // 扫描MyBatis的Mapper接口所在的包
        @MapperScan("com.itany.mapper")
        public class MyBatisConfig { 
        
           @Bean
           @ConfigurationProperties(prefix = "spring.datasource")
           public DataSource dataSource(){
               return new DruidDataSource();
           }
        
        }

#### 2.2 配置PageHelper分页插件 ####

步骤：

1.  添加pagehelper的依赖
    
        <dependency>
         <groupId>com.github.pagehelper</groupId>
         <artifactId>pagehelper-spring-boot-starter</artifactId>
         <version>1.2.5</version>
        </dependency>
2.  配置PageHelper属性
    
        # 配置PageHelper
        
        pagehelper:
         helper-dialect: mysql
3.  使用PageHelper
    
        public PageInfo<User> findByPage(int pageNum, int pageSize) {
          // 设置PageHelper分页
          PageHelper.startPage(pageNum,pageSize);
          List<User> list = userMapper.selectAll();
          return new PageInfo<>(list);
        }

[https_docs.spring.io_spring-boot_docs_2.0.3.RELEASE_reference_htmlsingle_common-application-properties]: https://docs.spring.io/spring-boot/docs/2.0.3.RELEASE/reference/htmlsingle/#common-application-properties