springBoot初级入门

获取配置文件中的值@ConfigurationProperties

1、这个注解默认只能从全局配置文件中获取信息，全局配置有两个，如下：

1、application.properties

2、application.yml

yml

1、key和value之间需要空格

2、缩进显示层次关系，缩进多少无所谓，只要左对齐那么就是一个层级关系的

3、key: value :： 表示一个键值对，注意一定要有空格

4、大小写敏感

5、属性的值如果是字符串可以直接写，不需要加上双引号或者单引号

1、双引号：加上双引号的值不会转义里面的特殊字符，比如字符串中包含一个换行符，那么就会在输出的时候换行

2、单引号：会转义特殊的字符，会直接输出换行符为`\n`

6、List和Set的表示方法：

# key与value之间空格
pets:
    - dog
    - pig
    - cat

## 行内的写法：
pets: [dog,pig,cat]

7、Map<key,value>的写法

map: {name: Jack,age: 22,gender: 女}

8、举例

1、JavaBean：

/**
 * ConfigurationProperties ： 这个注解表示这个实体类的值来自于配置文件中，当然包括properties和yaml文件
 *                          prefix表示这个配置文件中的前缀
 */
@Component  //注入到容器中
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private int age;
    private List<Object> list;
    private Map<String,Object> map;
    private User user;
    private Date birthday;
}

2、application.yml

person:
  name: 陈加兵
  age: 22
  list:
    - zhangsan
    - lisi
  user:
    name: 郑元梅
    age: 22
  map: {name: Jack,age: 22,gender: 女}
  birthday: 2012/12/11

3、添加一个依赖，将会在配置文件中自动提示

    <!--导入这个处理器，在配置文件中将会自动提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

4、测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class TeammissionServerApplicationTests {
    @Autowired
    private Person person;   //自动注入

    @Test
    public void contextLoads() {
        System.out.println(person);   //输出配置信息
    }

}

properties

1、依然可以使用@ConfigurationProperties这个注解获取配置文件的值，不过和yml文件中的配置有很大的区别，如下：

person.age=22
person.name=陈加兵
person.birthday=2012/12/11
person.list=a,b,c
person.map.name=陈加兵
person.map.age=22
person.user.name=Jack
person.user.age=33

@Value

1、这个注解是spring中的注解，用于获取配置文件的值

2、不支持JSR303校验

@PropertySource

1、我们在使用@configurationProperties获取文件中的信息的时候，默认只能从默认的配置文件中获取信息，如果我们需要自己单独定义一个配置文件，那么需要使用@PropertySource这个注解获取其中的信息

2、 我们在项目路径下新建一个person.properties文件，其中的内容如下：

person.age=22
person.name=陈加兵
person.birthday=2012/12/11
person.list=a,b,c
person.map.name=陈加兵
person.map.age=22
person.user.name=Jack
person.user.age=33

3、在Person这个实体类中添加如下的注解配置，使用@PropertySource这个注解加载这个配置文件，如下：

/**
 * ConfigurationProperties ： 这个注解表示这个实体类的值来自于配置文件中，当然包括properties和yaml文件
 *                          prefix表示这个配置文件中的前缀
 */
@PropertySource(value ={"classpath:person.properties"})   //从自定义的配置文件中获取信息
@Component  //注入到容器中
@ConfigurationProperties(prefix = "person")   //获取前缀为person的信息
public class Person {

    private String name;
    private int age;
    private List<Object> list;
    private Map<String,Object> map;
    private User user;
    private Date birthday;
}

4、使用@PropertySource这个注解能够导入自定义的配置文件并且获取其中的值

5、 使用这个注解只能加载properties文件，无法加载YAML文件

@ImportSource

1、在springBoot中几乎没有配置文件，全部都是使用注解，那么我们如果需要使用配置文件，我们该如何让这个配置文件生效呢？

2、我们可以使用这个注解加载自己的配置文件xml，不过在springBoot中不赞成这样做，因为可以使用配置类来代替配置文件xml

3、我们在项目的resource文件下新建一个beans.xml，其中配置了如下的信息：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="person" class="com.telles.teammissionserver.bean.Person">
        <property name="age" value="22"></property>
        <property name="name" value="陈加兵"></property>
    </bean>

</beans>

4、我们现在需要将其加入到IOC容器中，必须使用@ImportSource这个注解，我们需要在项目的主配置类上添加这个注解导入配置文件

//使用这个注解可以导入自定义的配置文件xml,其中的value值是一个数组，可以填写多个值
@ImportResource(value = {"classpath:beans.xml"})
@SpringBootApplication
public class TeammissionServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(TeammissionServerApplication.class, args);
    }
}

配置类

1、我们在springBoot中已经完全舍弃了配置文件的形式来为容器注入组件，我们都是使用配置类的形式，每个项目在建立的时候都有一个主配置类，使用SpringBootApplication这个注解来标注的，我们也可以定义自己的配置类，只要使用@Configuration这个注解标注即表示当前类是一个配置类。

2、我们在新建一个包config专门存放配置类，在其中可以建立多个配置类，如下：

@Configuration  //指定这是一个配置类
public class MainConfig {
    /**
     * @Bean: 这个注解将其注入到IOC容器中
     * 其中的返回类型Person就相当于class，方法名就是返回的id，在IOC容器中我们可以使用这个id获取自动
     * 配置的实例
     */
    @Bean
    Person person(){
        Person person=new Person();
        person.setAge(22);
        person.setName("chen");
        return person;
    }
}

配置文件占位符

1、可以使用随机数，如下：

## 使用随机的uuid为其复制
person.name=${random.uuid}
## 配置一个随机的int
person.age=${random.int}

2、可以使用占位符获取之前配置的值，如果没有可以使用:指定默认值

## 配置一个随机的int
person.age=${random.int}
# 使用占位符获取之前配置的值，如果这个值不存在，那么使用指定的默认值
person.user.age=${person.age:33}

多环境开发

1、我们在开发的时候可能会面对多环境，比如生产环境，测试环境，上线运行环境，针对这几种不同的环境，我们可能需要的配置也是不相同的，此时我们就需要在不同的环境之间切换不同的配置文件。

properties

1、我们可以在创建不同的properties文件，文件名如：application-{profile}.properties，比如，application-dev.properties和application-prod.properties这两个文件，此时我们可以springBoot的朱主配置文件中application.properties文件中添加如下的语句，用来激活某一种的配置文件：

# 激活dev配置文件，那么此时springBoot就会以application-dev.properties文件为配置文件
spring.profiles.active=dev

yaml

1、在yaml中不需要建立多个文件，因为yaml可以使用---区分不同的文档，只要在一个主配置文件application.yml中添加不同区域的文档，即使表示不同的文件，如下：

## 文档块1，此时激活dev
server:
  port: 8081
spring:
  profiles:
    active: dev

---


## dev环境的配置
server:
  port: 8080
spring:
  profiles: dev

---

## prod环境的配置
server:
  port: 8088
spring:
  profiles: prod

配置文件加载位置

1、springBoot项目创建的时候在classpath路径下的有一个application.properties文件，这个就是springBoot默认的文件位置，但是我们还可以在其他的位置指定配置文件，依然会生效。

2、springBoot有以下的位置可以放置配置文件，按照优先级由高到低如下：

1、项目路径下的config文件夹中

2、直接放在项目路径下

3、classpath路径下的config文件夹中

4、直接放在classpath路径下【创建项目的时候默认位置】

3、classpth即是resource文件夹下

4、注意：无论放在哪个位置，默认加载的文件名称必须是application.properties

5、如果高优先级和低优先级共有的配置，那么高优先级会覆盖低优先级的配置，但是高优先级配置文件中的没有的配置，如果在低优先级的配置文件中存在，那么依然会生效，这样就可以形成互补的形式

6、可以在默认的配置文件application.properties文件中使用spring.config.location来指定外部的配置文件，如下：

spring.config.location=/usr/local/application.properties

7、在项目已经发布出去之后，我们也可以使用命令行的方式指定配置文件的位置，如：java -jar springboot.jar --spring.config.location=/usr/local/application.properties

日志框架

1、spring默认的规定的日志框架是self4j和logback，这是目前的主流的日志框架，如果想要使用self4j和log4j，那么需要使用指定的适配类进行接口的转换。转换关系如下图：

[图片上传失败...(image-25c743-1538922709906)]

2、默认什么都不配置的情况下，日志是开启的，使用的是self4j+logback，日志的级别是info

3、我们可以在全局配置文件appliction.properties或者application.yml中修改默认的配置，比如修改默认的日志级别，控制台输出格式，输出的日志文件的位置

4、日志的输出级别由高到低的级别如下：ERROR, WARN, INFO, DEBUG, or TRACE.

5、在springBoot中支持自定义的日志配置如下：

# 指定com.telles包下的所有类下的日志输出级别为debug,可以指定某个类或者某个包下的类所使用的日志级别
logging.level.com.telles=error


# 如果指定的相对路径，那么就是在当前项目下，如果指定的了绝对路径，比如c:\\log\\spring.log，那么就是在指定的位置上生成log输出的文件
logging.file=log/spring.log

# 也是指定的日志的文件的位置，不过是在当前项目的所在根目录下指定的文件的位置，比如/log/spring.log，这个就是在该项目的根目录中的log文件夹下指定的日志文件是spring.log
logging.path=/log/spring.log

# 指定控制台输出的格式，但是也是有默认的格式，这个和log4j的配置是一样的
logging.pattern.console=

# 指定日志文件的输出格式
logging.pattern.file=

# 指定文件最大大小
logging.file.max-size=

# 指定日期的格式
logging.pattern.dateformat=

## 文件最大保存历史量
logging.file.max-history=

6、当然也可以使用自定义的配置文件，但是命名有一定的规范，否则springBoot并不能自动识别，比如如果使用logback日志框架的话，那么自定义的配置文件的名称必须是logback-xxx.xml,放在resource文件夹下,否则将不能识别，基本的配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <!--定义日志文件的存储地址 一般存储在服务器的文件夹中-->
    <property name="LOG_HOME" value="/tmp/logs" />

    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出-->
            <pattern>[%p]-[%c] - %m%n</pattern>
        </encoder>
    </appender>

    <!-- 按照每天生成日志文件 -->
    <appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名,使用日期进行拼接-->
            <FileNamePattern>${LOG_HOME}/web.log.%d{yyyy-MM-dd}.log</FileNamePattern>
            <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
        <!--日志文件最大的大小-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>100MB</MaxFileSize>
        </triggeringPolicy>
    </appender>

    <!-- show parameters for hibernate sql 专为 Hibernate 定制
    <logger name="org.hibernate.type.descriptor.sql.BasicBinder"  level="TRACE" />
    <logger name="org.hibernate.type.descriptor.sql.BasicExtractor"  level="DEBUG" />
    <logger name="org.hibernate.SQL" level="DEBUG" />
    <logger name="org.hibernate.engine.QueryParameters" level="DEBUG" />
    <logger name="org.hibernate.engine.query.HQLQueryPlan" level="DEBUG" />-->

    <!--myibatis log configure-->
    <logger name="com.apache.ibatis" level="DEBUG"/>
    <logger name="java.sql.Connection" level="DEBUG"/>
    <logger name="java.sql.Statement" level="DEBUG"/>
    <logger name="java.sql.PreparedStatement" level="DEBUG"/>

    <!-- 日志输出级别 -->
    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE" />
    </root>
    <!--日志异步到数据库 -->
    <!--<appender name="DB" class="ch.qos.logback.classic.db.DBAppender">-->
    <!--&lt;!&ndash;日志异步到数据库 &ndash;&gt;-->
    <!--<connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">-->
    <!--&lt;!&ndash;连接池 &ndash;&gt;-->
    <!--<dataSource class="com.mchange.v2.c3p0.ComboPooledDataSource">-->
    <!--<driverClass>com.mysql.jdbc.Driver</driverClass>-->
    <!--<url>jdbc:mysql://127.0.0.1:3306/databaseName</url>-->
    <!--<user>root</user>-->
    <!--<password>root</password>-->
    <!--</dataSource>-->
    <!--</connectionSource>-->
    <!--</appender>-->
</configuration>

自定义日志文件

1、springboot启动的时候会自动加载日志的配置文件，默认使用的是self4j+logback，虽然springBoot为我们自动配置了默认的配置，但是我们还是需要自己定义配置文件，我们可以创建一个配置文件放置在resuorce文件夹下面，但是命名规则确实有一些区别，如下：

2、总结的说就是，如果使用logback的日志，那么可以指定一个logback.xml放置在resource文件夹下，那么springBoot将会默认加载这个配置，直接覆盖默认的配置。如果使用log4j这个日志框架，那么可以直接创建一个log4j.properties放置在resrouce文件夹下。如果使用log4j2这个日志，我们可以使用log4j2.xml这个日志文件放置在resoruce文件夹下。

日志框架的切换

1、上面的日志文件都是一个配置文件针对多个环境，但是如果我们想要使用profile的功能，比如开发环境使用一个日志配置文件，运行环境使用另外一个配置文件，那么此时就需要使用日志框架的profile功能，此时的命名规则就必须是logback-{profile}.xml，比如使用logback框架的时候，那么我们可以配置logback-dev.xml作用与开发环境，使用logback-spring.xml用于运行环境。

2、虽然懂得了命名规则，那么需要在日志的配置文件中指定切换语句，如下：

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
</springProfile>

<springProfile name="dev | staging">
    <!-- configuration to be enabled when the "dev" or "staging" profiles are active -->
</springProfile>

<springProfile name="!production">
    <!-- configuration to be enabled when the "production" profile is not active -->
</springProfile>

程序中使用日志

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

private final Logger logger= LoggerFactory.getLogger(this.getClass());

SpringMVC的开发

1、如果想要开发springmvc模块，只需要选中web模块即可，默认的springBoot会自动为我们创建一些自动配置，不用自己一步一步的搭建springMVC框架。但是如果我们需要自己全面接管或者在原有的基础上进行一些扩展的话，SpringBoot都提供了一些支持。

创建一个web模块

1、创建项目，导入启动器，如下：

        <!--导入web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--springBoot的测试模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </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-devtools</artifactId>
            <optional>true</optional>
        </dependency>

引入静态资源

webjars的引入

1、springMVC引入自动配置资源都是在org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration这个类中进行配置，因此静态资源位置的映射也是在这个类中完成的，如下，即是配置静态资源映射的方法

    @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
                return;
            }
            Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
            CacheControl cacheControl = this.resourceProperties.getCache()
                    .getCachecontrol().toHttpCacheControl();
            //请求/webjars/**
            if (!registry.hasMappingForPattern("/webjars/**")) {
                customizeResourceHandlerRegistration(registry
                        .addResourceHandler("/webjars/**")
                        .addResourceLocations("classpath:/META-INF/resources/webjars/")
                        .setCachePeriod(getSeconds(cachePeriod))
                        .setCacheControl(cacheControl));
            }
            //添加 /**资源映射
            String staticPathPattern = this.mvcProperties.getStaticPathPattern();
            if (!registry.hasMappingForPattern(staticPathPattern)) {
                customizeResourceHandlerRegistration(
                        registry.addResourceHandler(staticPathPattern)
                                .addResourceLocations(getResourceLocations(
                                        this.resourceProperties.getStaticLocations()))
                                .setCachePeriod(getSeconds(cachePeriod))
                                .setCacheControl(cacheControl));
            }
        }

2、通过上面的代码可以知道任何/webjars/**这种请求的方式都会在classpath:/META-INF/resources/webjars/这个位置查找相关的静态资源

3、webjars：是一种以jar包的方式引入静态资源，比如引用jQuery、Bootstrap的文件，那么我们只需要引入对应的jar包即可访问这些静态资源，官方网址：https://www.webjars.org/

4、比如我们现在引入jquery的jar，如下：

    <!--引入jquery的jar-->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>jquery</artifactId>
            <version>3.3.1-1</version>
        </dependency>

5、此时我们看到导入webjas的目录结构，如下，自动配置的资源映射就是对应webjars下的资源位置，

image

1)、此时如果想要获取jquery.js这个文件，那么可以通过`http://localhost:8080/webjars/jquery/3.3.1-1/jquery.js`这个url查询到指定的文件，这个就是相对于上面springBoot自动配置的webjars的映射位置

其他静态资源的引入

1、除了映入webjars这个静态资源，我们还有自定义的css和js文件，那么我们也必须有一个位置放置这些资源，让springBoot能够访问到

2、/**是用来访问当前项目的任何资源，主要的就是静态文件夹，默认映射的位置如下：

1）、classpath ： 指定的是java和resources文件夹

2）、这写文件夹都是存放静态资源的，那么肯定会发生冲突，比如多个文件夹存放的静态资源名称是一样的，那么我们该如何查找呢？

3）、这些文件夹是否顺序访问的，即是按照如下的优先级进行访问的，如果上一级找到了，那么将会返回，下面的文件夹将不会查找

"classpath:/META-INF/resources/", 
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/" 

3、我们可以在classpath路径下创建上面的四个文件夹用来存放静态资源文件夹，这样我们就可以访问到这些资源了。如下：

image

4、此时我将slider.css这个静态资源文件放置到static中，那么我们可以通过请求http://localhost:8080/slider.css，将可以访问到这个资源，主要就是去上面的四个文件夹下查找文件，如果有这个文件，那么就返回即可。

配置首页

1、在springBoot中，首页也为我们自动配置了存放的位置

2、我们只需把首页index.html放置在静态资源文件夹下即可访问，比如我们放一个index.html在static文件夹下，直接访问http://localhost:8080/这个即可自动跳转首页

配置小图标

１、我们可以放置一个favicon.ico图片在静态资源文件夹下，那么即可自动为我们的页面配置上小图标

自定义静态资源存放位置

1、我们在全局配置文件中指定自己配置的资源存放位置，如下：

spring.resources.static-locations=classpath:/myStatic

2、一旦配置这个路径，那么上面springBoot自动配置的路径将会失效

模板引擎

1、sprintBoot不支持jsp，但是支持thymeleaf模板引擎，我们可以导入这个模板引擎

        <!--引入themleaf模板引擎-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

2、我们不需要指定版本号，在springBoot中已经为我们指定了默认的版本号，如下：

<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
        <thymeleaf-extras-data-attribute.version>2.0.1</thymeleaf-extras-data-attribute.version>
        <thymeleaf-extras-java8time.version>3.0.1.RELEASE</thymeleaf-extras-java8time.version>
        <thymeleaf-extras-springsecurity4.version>3.0.2.RELEASE</thymeleaf-extras-springsecurity4.version>
        <thymeleaf-layout-dialect.version>2.3.0</thymeleaf-layout-dialect.version>

使用thymelefa

1、我们只需要将所有的html文件放在teamplate下，那么thymeleaf将会自动解析其中的文件

2、引入下面的约束将会自动提示语法：

<html lang="en" xmlns:th="http://www.thymeleaf.org">

语法

1、th： 这个是使用th任意属性来替换原生属性，比如替换id使用th:id,class使用th:class

2、<h1 th:text="${hello}">成功访问</h1> ：替换标签体内的文本

3、表达式：

Simple expressions:
    Variable Expressions: ${...}
    Selection Variable Expressions: *{...}
    Message Expressions: #{...}
    Link URL Expressions: @{...}
    Fragment Expressions: ~{...}
    Literals
Text literals: 'one text' , 'Another one!' ,...
Number literals: 0 , 34 , 3.0 , 12.3 ,...
Boolean literals: true , false
Null literal: null
Literal tokens: one , sometext , main ,...
Text operations:
String concatenation: +
Literal substitutions: |The name is ${name}|
Arithmetic operations:
Binary operators: + , - , * , / , %
Minus sign (unary operator): -
Boolean operations:
Binary operators: and , or
Boolean negation (unary operator): ! , not
Comparisons and equality:
Comparators: > , < , >= , <= ( gt , lt , ge , le )
Equality operators: == , != ( eq , ne )
Conditional operators:
If-then: (if) ? (then)
If-then-else: (if) ? (then) : (else)
Default: (value) ?: (defaultvalue)
Special tokens:
Page 17 of 106No-Operation: _

springMVC的扩展

1、在springBoot中依赖mvc的自动配置肯定是不够的，比如我们需要添加一个拦截器，那么肯定是需要自己配置的，此时我们就需要定义自己的配置类进行扩展功能。

2、扩展的意思是几保留了mvc的自动配置，也使用了一些自定义的功能。

3、自动扩展的实现：

1）、定义一个配置类，使用`@Configuration`

2）、继承`WebMvcConfigurationSupport`，这个类是一个抽象类，其中有实现springmvc的不同组件，如果需要那个组件，只需要实现其中的方法即可

3）、在这个类中实现其中的方法即可。

4、比如我们需要实现一个拦截器，那么我们需要创建一个拦截器类，如下：

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("使用拦截器");
        return true;
    }
}

5、我们需要在配置类中配置这个拦截器，如下：

@Configuration  //springBoot的自动配置类
public class MyConfig extends WebMvcConfigurationSupport {

        //添加一个映射视图的组件，每次请求helloWorld都会映射到index.html
        @Override
        protected void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/helloWorld").setViewName("index");
        }

        //添加一个拦截器
        @Override
       protected void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(new                MyInterceptor()).addPathPatterns("/**").excludePathPatterns("/helloWorld");
    }
}

全面接管SpringMVC

1、全面接管的意思就是不需要springBoot的自动配置，而是全部使用自定义的配置

2、要实现全面接管springMVC，那么只需要在上面的配置上添加一个@EnableWebMvc，如下：

@Configuration  //springBoot的自动配置类
@EnableWebMvc   //全面接管springMVC
public class MyConfig extends WebMvcConfigurationSupport {
    
}

指定日期格式

1、springBoot默认的可以转换的日期格式：yyyy/MM/dd，那么我们可以在配置文件中改变这种配置格式，如下：

## 指定日期格式
spring.mvc.date-format=yyyy-MM-dd

2、一旦转换了这种日期的格式，那么当用户输入的日期格式为上面的那种才会自动转换成Date类型的数据，否则将会转换失败，出现异常

定制错误页面

修改Tomcat的默认配置

1、在springBoot默认使用的是嵌入式的tomcat容器，我们可以在全局配置文件中修改默认的tomcat的配置。

2、如何修改tomcat 的默认配置？

1）、在全局的配置文件application.properties中修改配置即可，如下：

    1）、这些配置全部都是对应着`org.springframework.boot.autoconfigure.web.ServerProperties`这个类，Tomcat的配置对应着`org.springframework.boot.autoconfigure.web.ServerProperties.Tomcat`

## 指定编码格式
## 如果需要修改tomcat的默认配置，我们需要修改server.tomcat.xxx
server.tomcat.uri-encoding=utf-8

## 指定端口号
## 如果需要修改server的默配置，我们需要修改server.xxxx
server.port=8080

注册Servlet、Filter、Listener

1、在springBoot中如果需要用到Servlet、过滤器和监听器，那么就需要自己配置

2、配置三大组件对应的类为：ServletRegistrationBean、FilterRegistrationBean、ServletListenerRegistrationBean。我们只需要在自定义的配置类中将三个组件注册到容器中即可

3、完成注册三大组件

1）、创建自己的三大组件

2）、创建一个配置类，在其中创建注入三大组件即可，如下：

@Configuration   //指定这是一个配置类
public class MyWebConfig {

    //注册自己的Servlet,在其中可以设置在配置文件中能够设置的值
    @Bean   //将这个组件添加到容器中
    public ServletRegistrationBean registrationBean(){
        //构造方法，第一个参数指定的是自己的Servlet，第二个参数指定的是映射的路径，是一个可变参数，可以指定多个参数
        ServletRegistrationBean bean=new ServletRegistrationBean(new MyServlet(),"/hello","/myFine");
        bean.setLoadOnStartup(1);
        return bean;
    }

    //注册过滤器
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean=new FilterRegistrationBean();
        bean.setFilter(new MyFilter());  //设置自己的Filter
        bean.setUrlPatterns(Arrays.asList("/**"));  //设置拦截的路径
        return bean;
    }

    //注册监听器
    @Bean
    public ServletListenerRegistrationBean servletListenerRegistrationBean(){
        ServletListenerRegistrationBean servletListenerRegistrationBean=new ServletListenerRegistrationBean<MyListener>(new MyListener());
        return servletListenerRegistrationBean;
    }
}

整合数据源

1、需要导入mysql的驱动程序

2、导入的依赖如下：

        <!--导入原生的jdbc启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--导入mysql的驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

3、我们可以在springBoot的配置文件中设置默认的mysql参数，如下：

## 配置Jdbc
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/jdbc
    driver-class-name: com.mysql.jdbc.Driver
    ## type用来指定使用什么数据连接池
    #type:

4、springBoot中默认支持的连接池都在org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration中展示出来，如下：

1）、`org.apache.tomcat.jdbc.pool.DataSource`

2）、`com.zaxxer.hikari.HikariDataSource`

3）、`org.apache.commons.dbcp2.BasicDataSource`

5、当然我们也是可以自定义自己的数据源，我们只需要在配置文件中使用spring-datasource.type这个配置即可

整合Druid数据源

0、https://www.cnblogs.com/niejunlei/p/5977895.html

1、导入依赖

        <!-- 添加数据库连接池 druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

2、在全局配置文件中设置使用指定的数据源

# 数据库访问配置
# 主数据源，默认的
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/jdbc
spring.datasource.username=root
spring.datasource.password=root

3、配置数据源参数，下面只是设置了部分的参数，在全局配置文件中设置：

# 下面为连接池的补充设置，应用到上面所有数据源中
# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

4、自定义一个DruidConfig，主要用来配置Druid，如下：

@Configuration   //指定Druid的数据源的配置类
public class DruidConfig {

    //配置druid的参数，并且将其注入到容器中
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DruidDataSource druid(){
        return new DruidDataSource();
    }

    /**
     * 配置监控
     *  1、配置一个管理后台的Servlet
     *  2、配置一个监控的filter
     */

    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean=new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        //设置初始化参数
        Map<String,Object> initParams=new HashMap<>();
        initParams.put("loginUsername","admin");  //设置登录的用户名
        initParams.put("loginPassword","admin");  //设置登录的密码
        initParams.put("resetEnable","false");
//        initParams.put("allow","localhost");  //允许localhost访问，默认是所有都能访问
//        initParams.put("deny","IP地址");  //设置拒绝访问的ip
        bean.setInitParameters(initParams);
        return bean;
    }

    //配置监控的Filter
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean=new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String,Object> initParams=new HashMap<>();
        initParams.put("exclusions","*.css,*.js,/druid/*");   //设置不拦截器的路径
        bean.setInitParameters(initParams);
        bean.setUrlPatterns(Arrays.asList("/**"));
        return bean;
    }
}

整合Mybatis

1、添加mybatis的启动器，如下：

    <!--导入mybatis的依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

2、只需要引入这个启动器，那么springBoot就会自动导入如下的mybatis

    <mybatis.version>3.4.5</mybatis.version>
    <mybatis-spring.version>1.3.1</mybatis-spring.version>
    <spring-boot.version>1.5.6.RELEASE</spring-boot.version>

注解版

1、我们可以使用注解版本的mybatis，只需要创建一个Mapper即可。如下：

@Mapper   //表明这个是mapper接口，会自动扫描
public interface UserMapper {
    @Select("select * from t_user where user_id=#{userId}")
    User selectUser(Integer userId);

    //插入，自增主键返回
    @Options(useGeneratedKeys = true,keyProperty = "userId")
    @Insert("insert into t_user(name) values(#{name})")
    int insertUser(User user);
}

2、使用注解版，如果需要配置mybaits的一些参数，比如驼峰命名法等配置，那么我们可以自定义一个配置类，如下：

import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Mybatis的配置类
 */
@Configuration
public class MybatisConfig {

    //自定义一个定制器，在其中可以针对mybatis配置不同的参数，就相当于一个mybatis的主配置文件
    @Bean  //注入到容器中
    public ConfigurationCustomizer configurationCustomizer(){
        return new ConfigurationCustomizer() {
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                configuration.setMapUnderscoreToCamelCase(true);  //开启驼峰命名法
                //在其中还可以配置myabtis的其他配置
            }
        };
    }
}

3、除了自己配置自定义的配置类来指定mybatis的参数配置，我们还可以在全局配置文件中使用mybatis.来进行相关的配置，比如开启驼峰命名，如下：

mybatis.configuration.map-underscore-to-camel-case=true

4、我们可以使用注解批量扫描mapper，这样我们就不需要在每一个Mapper接口都添加@Mapper这个注解，我们只需要在主配置类中添加@MapperScan这个注解即可，如下：

//批量扫描com.tellwess.springbootserver.mappers这个包下面的所有mapper
@MapperScan(value ="com.tellwess.springbootserver.mappers")
@SpringBootApplication
public class SpringbootServerApplication {

配置文件

1、我们将所有的mapper对应的配置文件放在classpath:mapper/*.xml下面的，其中的UserMapper.xml配置文件如下：

<?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.tellwess.springbootserver.mappers.UserMapper" >

    <select id="selectUser" resultType="com.tellwess.springbootserver.entities.User">
      select * from t_user where user_id=#{userId}
    </select>

    <insert id="insertUser">
        insert  into t_user(name) values(#{name})
    </insert>

</mapper>

2、创建一个UserMapper.java，如下：

public interface UserMapper {

    User selectUser(Integer userId);


    int insertUser(User user);
}

3、在主配置类下创建添加批量扫描注解，将接口注入到容器中，如下：

//批量扫描com.tellwess.springbootserver.mappers这个包下面的所有mapper
@MapperScan(value ="com.tellwess.springbootserver.mappers")
@SpringBootApplication
public class SpringbootServerApplication {

4、在全局配置文件中设置*.xml配置文件的位置，让springBoot能够扫描到，如下：

## 配置mybatis的全局配置文件
mybatis.mapper-locations=classpath:mapper/*.xml
# 开启驼峰命名
mybatis.configuration.map-underscore-to-camel-case=true
# 在其中还可以配置mybatis其他的配置

springBoot对事务的支持

1、在spring中我们如果需要添加事务，可能需要配置切面或者声明式注解，但是在springBoot中我们只需要直接使用即可，一切都为我们自动配置了。

2、要想使用声明式事务注解，那么需要导入spring.tx这个jar，其实这个jar在我们导入spring-boot-starter-jdbc的时候就已经为我们导入了，但是如果我们要是使用mybatis的话，那么只需要导入mybatis的场景启动器即可，因为其中就已经包含了jdbc的场景启动器，因此我们只需要导入mybatis的场景启动器即可，如下：

    <!--导入mybatis的依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

3、在需要添加事务的类上添加一个注解即可@Transactional，如下：

@Transactional
@Service
public class UserServiceImpl implements UserService {}

自动热部署

• 每次修改代码后都需要重新启动程序，但是我们可以使用热部署功能，只需要导入依赖即可。修改代码完成后按住Ctrl+F9即可自动热部署

        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

SpringBoot对跨域的支持

• https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-cors
• 只需要在容器中注入org.springframework.web.servlet.config.annotation.WebMvcConfigurer这个实例即可，如下：

//添加跨域的功能
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")
//                        .allowedOrigins("http://192.168.1.97")
//                        .allowedMethods("GET", "POST")
//                        .allowCredentials(false).maxAge(3600);
                ;   //对所有的路径都支持跨域的访问
            }
        };
    }

• 以上是针对全局配置的跨域，如果需要对某一个controller中的请求使用跨域，可以使用@CrossOrigin(origins = "http://192.168.1.97:8080", maxAge = 3600)这个注解标注在controller的类上，如下：

@CrossOrigin(origins = "http://192.168.1.97:8080", maxAge = 3600)
@RestController
public class IndexController{}

上传文件大小的配置

• 配置文件的方式：

#multipart upload 文件上传
#限制一次上传的单个文件的大小
spring.http.multipart.maxFileSize=10Mb
#限制一次上传的所有文件的总大小
spring.http.multipart.maxRequestSize=10Mb

解决同一个tomcat中不能运行多个springBoot项目问题

• https://www.cnblogs.com/zhaoyan001/p/9179924.html

• 在配置文件中添加配置，如下：

# 每个项目的值必须不同
spring.jmx.default-domain=demo

总结

1、整合mybaits和数据源配置的所有依赖如下：

        <!--导入mysql的驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- 添加数据库连接池 druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

        <!--导入mybatis的依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

springBoot配置文件能够配置的全部配置

• https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#appendix

参考文档

1、https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/

2、专栏

3、http://tengj.top/2017/04/24/springboot0/

4、http://www.ityouknow.com/spring-boot