SpringBoot 基础教程

最新推荐文章于 2024-08-24 22:15:32 发布

兔子大人·

最新推荐文章于 2024-08-24 22:15:32 发布

阅读量466

点赞数 1

本文链接：https://blog.csdn.net/weixin_48388096/article/details/115731555

版权

SpringBoot

一、Spring的发展历史

Spring1.x时代
在Spring1.x时代，都是通过xml文件配置bean，随着项目的不断扩大，需要将xml配置分放到不同的配置文件中，需要频繁的在java类和xml配置文件中切换。

Spring2.x时代
随着JDK 1.5带来的注解支持，Spring2.x可以使用注解对Bean进行声明和注入，大大的减少了xml配置文件，同时也大大简化了项目的开发。

那么，问题来了，究竟是应该使用xml还是注解呢？

最佳实践：
1、应用的基本配置用xml，比如：数据源、资源文件等；
2、业务开发用注解，比如：Service中注入bean等；

Spring3.x到Spring4.x到Spring5.x
从Spring3.x开始提供了Java配置方式，使用Java配置方式可以更好的理解你配置的Bean，现在我们就处于这个时代，并且Spring4.x和Springboot都推荐使用java配置的方式

二、Spring的Java配置方式

Java配置是Spring4.x推荐的配置方式，可以完全替代xml配置。
@Configuration和@Bean

Spring的Java配置方式是通过@Configuration 和 @Bean这两个注解实现的：
1、@Configuration作用于类上，相当于一个xml配置文件；
2、@Bean作用于方法上，相当于xml配置中的；

示例：

该示例演示了通过Java配置的方式进行配置Spring，并且实现了SpringIOC功能。

1、Maven创建工程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cb1kf0CV-1618477465607)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/2ELojbveoLokAAua.WgxfVU2tw2AdDvuatVLFWa1Pdc!/b/dFMBAAAAAAAA&bo=ywEZAgAAAAARB.E!&rf=viewer_4)]

2、导入pom.xml

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>

    <!-- 自定义版本号 -->
    <spring.version>4.3.8.RELEASE</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- Spring jar -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.0</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.0</version>
    </dependency>

    <!-- Mysql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.42</version>
    </dependency>

    <!-- druid连接池 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>

    <!-- jackson -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.8.8</version>
    </dependency>

    <!--JSTL标签 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>

    <!-- lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.16.20</version>
      <scope>provided</scope>
    </dependency>


    <!-- mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>


    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.0.0</version>
    </dependency>
</dependencies>

3、代码编写：

创建JavaBean User

@Data
public class User {
        private Integer id;
        private String uname;
        private String upass;
}

创建UserService

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    public User selectById(Integer id) {
        return userDao.selectById(id);
    }
}

创建核心配置文件SpringConfig

/**
该类替代spring_core.xml配置文件
 */
@Configuration  //@Configuration作用于类上，相当于一个xml配置文件
@ComponentScan({"com.qfjy"}) //配置指定的扫描包
public class SpringConfig {
    /*
        相当于XML中的一个bean
        其中bean的方法名称是bean名字
     */
    @Bean
    @Scope("prototype")
    public UserDao userDao(){
        return new UserDao();
    }
}

单元测试

@Test
public void t1(){
    ApplicationContext ctx=new AnnotationConfigApplicationContext(SpringConfig.class);
    String[] names = ctx.getBeanDefinitionNames();
    for (String s:names
        ) {
        System.out.println(s);
    }

    UserService userService = ctx.getBean(UserService.class);
    User user = userService.selectById(123);
    System.out.println(user);
}

小结
从以上的示例中可以看出，使用Java代码就完美的替代xml配置文件，并且结构更加的清晰

读取外部配置文件

jdbc.properties

#### key=value
jdbc_url=jdbc:mysql://localhost:3306/mybatis
jdbc_driver=com.mysql.jdbc.Driver
jdbc_user=root
jdbc_password=root

读取外部的资源配置文件
通过@PropertySource可以指定读取的配置文件，通过@Value注解获取值，具体用法：


@Configuration  //@Configuration作用于类上，相当于一个xml配置文件
@ComponentScan({"com.qfjy"}) //配置指定的扫描包
@PropertySource(value ={"classpath:jdbc.properties"})
public class SpringConfig {

    @Value("${jdbc_url}")
    private String jdbc_url;
    @Value("${jdbc_driver}")
    private String jdbc_driver;
    @Value("${jdbc_user}")
    private String jdbc_user;
    @Value("${jdbc_password}")
    private String jdbc_password;

    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName(jdbc_driver);
        dataSource.setUrl(jdbc_url);
        dataSource.setUsername(jdbc_user);
        dataSource.setPassword(jdbc_password);
        return dataSource;
    }

@PropertySource(value ={"classpath:jdbc.properties"},ignoreResourceNotFound = true)
可通过ignoreResourceNotFound=true忽略配置文件存在

三、SpringBoot简介

什么是SpringBoot

随着动态语言的流行 (Ruby、Groovy、Scala、Node.js)，

Java 的开发显得格外的笨重：繁多的配置、低下的开发效率、复杂的部署流程以及第三方技术集成难度大。

在上述环境下，Spring Boot 应运而生。它使用“习惯优于配置”（项目中存在大量的配置，此外还内置了一个习惯性的配置，让你无需手动进行配置）的理念让你的项目快速的运行起来。使用 Spring Boot 很容易创建一个独立运行（运行 Jar，内嵌 Servlet 容器）准生产级别的基于 Spring 框架的项目，使用 Spring Boot 你可以不用或者只需很少的 Spring 配置。

**其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置,Spring Boot 是一个服务于框架的框架。**通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

Spring Boot的优点

快速构建项目
对主流开发框架的无配置集成
项目可独立运行，无需外部依赖 Servlet 容器
提供运行时的应用监控
极大地提高了开发、部署效率
与云计算的天然集成

Spring Boot的核心特点

**微服务：**使用Spring Boot可以生成独立的微服务功能单元

**自动配置：**针对很多Spring应用程序常见的应用功能，Spring Boot能自动提供相关配置

**起步依赖：**告诉Spring Boot需要什么功能，它就能引入需要的库。

**命令行界面：**这是Spring Boot的可选特性，借此你只需写代码就能完成完整的应用程序，无需传统项目构建。

单体应用与微服务
单体应用是把所有的应用模块都写在一个应用中，导致项目越写越大，模块之间的耦合度也会越来越高。
微服务是一种架构风格，用微服务可以将应用的模块单独部署，对不同的模块进行不同的管理操作，不同的模块生成小型服务，每个功能元素最后都可以成为一个可以独立替换、独立升级的功能单元，各个小型服务之间通过http/rpc进行通信。

Spring Boot的缺点

版本迭代速度很快，一些模块改动很大
由于不用自己做配置，报错时很难定位

四、创建第一个SpringBoot

1、利用 IDEA工具或eclipse[插件]完成创建

（创建时，选中Web。让其支持Web操作访问）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XJyacjP1-1618477465614)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/oUROyYtJ3IK3jSp5Kqm4HnXI1Os1YuUpMa*3A2DHads!/b/dLYAAAAAAAAA&bo=FATVAQAAAAARF.Q!&rf=viewer_4)]

2、编写controller完成运行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cQ9TnQVI-1618477465618)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/WQdYHeyCrK3UmCwJBnjDU2GI9x9hu41cau1Okssl8O0!/b/dDUBAAAAAAAA&bo=VQUMAgAAAAADF2w!&rf=viewer_4)]

五、SpringBoot和核心讲解

1、pom.xml

目录结构

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.0.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

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

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Starter pom（参考手册13.4）

Starter POMs是可以包含到应用中的一个方便的依赖关系描述符集合。你可以获取所有Spring及相关技术的一站式服务，而不需要翻阅示例代码，拷贝粘贴大量的依赖描述符。例如，如果你想使用Spring和JPA进行数据库访问，只需要在你的项目

中包含spring-boot-starter-data-jpa依赖，然后你就可以开始了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mBFaQziz-1618477465620)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/anHTQ4s8GdMOOX4DRLxhOoIeEog2z128SaztuzMeQ8g!/b/dFMBAAAAAAAA&bo=9QTiAgAAAAADNwM!&rf=viewer_4)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0E9JmILl-1618477465623)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/csmy1tbJtiGKANcPtECzJ4TT2Eex8P7.INz2Pp8*Cfk!/b/dL8AAAAAAAAA&bo=9QR6AgAAAAADN5s!&rf=viewer_4)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BzhxSj7v-1618477465624)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/daAPNpcHmRQDxGkFIBkSjAzZ.omm15icPMx4ZyYQwp4!/b/dMMAAAAAAAAA&bo=9QT3AgAAAAADNxY!&rf=viewer_4)]

2 、入口类

@SpringBootApplication

SpringBoot的项目一般都会有*Application的入口类，入口类中会有main方法，这是一个标准的Java应用程序的入口方法。

/**
1、程序从main方法开始运行
2、使用SpringApplication.run()加载主程序类
3、主程序类需要标注：@SpringBootApplication注解
4、程序启动扫描加载主程序类所在的包
*/
@SpringBootApplication
public class Boot1Application {
    public static void main(String[] args) {
        SpringApplication.run(Boot1Application.class, args);
    }
}

@SpringBootApplication注解是SpringBoot的核心注解，它其实是一个组合注解：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

@SpringBootConfiguration：

这是SpringBoot项目的配置注解。进入查看：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

Java之四大元注解@Target、@Retention、@Documented、@Inherited
元注解定义:用于注解【注释】的注解就叫做元注解

1.@Target ：用于描述注解的使用范围，也就是说使用了@Target去定义一个注解，那么可以决定定义好的注解能用在什么地方
2.@Retention：用于描述注解的生命周期，也就是说这个注解在什么范围内有效，注解的生命周期和三个阶段有关：源代码阶段、CLASS文件中有效、运行时有效，故其取值也就三个值，分别代表着三个阶段
3.@Documented：表示该注解是否可以生成到 API文档中。在该注解使用后，如果导出API文档，会将该注解相关的信息可以被例如javadoc此类的工具文档化。 注意：Documented是一个标记注解，没有成员。
4.@Inherited：使用@Inherited定义的注解具备继承性
假设一个注解在定义时，使用了@Inherited，然后该注解在一个类上使用，如果这个类有子类，那么通过反射我们可以从类的子类上获取到同样的注解、

在Spring Boot项目中推荐使用@SpringBootConfiguration替代@Configuration
# 是@Configuration注解的派生注解。功能一致。标注这个类是一个配置类。
# 区别：@Configuration是Spring的注解。目的：解藕。

@EnableAutoConfiguration：

启用自动配置，该注解会让SpringBoot根据项目中依赖的jar包自动配置项目的配置项：
如：我们添加了spring-boot-starter-web的依赖，项目中也就会引入SpringMVC的依赖，SpringBoot就会自动配置tomcat和SpringMVC

@AutoConfigurationPackage
#作用是将 添加该注解的类所在的package 作为 自动配置package 进行管理。
#自动注入主类下所在包下所有加了注解（@Controller/@Service...)及配置类(@Configuration)等。

@Import#导入类
# 1 直接导入普通类
# 2 导入实现了ImportSelector接口的类
# 3 导入实现了ImportBeanDefinitionRegistrat接口的类

xxxAutoConfiguration

SpringBoot中存在大量的类，这些类的作用就是帮助我们进行自动配置。
这些自动配置类就是SpringBoot进行自动配置的核心。

关闭自动配置

通过上述，我们得知，SpringBoot会根据项目中的jar包依赖，自动做出配置，SpringBoot支持的自动配置如（非常多）：

如果发现应用了不想要的自动配置类，可以使用@EnableAutoConfiguration 或@SpringBootApplication 来禁用
@EnableAutoConfiguration禁用配置：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uLmfEQgM-1618477465626)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/s3uNwVInH76ESThKG6xvTcoh0I7QDZGN7G0NdhH0Uiw!/b/dFEBAAAAAAAA&bo=5APUAAAAAAADFwE!&rf=viewer_4)]

@SpringBootApplication 禁用配置：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-arlNntbY-1618477465627)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/ab9q4O5TlpTyue4n1XIB0OnpZ3EkAGOg*eT5.B1LQ!/b/dL4AAAAAAAAA&bo=QPAAAAAAADFzM!&rf=viewer_4)]

@ComponentScan：

组件扫描器，可自动发现和装配一些Bean

（默认扫描@SpringBootApplication所在类的同级目录以及它的子目录。）

六、SpringBoot个性化Banner

1、普通banner

需要在src/main/resources路径下新建一个banner.txt文件，并在banner.txt中填写好你需要打印的文件即可。

banner.txt

 ________                           .__       .__        
 /  _____/ __ __  ______  _  __ ____ |__|__  __|__| ____  
/   \  ___|  |  \/  _ \ \/ \/ // __ \|  \  \/  /  |/    \ 
\    \_\  \  |  (  <_> )     /\  ___/|  |>    <|  |   |  \
 \______  /____/ \____/ \/\_/  \___  >__/__/\_ \__|___|  /
        \/                         \/         \/       \/

参考地址：
http://www.network-science.de/ascii/ （将文字转成文本文件）

http://www.degraeve.com/img2txt.php （将图片转成文本文件）

https://www.asciiworld.com/ (最全的asciiworld)

2、自定义颜色

Spring Boot提供了一个枚举类[AnsiColor]，这个类可以控制banner.txt中的字符颜色，而且非常容易使用。

${AnsiColor.BRIGHT_RED} ：设置控制台中输出内容的颜色
${application.version} ：用来获取MANIFEST.MF 文件中的版本号
${application.formatted-version} ：格式化后的${application.version} 版本信息
${spring-boot.version} ：Spring Boot的版本号
${spring-boot.formatted-version} ：格式化后的${spring-boot.version} 版本信息

把以上信息通过${} 放入banner.txt中，就会打印出项目对应的信息。

3、动态Banner

SpringBoot 2.0后加入了动态Banner的方式

只需要将对应的gif的图片放到src/main/resources即可。[banner.gif]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kEwKOdbV-1618477465629)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/00MgUhoNYC88zNwquCwEz8vkSLMymJFlPvuQb0boP3w!/b/dL8AAAAAAAAA&bo=lgJ*AQAAAAARF8o!&rf=viewer_4)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vWhjbORk-1618477465630)(http://m.qpic.cn/psb?/V13x1ZYF1dFQtq/CSr9bDclLxI0HS.pDehbm42U1saqQPW.sUADeBAgo2k!/b/dL8AAAAAAAAA&bo=GAHSAAAAAAACF*g!&rf=viewer_4)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ln4V40LW-1618477465632)(https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1563965693063&di=6f8fb057f30a521310a10a05b4543520&imgtype=0&src=http%3A%2F%2Fimg.mp.itc.cn%2Fupload%2F20170110%2Fb56b87be5f174eca81f9d06116aa1968.jpg)]

4、解析：

发现 Springboot 可以把图片转换成 ASCII 图案，流程如下：

获取图片。
遍历图片像素点。
分析像素点，每个像素点根据颜色深度得出一个值，根据明暗度匹配不同的字符。
输出图案。

/** 位置：org.springframework.boot.SpringApplicationBannerPrinter */

5、Spring Boot默认寻找 :

默认寻找 Banner 的顺序是

依次在 Classpath 下找文件 banner.gif , banner.jpg , 和 banner.png , 先找到谁就用谁。

继续 Classpath 下找 banner.txt

上面都没有找到的话, 用默认的 SpringBootBanner 。

如下详细配置

https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#core-properties

`spring.banner.charset`	`UTF-8`	横幅文件编码。
`spring.banner.image.height`		字符中的横幅图像的高度（默认基于图像高度）。
`spring.banner.image.invert`	`false`	是否应针对暗终端主题反转图像。
`spring.banner.image.location`	`classpath:banner.gif`	横幅图像文件位置（也可以使用jpg或png）。
`spring.banner.image.margin`	`2`	字符中的左手图像边距。
`spring.banner.image.width`	`76`	字符中的横幅图像的宽度。
`spring.banner.location`	`classpath:banner.txt`	横幅文本资源位置。

七、Spring Boot的配置文件

SpringBoot的核心配置文件用于配置SpringBoot程序。有两种格式的配置文件：

.properties文件
.yml文件

默认情况下会找： bootstrap/application.properties/yml

配置文件的作用：

按需自定义修改SpringBoot自动配置的默认值。

全局配置文件(参考手册23.3)

参考文档：
https://docs.spring.io/spring-boot/docs/1.5.12.BUILD-SNAPSHOT/reference/htmlsingle/

SpringApplication将从以下位置加载application.properties文件，并添加到Spring Environment中：

1. 当前目录下的一个/config子目录
2. 当前目录
3. 一个classpath下的/config包
4. classpath根路径（root）
这个列表是按优先级排序的（列表中位置高的将覆盖位置低的）

application.properties示例：

#修改tomcat的端口为8081
server.port=8080
# 上下文的访问路径
server.servlet.context-path=/boot

更多的配置：

**参考官方文档：(**目录X. Appendices)

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

全局配置文件(yml)

YAML文件定义：

YAML（YAML Ain’t Market Language）语言文件，以数据为中心，比json、XML等文件更加适合做配置文件
yml是一种yaml格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。
yml是一种直观的能够被计算机识别的数据序列化格式。容易被人阅读。yaml类似于XML，但是语法比XML简洁很多。
yml后缀也可以使用yaml后缀。

YAML文件的基本语法：

1. 使用缩进表示层级关系
2. 缩进时不允许使用Tab键，只允许使用空格
3. 缩进的空格的数目不重要，只要相同层级的元素左对齐即可
4. 大小写敏感

YAML的值的写法：

1. k: v：字面直接来写；
2. 字符串默认不用加上单引号或者双引号；
3. ""：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思
4. name: "zhangsan \n lisi"：输出；zhangsan 换行 lisi
5. ''：单引号；会转义特殊字符，特殊字符终只是一个普通的字符串数据
6. name: ‘zhangsan \n lisi’：输出；zhangsan \n lisi
(4) YAML支持三种数据格式：对象，数组，基本数据类型

示例：

server:
  port: 8080  #服务的端口号
  servlet:
    context-path: /boot #上下文环境

备注（加载顺序）：

同一级目录下，如果有相同的application.properties 和application.yml文件时，优先级引用properties文件。同时属性的优先级以先声明的为准。后面不会进行覆盖。

使用配置文件注入属性

Springboot占位符支持的有随机数和配置的值等

官方提供

org.springframework.boot.env.RandomValuePropertySource

${random.value}
${random.int}
${random.long}
${random.int(10)}
${random.int[1024,1233]}
${random.uuid}

自定义配置数值

server:
   port: 9099
app:
   name: qfnj
   tel: 18012345678

获取值方式

注解@Value(value=”${app.name}”)就可以绑定到你想要的属性上面。

Xml配置文件

SpringBoot提供零配置，即无XML配置。但是在实际项目中，可能有一些特殊要求你必须使用XML配置，这时我们可以通过Spring提供@ImportResource来加载XML配置。
例如：(在类上方)
@ImportResource(value = {"classpath:demo.xml"})

bootstrap配置文件

SpringBoot中有以下两种配置文件bootstrap (.yml 或者 .properties)，application (.yml 或者 .properties)

bootstrap.yml 和application.yml 都可以用来配置参数。主要用于 Spring Boot 项目的自动化配置

区别描述：

#1.加载顺序上的区别

bootstrap.yml（bootstrap.properties）先加载
application.yml（application.properties）后加载

在 Spring Boot 中有两种上下文，一种是 bootstrap(用于应用程序上下文的引导阶段，由父Spring ApplicationContext加载), 另外一种是 application。
bootstrap 是应用程序的父上下文，也就是说 bootstrap 加载优先于 applicaton。bootstrap 主要用于从额外的资源来加载配置信息，还可以在本地外部配置文件中解密属性。这两个上下文共用一个环境，它是任何Spring应用程序的外部属性的来源。bootstrap 里面的属性会优先加载，它们默认也不能被本地相同配置覆盖。

#2.bootstrap/ application 的应用场景。

bootstrap.yml 可以理解成系统级别的一些参数配置，这些参数一般是不会变动的。
application 配置文件可以用来定义应用级别的，主要用于 Spring Boot 项目的自动化配置。

#3. bootstrap 配置文件有以下几个应用场景。

使用 Spring Cloud Config 配置中心时，这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息；
一些固定的不能被覆盖的属性
一些加密/解密的场景；

SpringBoot本身并不支持bootstrap.properties文件，需要和Spring Cloud 的组件结合——只有加上Spring Cloud Context依赖才能生效。

<!--需要引入该jar才能使bootstrap配置文件生效-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-context</artifactId>
</dependency>

八、日志

简介

SpringBoot对各种日志框架都做了支持，默认帮我们支持了slf4j.jar和logback的实现。

如果不需要更改为其他日志系统如Log4j2等，则无需多余的配置，LogBack默认将日志打印到控制台上。

如果要使用LogBack，原则上是需要添加dependency依赖的
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>

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

 private static final Logger log= LoggerFactory.getLogger(UserController.class);
@RequestMapping("hello")
    public  String hello(){
        log.trace("跟踪级别--");
        log.debug("==Bug级别--");
        log.info("Info");
        log.warn("warn..");
        log.error("error..级别");
        return "我的第一个 SpringBoot HelloWolrd" ;
    }
}

级别控制

日志的级别是由低到高。级别从高到低： ERROR, WARN, INFO, DEBUG, TRACE

日志的显示内容会在当前级别后的高级别生效显示。
SpringBoot默认的日志级别为info级别。我们可以通过配置来修改默认的日志的配置（控制台）

格式为： 'logging.level.* = LEVEL'
logging.level ：日志级别控制前缀，*为包名或Logger名
LEVEL ：选项 TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF

举例：
logging.level.com.qfjy=DEBUG   #com.qfjy包下所有class以DEBUG级别输出
logging.level.root=WARN   # root日志以WARN级别输出

# 设置日志级别
logging:
  level:
    com.qfjy.web.controller: error
    com.qfjy.service.impl: info #对指定包级别进行设定

文件输出(旧版本)

如果要编写除控制台输出之外的日志文件，则需在application.properties中设置logging.file或logging.path属性。

logging.file	logging.path	示例	描述
none	none		只在控制台输出
指定文件名	none	Log.log	输出到log.log文件
none	指定目录	Log/log.log	输出到指定目录下

· logging.file，设置文件或目录，可以是绝对路径，也可以是相对路径。如：logging.file=my.log

· logging.path，设置目录，会在该目录下创建spring.log文件，并写入日志内容，如：logging.path=/var/log

注：二者不能同时使用，如若同时使用，则只有logging.file生效

# 设置日志级别
logging:
  level:
    com.qfjy : trace #对指定包级别进行设定
  file: log/my.log  #设定日志文件

默认情况下，日志文件的大小达到 10MB 时会切分一次，产生新的日志文件，默认级别为： ERROR、WARN、INFO

文件输出(最新版本)

mvn package 即可看到效果

logging:
  file:
    name: log/my.log

定制日志格式

根据不同的日志系统，你可以按如下规则组织配置文件名，就能被正确加载：

Logback： logback-spring.xml, logback-spring.groovy, logback.xml, logback.groovy
Log4j： log4j-spring.properties, log4j-spring.xml, log4j.properties, log4j.xml
Log4j2： log4j2-spring.xml, log4j2.xml
JDK (Java Util Logging)： logging.properties

Spring Boot 官方推荐优先使用带有 -spring 的文件名作为你的日志配置（如使用 logback-spring.xml ，而不是 logback.xml ），命名为 logback-spring.xml 的日志配置文件， spring boot 可以为它添加一些 spring boot 特有的配置项（下面会提到）。

application.yml

logging:
    config: classpath:logback-spring.xml

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration  scan="true" scanPeriod="10 seconds">

    <!--<include resource="org/springframework/boot/logging/logback/base.xml" />-->

    <contextName>logback</contextName>
    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
    <property name="log.path" value="D:/dudu/log" />

    <!-- 彩色日志 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>


    <!--输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>info</level>
        </filter>
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>


    <!--输出到文件-->

    <!-- 时间滚动输出 level为 DEBUG 日志 -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_debug.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 INFO 日志 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_info.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 WARN 日志 -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_warn.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>


    <!-- 时间滚动输出 level为 ERROR 日志 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_error.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
        以及指定<appender>。<logger>仅有一个name属性，
        一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
              如果未设置此属性，那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
    -->
    <!--<logger name="org.springframework.web" level="info"/>-->
    <!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>-->
    <!--
        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
        第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
     -->


    <!--
        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->

    <!--开发环境:打印控制台-->
    <springProfile name="dev">
        <logger name="com.qfjy" level="debug"/>
    </springProfile>

    <root level="info">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="DEBUG_FILE" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="WARN_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>

    <!--生产环境:输出到文件-->
    <!--<springProfile name="pro">-->
    <!--<root level="info">-->
    <!--<appender-ref ref="CONSOLE" />-->
    <!--<appender-ref ref="DEBUG_FILE" />-->
    <!--<appender-ref ref="INFO_FILE" />-->
    <!--<appender-ref ref="ERROR_FILE" />-->
    <!--<appender-ref ref="WARN_FILE" />-->
    <!--</root>-->
    <!--</springProfile>-->
</configuration>

九、Spring Boot的热部署

在实际开发中，我们修改某处代码逻辑功能或页面都需要重启应用服务器，这无形中降低了开发效率。
热部署是指当我们修改代码后，服务能自动重启加载新修改的内容，这样大大提高了我们开发的效率：
SpringBoot 官方提供了热部署功能：

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

注意以上的热部署方式在IDEA是默认没有打开自动编译的，手动编译需要快捷键（Ctrl+Shift+F9），自动编译的修改配置如下：(注意刷新不要太快，会有1-2秒延迟)

yml文件中如果出现中文注释乱码，可在此解决:

https://www.cnblogs.com/ambitionutil/p/11245312.html

十、SpringBoot单元测试

导入依赖jar

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

测试类

@RunWith(SpringRunner.class)   //是告知JAVA环境 这个类通过用什么运行环境运行。启动和创建均是（spring的应用上下文）
@SpringBootTest
class Ch2BootApplicationTests {
    @Autowired
    DemoService demoService;
    @Test
    void contextLoads() {
      ......
    }

}

需要重启应用服务器，这无形中降低了开发效率。
热部署是指当我们修改代码后，服务能自动重启加载新修改的内容，这样大大提高了我们开发的效率：
SpringBoot 官方提供了热部署功能：

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

yml文件中如果出现中文注释乱码，可在此解决:

https://www.cnblogs.com/ambitionutil/p/11245312.html

十、SpringBoot单元测试

导入依赖jar

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

测试类

@RunWith(SpringRunner.class)   //是告知JAVA环境 这个类通过用什么运行环境运行。启动和创建均是（spring的应用上下文）
@SpringBootTest
class Ch2BootApplicationTests {
    @Autowired
    DemoService demoService;
    @Test
    void contextLoads() {
      ......
    }

}