SpringBoot，写完老板又让我转回后端

最新推荐文章于 2022-04-08 11:57:41 发布

深知她是一场梦

最新推荐文章于 2022-04-08 11:57:41 发布

阅读量2k

点赞数 1

分类专栏： SpringBoot 文章标签： springBoot 原理源码解析微服务 thtmeleaf

本文链接：https://blog.csdn.net/lgl782519197/article/details/110678870

版权

本文详细介绍了SpringBoot的基础知识，包括SpringBoot的特点、微服务概念以及如何搭建SpringBoot项目。通过实例演示了配置文件的使用，包括YAML语法和获取配置值的不同方式。文章还深入探讨了SpringBoot自动配置的原理，并展示了如何扩展和全面接管SpringMVC。此外，文章涵盖了SpringBoot的国际化、登录拦截、错误页面定制、数据访问和任务调度等多个方面，帮助读者全面掌握SpringBoot的开发和应用。

摘要由CSDN通过智能技术生成

1：SpringBoot基础入门

1-1：什么是SpringBoot

什么是Spring

Spring是一个开源框架，2003年兴起的一个轻量级的Java开发框架，作者：Rod Johnson。

Spring是为了解决企业级应用开发的复杂性而创建的，简化开发

Spring是如何简化Java开发的

为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

1、基于Bean的轻量级和最小侵入性编程；

2、通过IOC，依赖注入DI和面向接口实现松耦合；

3、基于切面AOP和惯例进行声明式编程；

4、通过切面和模板减少样式代码；

什么是SpringBoot

       我们从最原始的Servlet结合Tomcat，接着到Struts，后来到SpringMVC，框架从无到有的衍生，这一切都是为何简化开发，提高开发效率，但是慢慢的我们发现，Spring也不满足我们的需求了，因为配置太多，简称配置地狱。而SpringBoot呢，就是一个JavaWeb大的开发框架，和SpringMVC类似，对比其他JavaWeb框架的好处，官方说是简化开发，约定大于配置，you can ‘‘just run’’，能迅速的开发web应用，几行代码开发一个http接口。

       我们慢慢的发现了一个规律，所有的技术框架的发展似乎都遵循了一条主线：从一个复杂应用场景衍生一种规范框架，人们只需要进行各种配置而不需要自己实现它，这时候强大的配置功能成了优点；发展到一定程度之后，人们根据实际生产应用情况，选取其中实际功能和设计精华，重构出一些轻量级的框架；之后为了提高开发效率，嫌弃原先的各种配置过于麻烦，于是开始提倡“约定大于配置”，进而衍生出一些一站式的解决方案。

       这就是Java企业级应用->J2EE->Spring->SpringBoot的过程

       随着Spring不断的发展，涉及的领域越来越多，项目整合开发需要配合各种各样的文件，慢慢变得不那么易用简单，违背了最初的理念，甚至人称配置地域。SpringBoot正是在这样的一个背景下被抽象出来的开发框架，目的为了让大家更容易的使用Spring，更容易的集成各种常用的中间件，开源软件；

       SpringBoot基于Spring开发，SpringBoot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷的开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。SpringBoot以约定大于配置的核心思想，默认帮我们进行了很多配置，多试SpringBoot应用只需要很少的Spring配置。同时它集成了大量常用的第三方库配置（例如Redis、MongoDB、Jpa、RabbitMQ、Quartz等等），SpringBoot应用中这些第三方库几乎可以零配置的开箱即用。

       简单来说就是SpringBoot其实不是什么新框架，它默认配置了很多框架的使用方式，就像Maven整合了所有的jar包，SpringBoot整合了所有的框架

       SpringBoot出生名门，从一来是就站在一个比较高的起点，又经过这几年的发展，生态最有完善，SpringBoot已经当之无愧成为Java领域最热门的技术。

SpringBoot的主要特点

快速创建独立运行的Spring项目以及与主流程框架集成

开箱即用，大量的自动配置，提供各种默认配置来简化项目配置，也可以修改默认值

内嵌式容器简化Web项目，使用嵌入式的Servlet容器，应用无需打成war包

没有冗余代码生成和XML配置的要求

starters自动依赖与版本控制

准生产环境的运行时应用监控

与运计算的天然集成

使用SpringBoot到底有多爽，用下面这幅图来表达

1-2：什么是微服务

什么是微服务

微服务是一种架构风格，它要求我们在开发一个应用的时候，这个应用必须构建成一系列小服务的组合；可以通过http的方式进行互通。要说微服务架构，先得说说我们过去的单体应用架构。

单体应用架构

       所谓单体应用架构（all in one）是指，我们将一个应用的中所有应用服务都封装在一个应用中。

       无论是ERP、CRM或是其他什么系统，你都把数据库访问，web访问等等各个功能都放大一个war包内。

    这样做的好处：

易于开发和测试

十分方便部署

需要扩展时，只需要将war复制多份，然后放到多个服务器上，再做个负载均衡就可以了。

    这样做的缺点是：

牵一发而动全身，哪怕修改一个非常小的地方，都要停掉整个服务，重新打包、部署这个应用的war包。

对于一个大型应用，如果把所有的内容都放在一个应用里面，我们如何维护，如何分工合作都是问题。

微服务架构

       所谓微服务架构，就是打破之前all in one的传统架构方式，把每个功能元素单独出来。把独立出来的功能元素进行动态组合，需要的功能元素才拿来组合，需要多一些时可以整合多个功能元素。所以微服务架构是对功能元素进行复制，而没有对整个应用进行复制。

    这样做的好处是：

节省了调用资源

每个功能元素的服务都是一个可替换换的，可堵路升级的软件代码

    下面的连接详细的阐述了什么是微服务

原文地址：https://martinfowler.com/articles/microservices.html

翻译版本：https://www.cnblogs.com/liuning8023/p/4493156.html

原文里也提供了几种语言的版本

如何构建微服务

一个大型系统的微服务架构，就像是一个复杂交织的神经网络，每一个神经元就是一个功能元素，它们各自完成自己的功能，然后通过http相互请求调用。比如一个电商系统，查缓存，连数据库，浏览页面，结账，支付等服务都是一个个独立的功能服务，都被微化了，他们只为一个个微服务共同构建了一个庞大的系统。如果修改其中的一个功能，只需要更新升级其中一个功能服务单元即可。

但是这种庞大的系统架构给部署和运维带来很大的难度。于是，Spring为我们带来了构建大型分布式微服务的全套、全程产品：

构建一个个功能独立的微服务应用单元，可以使用SpringBoot，可以帮我们快速构建一个应用；

大型分布式网络服务的调用。这部分有SpringCloud来完成，实现分布式；

在分布式中间，进行流式数据计算、批处理，我们有springCloud Data Flow；

Spring为我们想清楚了整个从开始构建应用到大型分布式应用全流程方案。

1-3：官网搭建SpringBoot项目

首先进入官网https://spring.io/projects/spring-boot

       拉到最下面

       点击进入或者直接进入https://start.spring.io/

       填写项目信息

       我们要创建web项目，选择Spring Web

       信息填完后创建项目

       然后会把项目下载下来

       把包拷贝到你想要的目录下，然后解压

       用idea打开我们的项目

       打开项目后先让maven下载依赖包，导入完可以删掉我们不需要的文件

       删掉文件后的项目

       然后启动项目

       访问http://localhost:8080/

       到这里整个基础项目就完成，接下来就是自己的业务问题，我们这里写个简单的接口

       重启访问接口

1-4：使用Idea快速创建SpringBoot项目

       创建项目

       填写基本信息

       提示Artifact含有非法字符集

       是因为我们的Artifact含有大写字母，改为小写就好

       SpringBoot项目创建成功，删掉我们不想要的文件

       因为我们创建的时候，没有导入Web依赖，所以这个项目不是Web项目，如果想变为Web项目，可以手动Maven导入依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>
       启动项目

       访问http://localhost:8080/

       修改端口号

       重启

resources文件夹中目录结构

static：保存所有的静态资源：（js、css、images）

templates：保存所有的模板页面：（SpringBoot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面），可以使用模板引擎（freemarker、thymeleaf）

application.properties：SpringBoot应用的配置文件，可以修改一些默认设置

1-5：自定义banner

所谓banner，就是启动项目的时候的这个东西

在项目的resources目录下，新建一个文件叫banner.txt

在这个新建的banner.txt文件下定义你们想要输出的内容即可

更多的banner图，可以来这里找https://www.bootschool.net/ascii-art

我这里搞了一辆车的

                      _____________________________________________________
                     |                                                     |
            _______  |                                                     |
           / _____ | |                货拉拉---程序员的好归宿                |
          / /(__) || |                                                     |
 ________/ / |OO| || |                                                     |
|         |-------|| |                                                     |
(|         |     -.|| |_______________________                             |
|  ____   \       ||_________||____________  |             ____      ____  |
/| / __ \   |______||     / __ \   / __ \   | |            / __ \    / __ \ |\
\|| /  \ |_______________| /  \ |_| /  \ |__| |___________| /  \ |__| /  \|_|/
  | () |                 | () |   | () |                  | () |    | () |
   \__/                   \__/     \__/                    \__/      \__/

启动项目

1-6：单元测试@SpringBootTest

使用@SpringBootTest要导入依赖

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

进入spring-boot-starter-test的依赖看，里面集成了SpringBootTest的依赖，sprin的核心springframework依赖以及junit和各种依赖

总体来说比junit强大很多

然后在单元测试的类上方加上@SpringBootTest，在单元测试的方法上方加上@Test，加了@SpringBootTest，那就可以使用Spring的注入了

package com.lingaolu.springbootdemo;

import com.lingaolu.springbootdemo.bean.Student;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringbootdemoApplicationTests {
    

   @Autowired
   Student student;
   @Test
   void contextLoads() {
    
       System.out.println(student);
   }

}

我这里注入了类Student，Student类注入了name属性

package com.lingaolu.springbootdemo.bean;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class Student {
    
   @Value("林某")
   private String name;

   public String getName() {
    
       return name;
   }

   public void setName(String name) {
    
       this.name = name;
   }

   @Override
   public String toString() {
    
       return "Student{" +
               "name='" + name + '\'' +
               '}';
   }
}

单元测试执行，结果出来

2：SpringBoot的配置

我们在第一章SpringBoot基础入门的第四节使用Idea快速创建SpringBoot项目的时候已经初步接触了SpringBoot的配置，那就是修改端口号，下面我们来介绍SpringBoot的配置

2-1：配置文件格式

SpringBoot的配置文件，后缀不仅支持.properties，还只会yml和yaml格式，从下图我们可以看出

2-2：YAML语法

百度百科：

YAML（/ˈjæməl/，尾音类似camel骆驼）是一个可读性高，用来表达数据序列化的格式。YAML参考了其他多种语言，包括：C语言、Python、Perl，并从XML、电子邮件的数据格式（RFC 2822）中获得灵感。Clark Evans在2001年首次发表了这种语言，另外Ingy döt Net与Oren Ben-Kiki也是这语言的共同设计者。当前已经有数种编程语言或脚本语言支持（或者说解析）这种语言。

YAML是"YAML Ain’t a Markup Language"（YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言），但为了强调这种语言以数据做为中心，而不是以标记语言为重点，而用反向缩略语重命名。

YAML以数据为中心，比json、xml等更适合做位置文件
YAML配置例子
server:
 port: 666
XML配置例子
<server>
	<port>666</port>
</server>
可见yml太简洁方便，我们验证一下yaml修改端口号

说明我们使用yaml修改端口号成功

2-2-1：基本语法

k:(空格)v：表示一对键值对，k和v之间的空格必须有，并且冒号:是英文的冒号:

以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的

属性和值也是大小写敏感

2-2-2：值的写法

字面量：普通的值（数字，字符串，布尔）

k: v（字面直接来写）

字符串默认不用加上单引号或者双引号

“”：双引号，不会转义字符串里面的特殊字符，特殊字符会作为本身想表达的意思
如：name: “lin\nmou”,输出：lin换行mou

‘’：单引号，会转义特殊字符，特殊字符最终只是一个普通的字符串数据
如：name: ‘lin\nmo’,输出：lin\nmou
对象、map(属性和值)（键值对）
girlFriend:
 name: 未知
 age: 29
行内写法
girlFriend: {
     name: 未知,age: 29}
数组（List、Set）

用-值表示数组中的第一个元素
games:
 - LOL
 - CS
 - WOW
行内写法
games: [LOL,CS,WOW]

2-3：从配置文件中获取值

SpringBoot默认的配置文件全名为application.properties，默认被识别，也就是application开头.(properties/yaml/yml)的配置文件属于SpringBoot的全局配置文件，可以被默认加载

2-3-1：@ConfigurationProperties(prefix=“配置”)

@ConfigurationProperties可以从配置文件中获取整个对象的配置值，将配置文件中配置的每一个属性的值，通过反射的set方法，映射到这个组件中，我们还是直接举例子

我们有2个实体bean对象

Girl：含有name和age属性，书写set和get方法

Programmer：含有name和age以及girl属性，使用lombok

Girl的代码

package com.lingaolu.springbootdemo.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

// 只有这个组件是容器的组件，才能使用容器提供的>@ConfigurationProperties功能
@Component
// 将配置文件中配置的每一个属性的值，映射到这个组件中
// @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配合文件中相关的配置进行绑定
// prefix="girl",配置文件中哪个页面的所有属性进行--映射
@ConfigurationProperties(prefix="girl")
public class Girl {
    
   private String name;
   private Integer age;

   public String getName() {
    
       return name;
   }

   public void setName(String name) {
    
       this.name = name;
   }

   public Integer getAge() {
    
       return age;
   }

   public void setAge(Integer age) {
    
       this.age = age;
   }

   @Override
   public String toString() {
    
       return "Girl{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
   }
}

Programmer的代码

package com.lingaolu.springbootdemo.bean;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
// 使用lombok
@Data
@ConfigurationProperties(prefix="pro")
public class Programmer {
    

   private String name;
   private Integer age;
   private Girl girl;
}

Girl的配置，采用properties文件
girl.name=go
girl.age=25

Programmer的配置，采用yml文件

pro:
 name: 林某
 age: 25
 girl:
   name: 狗不理
   age: 23

单元测试

package com.lingaolu.springbootdemo;

import com.lingaolu.springbootdemo.bean.Girl;
import com.lingaolu.springbootdemo.bean.Programmer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringbootdemoApplicationTests {
    

   @Autowired
   Girl girl;
   @Autowired
   Programmer programmer;
   @Test
   void contextLoads() {
    
       System.out.println(girl);
       System.out.println("------------------");
       System.out.println(programmer);
   }

}

运行结果

从结果可以看出，无论是properties文件还是yml文件，都能成功的把配置文件里的属性值映射到我们的实体

properties文件中文乱码问题，从上面的例子看出，我们的yml配置文件使用中文，可能成功的映射，那么我们的properties文件也使用中文，结果乱码了

解决properties文件中文乱码问题，因为我们idea里的properties文件默认的是utf-8编码，而运行时的properties文件是ascii编码，所以我们需设置一下

Apply,OK，接着修改属性的值，我们修改为一场梦幻的爱情，再测试一下，中文乱码解决了

发现没有，无论是Girl类还是Programmer类，上方都会有一个红色的提示，这个不影响我们的代码，就是看起来不舒服

解决上面的问题，我们可以导入配置文件处理器

<!-- 导入配置文件处理器，配置文件进行绑定就会有提示  -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-configuration-processor</artifactId>
   <optional>true</optional>
</dependency>

刷新maven，重启一下，那么无论是哪种配置文件，我们配置的时候也会有提示了

2-3-2：@ConfigurationProperties(prefix=“配置”)和@value的区别

我们知道spring原生的注解@value也可以给属性注入值，如我们下列的例子

Programmer类的name属性使用@value，其他的使用@ConfigurationProperties

package com.lingaolu.springbootdemo.bean;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@Data
@ConfigurationProperties(prefix="programmer")
public class Programmer {
    

   @Value("${name}")
   private String name;
   private Integer age;
   private String no;
}

配置文件

programmer:
	age: 25
	no: 110
name: 码农

结果，name属性也注入值了

虽然@value也可以注入，但是和@ConfigurationProperties还是有区别的，如下表

比较项	@ConfigurationProperties	@value
决定性	非SpEL注入，以@ConfigurationProperties为最终结果	以SpEL注入，以@value为最终结果
功能	批量注入配置文件中的属性	一个一个指定
SpEL	不支持	支持
松散绑定	支持	不支持
JSR303数据校验	支持	不支持
复杂类型封装	支持	不支持

下面我们举例说明

决定性

SpEL

松散绑定
JSR303数据校验
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-validation</artifactId>
</dependency>
要使用数据校验，得maven引入上面的包，然后使用注解@Validated作用在要校验的类上，接着在对应属性的相关类型校验进行注解，比如我们这里进行邮箱校验
复杂类型封装

2-3-3：@PropertySource()加载.properties文件

我们先看一个例子

我们前面说过，SpringBoot默认的配置文件名前缀是application，并且这种前缀的配置文件属于全局配置文件，可以被SpringBoot全局找到，被默认加载，但是我们的配置文件是pro.properties，命名的格式不符合全局配置文件的方式，所以找不到，要想找到，就使用@PropertySource()，加载指定的配置文件

package com.lingaolu.springbootdemo.bean;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;


@Data
@Component
@PropertySource(value = {
    "classpath:pro.properties"})
@ConfigurationProperties(prefix="pro")
public class Programmer {
    
   private String name;
   private Integer age;

}

加载了指定的配置文件后，就可以被找到了

2-3-4：@PropertySource()加载.yml或者yaml文件

上一节我们说到了@PropertySource()加载.properties文件，这节我们将说@PropertySource()加载.yml或者yaml文件，那么你可能回想，为何要分开说，既然分开说，那就明他们是有区别的，我们先用.properties文件成功的例子，演示一下.yml文件

发现即使使用了@PropertySource()加载指定的文件，还是没有成功

这是为什么呢？这是因为@PropertySource只对properties文件可以进行加载，但对于yml或者yaml不能支持。

想要解决这个问题，我们需要写一个工厂类，继承DefaultPropertySourceFactory，用来处理yml或者yaml文件，因为@PropertySource有一个工厂属性factory。默认就是DefaultPropertySourceFactory

所以我们写了一个工厂类
在这里插入图片描述

package com.lingaolu.springbootdemo.factory;

import org.springframework.boot.env.YamlPropertySourceLoader;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.DefaultPropertySourceFactory;
import org.springframework.core.io.support.EncodedResource;
import java.io.IOException;
import java.util.List;
import java.util.Properties;

// 继承DefaultPropertySourceFactory
public class YamlAndPropertySourceFactory extends DefaultPropertySourceFactory {
    
   @Override
   public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
    
       if (resource == null) {
    
           return super.createPropertySource(name, resource);
       }
       Resource resourceResource = resource.getResource();
       if (!resourceResource.exists()) {
    
           return new PropertiesPropertySource(null, new Properties());
       } else if (resourceResource.getFilename().endsWith(".yml") || resourceResource.getFilename().endsWith(".yaml")) {
    
           List<PropertySource<?>> sources = new YamlPropertySourceLoader().load(resourceResource.getFilename(), >resourceResource);
           return sources.get(0);
       }
       return super.createPropertySource(name, resource);
   }
}

然后我们的@PropertySource，除了要加载指定的配置文件外，还要指定我们所写的工厂类
在这里插入图片描述

package com.lingaolu.springbootdemo.bean;

import com.lingaolu.springbootdemo.factory.YamlAndPropertySourceFactory;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;


@Data
@Component
@PropertySource(value = {
    "classpath:pro.yml"}, factory = YamlAndPropertySourceFactory.class)
@ConfigurationProperties(prefix="pro")
public class Programmer {
    
   private String name;
   private Integer age;

}

结果能成功注入

2-3-5：@ImportResource

@ImportResource的作用就是导入Spring的配置文件，让配置文件里面的内容生效

我们先看一个例子，SpringBoot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别

我们自己写了一个spring的配置文件

<?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
       https://www.springframework.org/schema/beans/spring->>beans.xsd">

   <bean id="programmer1" class="com.lingaolu.springbootdemo.bean.Programmer">
       <property name="name" value="我们缺少的是勇气"/>
   </bean>


</beans>

单元测试

package com.lingaolu.springbootdemo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

@SpringBootTest
class SpringbootdemoApplicationTests {
     

   @Autowired
   ApplicationContext ioc;
   @Test
   void contextLoads() {
     
       boolean b1 = ioc.containsBean("programmer");
       System.out.println(b1);
       boolean b2 = ioc.containsBean("programmer1");
       System.out.println(b2);
   }

}

结果发现IOC容器竟然没有我们注入的bean，因为我们自己写的spring.xml文件没有生效
在这里插入图片描述

想要我们自己写的spring.xml生效，这就需要@ImportResource登场了，在我们的SpringBoot的主配置类入口上标注上@ImportResource(locations = {“classpath:spring.xml”})

我们再运行测试一下，成功生效

2-3-6：@Configuration

我们在Spring中知道，xml配置文件可以使用配置类来代替，只需要在配置类中使用注解@Configuration就可以声明这个类是配置类，然后使用@Bean注解说明这个方法相当于配置文件的<bean>标签，SpringBoot提倡使用配置类的方式,代替2-3-5：@ImportResource的配置文件方式

我们定义一个配置类MyConfig
在这里插入图片描述

package com.lingaolu.springbootdemo.config;

import com.lingaolu.springbootdemo.bean.Programmer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// @Configuration声明这个类是配置类
@Configuration
public class MyConfig {
    

   // @Bean相当于配置文件里的<bean>标签，注入到IOC容器中，key为方法名
   @Bean
   public Programmer programmer2(){
    
       return new Programmer();
   }

}

结果

2-3-7：配置文件占位符

配置文件占位符使用的是${表达式}，其中可以使用随机数等等

我们的Programmer类代码

package com.lingaolu.springbootdemo.bean;

import com.lingaolu.springbootdemo.factory.YamlAndPropertySourceFactory;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;


@Data
@Component
@ConfigurationProperties(prefix="pro")
public class Programmer {
    
   private Integer age;
   private String name1;
   private String name2;
   private String name3;
   private String name4;

}

配置文件代码

pro:
 age: 24
 name1: ${
    random.uuid}
 name2: ${
    pro.name1}林
 name3: ${
    pro.name}林
 name4: ${
    pro.name:神}林

结果说明

2-4：多配置环境Profile

我们在协作开发的过程中，通常需要多配置环境，比如开发是一套环境，上线又是一套环境，这就需要多环境配置，需要用到什么环境就切换到相应的配置环境即可

2-4-1：多文档快方式

在yml文件中，支持多文档快方式，使用—进行文档快的分割，如下

结果

默认环境

使用激活dev环境

使用激活prod环境

2-4-2：多配置文件方式

上面介绍了多文档快方式，但是如果配置很多的时候，使用多文档快方式容易搞错，所以还是需要多配置文件方式比较清楚，但是使用多配置文件方式，其文件名有要求

文件名：application-环境名.yml

结果

默认环境

使用激活dev环境

使用激活prod环境

2-4-3：激活指定的Profile环境

激活指定的Profile环境的方式有很多种，上面已经演示过一种，在配置文件中指定，下面再介绍其他的
在配置文件中指定

.properties文件
spring.profiles.active=prod
.yml文件
spring:
 profiles:
   active: prod
虚拟机参数-Dspring.profiles.active=prod

虽然我配置文件中指定了dev环境，但是运行的时候虚拟机参数指定了prod环境，所以实际的配置是prod环境，所以端口号是8082

命令行参数指定，–spring.profiles.active=prod

虽然我配置文件中指定了dev环境，但是运行的时候命令行参数指定了prod环境，所以实际的配置是prod环境，所以端口号是8082

关于命令行方式还可以这样操作，因为我们的项目最终打包成1个jar包

最终也是使用了我们指定的配置环境和端口号

注意，当虚拟机参数和命令行参数同时存在时，最终已命令行参数为最终的配置

2-5：配置文件的加载位置与顺序

SpringBoot启动会扫描以下位置的application.properties文件或者application.yml文件以及application.yaml文件作为SpringBoot的默认配置文件

file:./config/

file:./

classpath:/config/

classpath:/

加载顺序为

这些位置的加载顺序为由低到高，所以优先级为由高到低，高优先级的配置会覆盖掉低优先级的配置

同一位置的加载顺序为:application.properties文件，application.yml文件，到application.yaml文件，所以优先级从高到低为application.yaml文件—application.yml文件—application.properties文件，优先级高的配置会覆盖掉低优先级的配置

所有的配置文件都可以共同起作用进行互补配置

同一位置，三种文件同时存在时示例

示例如下

同一位置，三种文件同时存在时，最高优先级为.yaml文件

.yaml文件不存在相关的配置，那么.yml文件第二优先级

.yaml文件和.yml文件都不存在相关的配置，轮到第三优先级的.properties文件

不同位置配置文件示例

示例如下

4个位置都有配置文件时，最高优先级为项目路径下的config/配置文件，即file:./config/

项目路径下的config/配置文件没有相关配置时，轮到第2优先级的项目路径下的配置文件，即file:./

前2个配置文件没有相关配置时，轮到第3优先级的类路径下的config/的配置文件，即 classpath:/config/

前3个配置文件没有相关配置时，轮到第4优先级的类路径下的配置文件，即 classpath:/

我们还可以通过–spring.config.location来改变默认的配置文件位置，项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置

       我们启动jar包，端口号是8089

       现在我们外部有一个配置文件，端口号是8090

       我们还是启动之前的jar包，只不过是通过–spring.config.location来改变默认的配置文件位置，这样端口号也变为了8090

3：SpingBoot的原理

我们都知道，SpringBoot比Spring方便，是因为它帮我们默认配置了很多东西，那么SpringBoot到底能配置什么属性，我们可以从官网里面找SpringBoot可配置属性

但是这里有那么多的属性，要记起来那就是头疼了，所以要方便了解SpringBoot可配置什么，去了解SpringBoot自动装配的原理是很有必要的。

万事开头难，那么我们就从项目的源头开始入手，项目启动很简单，就只有一个注解@SpringBootApplication，看来这个注解帮我们处理很很多事，我们就从这个注解入手

点进来发现了一个启用自动配置的注解，SpringBoot启动的时候加载主配置类，开启了自动配置功能@EnableAutoConfiguration

最低0.47元/天解锁文章

深知她是一场梦

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
2
评论
SpringBoot，写完老板又让我转回后端

SpringBoot1：SpringBoot基础入门1-1：什么是SpringBoot1-2：什么是微服务1：SpringBoot基础入门1-1：什么是SpringBoot什么是Spring       Spring是一个开源框架，2003年兴起的一个轻量级的Java开发框架，作者：Rod Johnson。       Spring是为了解决企
复制链接

扫一扫