我们并不是没有梦想，更不是没有努力过，而是未曾坚持下去！
SpringBoot
Spring Boot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品（Spring家族中的一员）
springboot设计目的： 用来简化 Spring 应用的初始搭建以及开发过程
1、springboot主要特点
自动配置：不需要再关注各个框架的整合配置,springboot全部已经配置好了
起步依赖：我们在需要使用某个框架的时候, 直接添加这个框架的启动器依赖即可 , 不需要在关注jar包的冲突和整合
启动器依赖（starter）：就是springboot提前封装的项目模块
2、SpringBoot、 SpringMVC和Spring有什么区别
Spring是一个IOC容器，用来管理Bean，使用依赖注入实现控制反转，可以很方便的整合各种框架，提供AOP机制弥补OOP的代码重复问题、更方便将不同类不同方法中的共同处理抽取成切面、自动注入给方法执行，比如日志、异常等
OOP：面向对象程序设计
SpringMVC是Spring对web框架的一个解决方案，提供了一个DispatcherServlet，用来接收请求，然后定义了一套路由策略(url到handle的映射)及适配执行handle，将handle结果使用视图解析技术生成视图展现给前端
SpringBoot是Spring提供的一个快速开发工具包，让程序员能更方便、更快速的开发spring+springmvc应用，简化了配置(约定了默认配置)，整合了一系列的解决方案(starter机制)、redis.mongodb.es，可以开箱即用
3、SpringBoot 优势
spring boot 其实不是什么新的框架，它默认配置了很多框架的使用方式，就像 maven 整合了所有的 jar 包，spring boot 整合了所有的框架
1.快速构建项目
2.零配置，遵循“约定大于配置” 编码<配置<约定
3.集成第三方库变为启动器，做到“开销即用”
4.嵌入tomcat服务器
使用Spring Boot开发时, 不需要关注各种复杂的整合配置 , 也不用关注各个库之间的依赖及冲突问题 , Spring Boot已经默认帮我们整合配置好了 !
节省了大量的配置及依赖调整时间, 让我们能够把时间用在刀刃上, 专注业务逻辑的开发。
4、SpringBoot 左下角启动项目配置
- 正常情况按下图打开view下的tool windows会有一个services的选项，但是这里没有
1.点击Run,找到 Edit Configurations
2.点击Templates(不用展开)，展开右侧Configurations available services,点击加号
3.点击加号，选择Spring Boot 确认后，效果如下
4.效果，左下角出现services
SpringBoot入门案例
该入门案例的需求很简单，如下。。
1、创建maven工程
如下图创建名为springboot_01的maven工程
注意下图中springboot_01和springboot是没有父子工程关系的； springboot的存在完全是为了方便管理各个模块，它可以没有
2、pom.xml中添加启动器
SpringBoot可以帮我们方便的管理项目依赖 , 在Spring Boot提供了一个名为**spring-boot-starter-parent**的工程，里面已经对各种常用依赖的版本进行了管理。
我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标(不需要添加版本)即可
在springboot_01工程的pom文件中：
添加父工程启动器 spring-boot-starter-parent
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.6.RELEASE</version> </parent>添加web启动器：spring-boot-starter-web
为了让Spring Boot帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为启动器。因为我们是web项目，这里我们引入web启动器
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>这个启动器的依赖，它已经把自己运行所需要的必要包集成在这个启动器中，通过Maven的依赖传递性，将这些包都依赖到咱们的项目里了
3、创建启动类 Application
Spring Boot项目通过main函数即可启动，我们需要创建一个启动类
启动类可以1.启动tomcat 2.管理各种bean对象（扫描包）
springboot默认就是jar包，因为tomcat内置了
@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class,args); } }
启动类的位置：要以上帝视角。默认扫描启动类所在包及子包下的类身上的注解
4、编写HelloController控制器
里面写一个控制器方法，处理/hello请求
@RestController
public class HelloController {
@RequestMapping("/hello")
public String sayHello(){
return "hello spring boot!!" ;
}
}启动springboot项目，如下图：
在浏览器测试，成功搭建springboot-web项目
5、使用Spring Initializr 快速创建
Spring Initializr 从本质上来说就是一个Web应用程序，它能为你生成Spring Boot项目结构。虽然不能生成应用程序代码，但它能为你提供一个基本的项目结构。
记得要改这里的配置URL https://start.springboot.io
6、启动参数（VM Options）传入配置项
SpringBoot 既可以加载指定目录下的配置文件获取配置项，也可以通过启动参数（VM Options）传入配置项，注意：通过启动参数传入的配置项会“顶掉”配置文件中的配置
在上文中，我们的项目启动端口是8080，现在做如下操作
-Dserver.port=5555
重新启动项目
IDEA 快捷键：
进入方法: Ctrl + 鼠标左键
光标前进/后退： Ctrl + Shirt + 右方向键/左方向键
SpringBoot配置文件
配置文件必须放置在项目的类加载目录下, 并且名字必须是application
springboot项目在运行的时候会自动加载这些配置文件。名字必须是application.yaml,或
application.properties。选其一
1、properties文件
配置数据库连接信息，会重复去写“spring.jdbc.datasource”（这是properties文件的缺点）
spring.jdbc.datasource.driverClassName=com.mysql.jdbc.driver spring.jdbc.datasource.url=jdbc:mysql://springboot_01 spring.jdbc.datasource.username=xiaoyumao spring.jdbc.datasource.password=123456根据配置文件中的属性，创建属性类DataSourceProperties，封装4个属性
@Value是spring中的注解，不是springboot的
import org.springframework.beans.factory.annotation.Value; @Component public class DataSourceProperties { @Value("${spring.jdbc.datasource.driverClassName}") private String driverClassName; @Value("${spring.jdbc.datasource.url}") private String url; @Value("${spring.jdbc.datasource.username}") private String username; @Value("${spring.jdbc.datasource.password}") private String password; //省略get/set方法/toString方法 }在HelloController中，额外加入以下内容
浏览器重新发起请求 http://localhost:8080/hello
查看控制台打印输出：
2、@Value
@Value("${server.port:8080}")
private int serverPort;如上，如果在配置文件没有配置对应的属性，则使用8080作为默认值
给参数注入，执行set方法
public static String zhifuUrl;
@Value("${zhifu.url}")
public void setZhifuUrl(String url) {
CrmUtil.zhifuUrl = url;
} 注：在没有指定默认值的情况下，如果忘记在配置文件配置对应的属性，在程序启动时会报错，导致程序启动失败，这种情况可以为@Value指定默认值，来避免该问题
3、yaml 配置文件
当俩种格式（application.yaml,或application.properties）的配置文件都存在，读的是properties格式的配置文件。
yaml语法 :
1.数据结构用树形结构呈现，通过缩进来表示层级，
2.连续的项目（集合）通过减号 ” - ” 来表示
3.键值结构里面的key/value对用冒号 ” : ” 来分隔。
4.YAML配置文件的扩展名是yaml 或 yml
server: port: 8080 servlet: context-path: /demoserver.port 配置启动项目的tomact端口号
server.servlet.context-path 配置应用的上下文路径，也可以称为项目路径
- server.servlet.context-path不配置时，默认为 / ，如：localhost:8080/xxxxxx
- 当server.servlet.context-path有配置时，比如 /demo，此时的访问方式为localhost:8080/demo/xxxxxx
把上面说的properties属性文件，用yml的语法写就是如下：
spring:
jdbc:
datasource:
driverClassName: com.mysql.jdbc.driver
url: jdbc:mysql://springboot_01
username: xiaoyumao
password: 123456上面这种数据源的连接方式是我们自定义的，以后数据源配置并不会这么使用
以后怎么连接数据库，使用下图框住的上面那个框，下面那个框是自定义的，需要自己写配置类读取。上面的是springboot定义好的，直接可以用。
4、多环境profile切换配置
[profile-配置文件]
场景：开发环境、测试环境、准生产环境、生产环境，每一个环境都有自己的数据库（需要通过yml配置）
Spring Boot项目中配置文件的名称只能是**application** , 如果我们把所有的配置全都写在一个配置文件中如果配置项比较多, 配置文件就会显得比较复杂和臃肿 ! 不利于后期的项目维护和开发
springboot中可以使用多个yaml配置文件，这些文件名称必须为application-***.yml，并且在application.yml中激活（文件中引用）
怎么快速灵活的切换数据库
spring.profiles.active 这个key就不是自定义的了。会自动提示的
-----------------------------------------------------
2个配置文件如下：
创建application-dev.yml，配置开发环境的数据库连接信息
创建application-test.yml，配置测试环境的数据库连接信息
5、修改tomcat端口号
上面的开发环境和测试环境配置里，tomcat的端口号默认都是8080。我们可以单独在不同的yml文件中为每一个不同的环境指定不同的tomcat端口号。
但是没必要，我们就直接在配置在application.yml中配置，让它们共用即可.
此时再次重启，浏览器访问，8080就不好使了，需要访问8089端口
那么为什么默认是8080呢，我来带你找一找
1.点开External Libraries
2.spring-boot-autoconfigure -->META_INF-->json文件
SpringBoot 很多注解
1、@SpringBootApplication
@SpringBootApplication注解是组合注解[@SpringBootConfiguration +@ComponentScan + @EnableAutoConfiguration ]
@SpringBootConfiguration
标注这个类就是配置类，相当于xml配置文件,本质上就是一个@Configuration注解@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Configuration public @interface SpringBootConfiguration { @AliasFor( annotation = Configuration.class ) boolean proxyBeanMethods() default true; }@ComponentScan 上帝视角组件扫描
默认扫描启动类所在包及子包下的类身上的注解
@EnableAutoConfiguration
启用自动配置，自动去读取spring.factories配置文件中的自动配置类@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @AutoConfigurationPackage @Import({AutoConfigurationImportSelector.class}) public @interface EnableAutoConfiguration { String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration"; Class<?>[] exclude() default {}; String[] excludeName() default {}; }下面在自动配置原理中，会详细解释这个注解@EnableAutoConfiguration
2、@Configuration+@Bean
@Configuration 告诉springboot这是一个配置类，等同于以前的application.xml配置文件
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface Configuration { @AliasFor( annotation = Component.class ) String value() default ""; boolean proxyBeanMethods() default true; }@Configuration(proxyBeanMethods = false)
proxyBeanMethods 是用来指定 @Bean 注解标注的方法是否使用CGLIB代理，默认是 true 使用代理。
proxyBeanMethods = false不代理bean方法，每次获取都是重新创建 反之，代理bean方法，代理干的事情：判断这个bean对象是否存在，如果存在就直接在ioc中拿如果配置类中的@Bean标识的方法之间不存在依赖调用的话，可以设置为false，可以避免拦截方法进行代理操作
@Bean 给容器中添加组件，以方法名作为组件的id，返回类型就是组件的类型，返回的值，就是组件在容器中的实例
@Configuration //告诉springboot这是一个配置类，等同于以前的配置文件
public class MyConfig {
@Bean//给容器中添加组件，
App getApp(){
App app = new App(1, "快手");
return app;
}
}注意：配置类本身也是组件
@Bean 默认是单实例的，不管获取多少次这个组件，都是同一个，
在启动类的面方法中，用 ==判断测试
public static void main(String[] args) { ConfigurableApplicationContext run = SpringApplication.run(Spingboot01Application.class, args); //多次获取组件名是getApp的组件 App app1 = run.getBean("getApp", App.class); App app2 = run.getBean("getApp", App.class); //==判断是不是获取的同一个组件 System.out.println(app1==app2); }控制台打印，符合预期
3、@import+@Configuration
1.@Import要写在容器中的组件类上
2.给容器导入自定义的组件User
@Configuration
@Import(User.class)
public class MyConfig {
}
//---User类是另外一个java文件
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private Integer userId;
private String name;
private String password;
}3.import方式导入的组件，默认组件名是全类名
在启动类的main方法里，去获取容器中的组件
@SpringBootApplication public class Application { public static void main(String[] args) { ConfigurableApplicationContext run = SpringApplication.run(Application.class, args); //获取类型为User的所有组件的beanid String[] names = run.getBeanNamesForType(User.class); //遍历打印beanid for (String name : names) { System.out.println(name); //根据beanId获取容器中的bean User user = (User) run.getBean(name); System.out.println(user); } } }运行启动类，打印效果如下，@import注入，默认组件名beanid是全类名
4、@ImportResource+@Configuration
作用：迁移spring中xml方式配置的组件
使用方式：在某一个配置类上加@ImportResource
测试如下：
1.创建Phone类，并使用spring的方式在beans.xml中set注入
<bean id="phone" class="com.example.spingboot01.pojo.Phone"> <property name="brand" value="华为"></property> <property name="name" value="mate50Pro"></property> </bean>2.在配置类上使用@ImportResource导入资源
@Configuration @ImportResource("classpath:beans.xml") public class MyConfig { }3.在启动类里的main方法获取
public static void main(String[] args) { ConfigurableApplicationContext run = SpringApplication.run(Spingboot01Application.class, args); //获取组件名是phone的组件 Object phone = run.getBean("phone"); System.out.println(phone); }4.控制台打印如下，符合预期效果
5、@ConfigurationProperties 配置绑定
该注解源码如下：
//springboot源码
public @interface ConfigurationProperties {
@AliasFor("prefix")
String value() default "";
@AliasFor("value")
String prefix() default "";
}因为prefix和value互为别名，下面我就直接省略了，相当于使用了value
---------------------------
配置绑定：将一些配置属性批量注入到bean对象。
配置绑定方式一：@ConfigurationProperties+@Component
prefix=“公共的key值”，但是类中的属性必须和配置文件的属性一致（长得一样，才会自动注入），这种注入方式，属性再多，只要按照规则就可以一次性自动注入。
注意一定要加 @Component
容器中的组件才能拥有springboot给他提供的强大功能，比如配置绑定
@Component @ConfigurationProperties("spring.jdbc.datasource") @Data //提供get、set、toString方法 public class DataSourceProperties { private String driverClassName; private String url; private String username; private String password; }接着会弹出这么一个玩意
解决办法：在pom文件添加配置信息
spring-boot-configuration-processor其实是一个注解处理器，在编译阶段干活的，一般在maven的声明都是 ,optional 为true
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency>---------------------详细介绍如下
optional表示是否会传递依赖，有两个可填值（假如不声明optional标签，默认就是false）：false: 传递依赖
true：不传递依赖举例：A引用了B的依赖，而B又引用了C依赖。 假如B引用C依赖的时候没有设置optional，那么A是可以使用C依赖的。 假如B引用C依赖的时候将optional标签设置为了true，那么在A当中就无法使用C依赖相关的方法，并且A调用B依赖的方法，而B依赖方法使用到了C，这时候会报找不到C依赖下的类，因为C不参与A的打包。spring-boot-configuration-processor说白了就是给自定义的配置类生成元数据信息的，如上边使用@ConfigurationProperties("spring.jdbc.datasource")的类
项目编译后：
生成的内容如下
{ "groups": [ { "name": "spring.jdbc.datasource", "type": "com.xkcoding.properties.property.DataSourceProperties", "sourceType": "com.xkcoding.properties.property.DataSourceProperties" } ], "properties": [ { "name": "spring.jdbc.datasource.driver-class-name", "type": "java.lang.String", "sourceType": "com.xkcoding.properties.property.DataSourceProperties" }, { "name": "spring.jdbc.datasource.password", "type": "java.lang.String", "sourceType": "com.xkcoding.properties.property.DataSourceProperties" }, { "name": "spring.jdbc.datasource.url", "type": "java.lang.String", "sourceType": "com.xkcoding.properties.property.DataSourceProperties" }, { "name": "spring.jdbc.datasource.username", "type": "java.lang.String", "sourceType": "com.xkcoding.properties.property.DataSourceProperties" } ], "hints": [] }name | String 属性的全名。名称采用小写的周期分隔形式(例如server.address)。此属性是强制性的。 type | String 属性的数据类型的完整签名（例如java.lang.String），但也是完整的泛型类型（例如java.util.Map）。 您可以使用此属性来指导用户可以输入的值的类型。为了保持一致性，通过使用其包装对应项（例如，boolean变为java.lang.Boolean）来指定基元的类型。 请注意，此类可能是一个复杂类型，它从Stringas绑定的值转换而来。如果类型未知，则可以省略。 description | String 可以向用户显示的组的简短描述。如果没有可用的描述，则可以省略。建议描述为简短段落，第一行提供简明摘要。描述中的最后一行应以句点（.）结尾。 sourceType | String 贡献此属性的源的类名称。例如，如果属性来自带注释的类@ConfigurationProperties，则此属性将包含该类的完全限定名称。如果源类型未知，则可以省略。 defaultValue | Object | 默认值，如果未指定属性，则使用该值。如果属性的类型是数组，则它可以是值数组。如果默认值未知，则可以省略。
使用
additional-spring-configuration-metadata.json进行提示。
@Data @ConfigurationProperties(prefix = "developer") @Component public class DeveloperProperty { private String name; private String website; private String qq; private String phoneNumber; }它使用简单的 JSON 格式，其中的项目分类在
groups或properties下，其他值提示分类在hints下为自定义配置添加 hint 提醒。如自定义的开发人员配置信息
配置绑定方式二：@ConfigurationProperties+@EnableConfigurationProperties
某种情况下：我们使用的是第三方的类，人家没标@Component。怎么办，我们也改不了人家的源码
1、在属性类DataSourceProperties上去掉@Component
@ConfigurationProperties("spring.jdbc.datasource") @Data //提供get、set、toString方法 public class DataSourceProperties { private String driverClassName; private String url; private String username; private String password; }2、一定要在配置类上写，替换了方式一的@Component（是不是一定在配置类上写还有待考究，但是在配置类上写了是可以用的）
使用@EnableConfigurationProperties(DataSourceProperties.class)
@Configuration @EnableConfigurationProperties(DataSourceProperties.class) //开启DataSourceProperties类的配置绑定功能 //把这个DataSourceProperties类组件自动注册到容器中 public class MyConfig { }经认证：再次启动该测试方法，也是没有问题的。
@SpringBootTest class Spingboot01ApplicationTests { @Autowired DataSourceProperties dataSourceProperties; @Test void contextLoads() { System.out.println(dataSourceProperties); } }
6、@Conditional 条件装配
满足Conditional 指定的条件，才进行组件的注入。
它有非常多的派生注解，常用如下 :
| 注解 | 作用 |
| @ConditionalOnBean | 如果存在某个Bean, 配置类生效 |
| @ConditionalOnMissingBean | 如果不存在某个Bean, 配置类生效 |
| @ConditionalOnClass | 如果存在某个类, 配置类生效 |
| @ConditionalOnMissingClass | 如果不存在某个类, 配置类生效 |
| @ConditionalOnProperty | 如果存在某个属性配置, 配置类生效 |
| @ConditionalOnWebApplication | 如果是一个web应用, 配置类生效 |
| @ConditionalOnNotWebApplication | 如果不是一个web应用, 配置类生效 |
举例：@ConditionalOnBean
1.条件注解加在方法上，当条件成立后，方法返回的组件才会被注册到容器中
2..条件注解加在类上，当条件成立后，这个类下的所有配置才能生效
SpringBoot自动配置
Springboot在启动的时候会调用run方法，run方法会执行refreshContext()方法刷新容器，
会在类路径下找到springboot-boot-autoconfigure/springboot-boot-autoconfigure.jar/META-INF/spring-factories文件，该文件中记录中众多的自动配置类，
容器会根据我们是否引入依赖是否书写配置文件的情况，将满足条件的Bean注入到容器中，于是就实现了springboot的自动装配
1、@EnableAutoConfiguration
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}2、@AutoConfigurationPackage
直译：自动配置包
@Import@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @Import({Registrar.class}) public @interface AutoConfigurationPackage { String[] basePackages() default {}; Class<?>[] basePackageClasses() default {}; }实际上就是一个@Import，用来给容器中导入一个组件
点击进入Registrar.class
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports { Registrar() { } public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) { AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0])); } public Set<Object> determineImports(AnnotationMetadata metadata) { return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata)); } }利用Registrar给容器中导入一系列组件，哪一系列？？
将指定的一个包（启动类所在包）下的所有组件导入进来。。
原因是从注解@AutoConfigurationPackage的元信息中获取的
3、@Import({AutoConfigurationImportSelector.class})
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}this.getAutoConfigurationEntry();//给容器中导入组件
它里面的一个核心方法，
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);getCandidateConfigurations（）；//获取所有导入到容器的配置类
它会使用spring的工厂加载器
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
return configurations;
}再往下点点点。。
就会找到这个方法，加载我们所有的组件
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
}说了这么多，总计就是从这个位置加载文件：META-INF/spring.factories
4、spring-boot-autoconfigure-2.3.7.RELEASE.jar
核心包
它里面也有 META-INF/spring.factories
打开这个文件META-INF/spring.factories
从22行一直到148行，正好是127个自动配置类。其实就是在配置文件里写死了，
springboot一启动就要给容器中加载的所有配置类，但是这些配置类哪些生效哪些不生效，就是按需开启了。得益于这个条件装配注解@ConditionalOnXXX，实现了按需配置
如查看mvc 的自动配置类：WebMvcAutoConfiguration
SpringBoot配置文件的查找顺序
1、配置信息来源—环境变量
除了properties文件和yaml文件，配置信息也可以来源于环境变量，也可以是 命令行参数来配置，运行jar包的时候。。。
创建Controller，处理请求
@RestController public class HelloController { @Value("${MAVEN_HOME}") private String msg; @RequestMapping("/hello") public String sayHello(){ return msg; } }在浏览器访问，真牛逼啊
2、配置文件查找位置
在生产环境下修改配置就非常简单了，无需修改代码
由上到下加载，配置文件的查找位置
（1）classpath 根路径（最常用）
（2）classpath 根路径下的config目录
（3）jar包当前目录
（4）jar包当前目录的config目录
（5）/config子目录的直接子目录
情况（5）是指linux目录的根目录下有一个config目录，在这个config目录的子目录是可以用的。
注意：下面的配置（后加载）会覆盖上面的同名项配置
3、验证配置文件加载覆盖
测试情况（1），这也是我们平时配置文件放的位置，在classpath根路径
文件内容是：
@RestController public class HelloController { @Autowired DataSourceProperties dataSourceProperties; @RequestMapping("/hello") public String sayHello(){ return dataSourceProperties.getUsername()+":"+dataSourceProperties.getPassword(); } }浏览器访问，没啥问题，这是我们测试别的情况的基础
测试情况（1）和情况（2）同时存在的情况
配置文件的位置
文件内容，只修改了这一处
浏览器访问测试，没啥问题。后加载的配置会覆盖之前同名的配置
测试情况（1）和情况（2）测试情况（3）同时存在
使用idea打包后，创建测试文件夹，把jar包放到文件夹中，并创建application.yml
对配置文件内容作如下修改
打开cmd， java - jar 运行我们的springboot项目
在浏览器访问测试，符合预期效果
测试情况（1）、情况（2）、情况（3）、情况4 同时存在
在jar包所在目录创建config文件夹，并在文件夹里创建配置文件
配置文件内容作如下修改
浏览器访问测试，符合预期效果
总结一波
Springboot 程序启动时，会从以下位置查找配置文件并加载：
- 当前项目根目录下的/config目录下
- 当前项目的根目录下
- classpath:/config/：classpath的/config目录（即resource目录下的config目录）
- classpath:/ ：classpath的根目录（即resource目录下）
配置文件加载优先级为由上至下，上面的优先级更高，所有位置的文件都会被加载，高优先级配置内容会覆盖低优先级配置内容。
SpringBoot错误处理机制
1、默认错误处理机制
默认情况下：springboot提供/error 处理所有错误的映射
对于机器客户端（如postman），它将生成JSON响应，其中包含错误。HTTP状态和异常消息的详细信息。
对于浏览器客户端，响应一个"whitelabel"错误视图，以HTML格式呈现相同的数据
5130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
