SpringCore 完整学习教程1，入门级别

SpringCore 完整学习教程1，入门级别
1. SpringApplication

SpringApplication类提供了一种方便的方式来引导从main()方法启动的Spring应用程序。在很多情况下，你可以委托给静态的SpringApplication.run方法，如下面的例子所示:
```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class MyApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
 
}
 
```
1.1. Startup Failure

如果应用程序启动失败，注册的failureanalyzer将有机会提供专门的错误消息和解决问题的具体操作。例如，如果你在端口8080上启动一个web应用程序，并且该端口已经在使用中，你应该看到类似以下消息:
```
***************************
APPLICATION FAILED TO START
***************************
 
Description:
 
Embedded servlet container failed to start. Port 8080 was already in use.
 
Action:
 
Identify and stop the process that is listening on port 8080 or configure this application to listen on another port.
```
Spring Boot提供了许多FailureAnalyzer实现，您可以添加自己的实现。类似于：
```
package dev.farhan.movies.cache;
 
import org.springframework.boot.diagnostics.AbstractFailureAnalyzer;
import org.springframework.boot.diagnostics.FailureAnalysis;
import org.springframework.stereotype.Service;
 
@Service
public class Failure extends AbstractFailureAnalyzer {
    @Override
    protected FailureAnalysis analyze(Throwable rootFailure, Throwable cause) {
        if (rootFailure.getMessage().equals("classnotfound......")){
            System.out.println("版本不对，找不到类");
        }
        return null;
    }
}
```
1.2. Lazy Initialization

SpringApplication允许惰性初始化应用程序。当启用延迟初始化时，bean将在需要时创建，而不是在应用程序启动时创建。因此，启用延迟初始化可以减少应用程序启动所需的时间。在web应用程序中，启用延迟初始化将导致许多与web相关的bean在收到HTTP请求之前不会初始化。

总之就是好处是：减少应用程序启动的时间。坏处是：如果延迟初始化配置错误的bean，则在启动期间将不再发生失败，并且只有在初始化bean时才会出现问题。

延迟初始化可以通过编程方式使用SpringApplicationBuilder上的lazyInitialization方法或SpringApplication上的setLazyInitialization方法来启用。或者，也可以使用spring.main来启用它。惰性初始化属性，示例如下:
```
spring:
  main:
    lazy-initialization: true
```
1.3. Customizing the Banner

可以通过在类路径中添加banner.txt文件或通过将spring.banner.location属性设置为此类文件的位置来更改在启动时打印的横幅。如果文件的编码不是UTF-8，则可以设置spring.banner.charset。

1.4. Customizing SpringApplication

如果SpringApplication默认值不符合您的口味，您可以创建一个本地实例并对其进行定制。例如，要关闭横幅，你可以这样写:
```
import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class MyApplication {
 
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(MyApplication.class);
        application.setBannerMode(Banner.Mode.OFF);
        application.run(args);
    }
 
}
 
```
1.5. Fluent Builder API

如果你需要构建一个ApplicationContext层次结构(具有父/子关系的多个上下文)，或者如果你更喜欢使用“流畅”的构建器API，你可以使用SpringApplicationBuilder。
SpringApplicationBuilder允许你将多个方法调用链接在一起，并包含父方法和子方法，让你创建一个层次结构，如下面的例子所示:
```
package dev.farhan.movies;
 
import org.springframework.boot.Banner;
import org.springframework.boot.ExitCodeGenerator;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
 
@SpringBootApplication
@EnableCaching
public class MoviesApplication {
 
	@Bean
	public ExitCodeGenerator exitCodeGenerator() {
		return () -> 42;
	}
 
	public static void main(String[] args) {
		new SpringApplicationBuilder().sources(MoviesApplication.class)
				.bannerMode(Banner.Mode.OFF)
				.run(args);
 
		//SpringApplication.run(MoviesApplication.class, args);
		//System.out.println(SpringApplication.exit(SpringApplication.run(MoviesApplication.class, args)));
	}
 
}
 
 
```
1.6. Application Availability

当部署在平台上时，应用程序可以使用Kubernetes Probes等基础设施向平台提供有关其可用性的信息。Spring Boot包括对常用的“活跃”和“就绪”可用性状态的开箱即用支持。如果您正在使用Spring Boot的“执行器”支持，那么这些状态将作为健康端点组公开。
此外，您还可以通过将ApplicationAvailability接口注入到您自己的bean中来获得可用性状态。

1.6.1. Liveness State

应用程序的“活跃”状态告诉我们，它的内部状态是否允许它正常工作，或者如果当前出现故障，它是否可以自行恢复。中断的“活跃”状态意味着应用程序处于无法恢复的状态，基础设施应该重新启动应用程序。

一般来说，“活动性”状态不应该基于外部检查，比如健康检查。如果是这样，失败的外部系统(数据库、Web API、外部缓存)将触发大量重启和跨平台的级联故障。

Spring Boot应用程序的内部状态主要由Spring ApplicationContext表示。如果应用程序上下文已经成功启动，Spring Boot假定应用程序处于有效状态。只要上下文被刷新，应用程序就被认为是活动的。

1.6.2. Readiness State
```
应用程序的“就绪”状态告诉应用程序是否准备好处理流量。失败的“就绪”状态告诉平台，它现在不应该将流量路由到应用程序。这通常发生在启动期间，当commandlinerrunner和ApplicationRunner组件正在处理时，或者在任何时候，如果应用程序决定它太忙而无法接收额外的流量。
一旦调用了应用程序和命令行运行程序，就认为应用程序准备好了
```
1.6.3. Managing the Application Availability State
```
package dev.farhan.movies.cache;
 
import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.ReadinessState;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
 
@Component
public class MyReadinessStateExporter {
 
    @EventListener
    public void onStateChange(AvailabilityChangeEvent event) {
        switch (event.getState()) {
            case ACCEPTING_TRAFFIC:
                // create file /tmp/healthy
                break;
            case REFUSING_TRAFFIC:
                // remove file /tmp/healthy
                break;
        }
    }
 
}
 
```
1.7. Application Events and Listeners

在应用程序运行时，应用程序事件按以下顺序发送:
1. ApplicationStartingEvent在运行开始时发送，但在任何处理之前发送，除了侦听器和初始化器的注册。
2. 当要在上下文中使用的环境已知时，但在创建上下文之前，将发送ApplicationEnvironmentPreparedEvent。
3. 当ApplicationContext准备好并且ApplicationContextInitializedEvent被调用时，在加载任何bean定义之前发送applicationcontextinitialalizer。
4. ApplicationPreparedEvent在刷新开始之前、加载bean定义之后发送。
5. ApplicationStartedEvent在上下文刷新之后，但在调用任何应用程序和命令行运行程序之前发送。
6. 紧接着发送一个AvailabilityChangeEvent和livessstate。正确表示应用程序被认为是活动的。
7. 在调用任何应用程序和命令行运行程序后发送ApplicationReadyEvent。
8. 紧接着发送一个AvailabilityChangeEvent和ReadinessState。ACCEPTING_TRAFFIC表示应用程序已准备好处理请求。
9. 如果在启动时出现异常，则发送ApplicationFailedEvent。
WebServerInitializedEvent在WebServer准备好后发送。ServletWebServerInitializedEvent和ReactiveWebServerInitializedEvent分别是servlet和响应变体。
当ApplicationContext被刷新时，发送一个ContextRefreshedEvent。

事件监听器不应该运行可能很长的任务，因为它们默认在同一个线程中执行。考虑使用应用程序和命令行运行器。likethis 本章的1.10

1.8. Web Environment

SpringApplication尝试为您创建正确类型的ApplicationContext。用于确定WebApplicationType的算法如下:
- 如果Spring MVC存在，则使用AnnotationConfigServletWebServerApplicationContext
- 如果Spring MVC不存在，而Spring WebFlux存在，则使用AnnotationConfigReactiveWebServerApplicationContext
- 否则，使用AnnotationConfigApplicationContext
1.9. Accessing Application Arguments

如果需要访问传递给SpringApplication.run(…)的应用程序参数，可以注入org.springframework.boot.ApplicationArguments bean。ApplicationArguments接口提供了对原始String[]参数以及解析后的选项和非选项参数的访问，如下面的示例所示:
```
import java.util.List;
 
import org.springframework.boot.ApplicationArguments;
import org.springframework.stereotype.Component;
 
@Component
public class MyBean {
 
    public MyBean(ApplicationArguments args) {
        boolean debug = args.containsOption("debug");
        List files = args.getNonOptionArgs();
        if (debug) {
            System.out.println(files);
        }
        // if run with "--debug logfile.txt" prints ["logfile.txt"]
    }
 
}
 
```
测试：
```
package com.example.demo;
 
import com.example.demo.demos.MyBean;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.DefaultApplicationArguments;
import org.springframework.boot.test.context.SpringBootTest;
 
 
@SpringBootTest
class DemoApplicationTests {
 
    @Autowired
    private MyBean myBean;
 
    @Test
    void contextLoads() {
    }
 
    @Test
    public void testMyBean() {
        String[] args = {"--debug", "logfile.txt"};
        ApplicationArguments arguments = new DefaultApplicationArguments(args);
        myBean = new MyBean(arguments);
 
    }
}
```
运行结果：

1.10. Using the ApplicationRunner or CommandLineRunner

如果需要在SpringApplication启动后运行一些特定的代码，可以实现ApplicationRunner或commandlinerrunner接口
```
package dev.farhan.movies.cache;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
 
@Component
public class MyCommandLineRunner implements CommandLineRunner {
 
    @Override
    public void run(String... args) {
        System.out.println("sb该启动了-------------");
    }
    
 
}
 
```
1.11. Application Exit

项目退出时，可以创建一个退出码，给jvm，类似于：
```
package dev.farhan.movies;
 
import org.springframework.boot.Banner;
import org.springframework.boot.ExitCodeGenerator;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
 
@SpringBootApplication
@EnableCaching
public class MoviesApplication {
 
	@Bean
	public ExitCodeGenerator exitCodeGenerator() {
		return () -> 42;
	}
 
	public static void main(String[] args) {
		new SpringApplicationBuilder().sources(MoviesApplication.class)
				.bannerMode(Banner.Mode.OFF)
				.run(args);
 
		//SpringApplication.run(MoviesApplication.class, args);
		System.exit(SpringApplication.exit(SpringApplication.run(MoviesApplication.class, args)));
	}
 
}
```
1.12. Admin Features

通过指定spring.application.admin.enabled属性，可以为应用程序启用与管理相关的特性。这将在MBeanServer平台上公开SpringApplicationAdminMXBean。您可以使用此特性远程管理Spring Boot应用程序。此特性对于任何服务包装器实现也很有用。
如果您想知道应用程序正在哪个HTTP端口上运行，那么使用local.server.port的键获取该属性。

1.13. Application Startup tracking

将信息写入缓冲区

在应用程序启动期间，SpringApplication和ApplicationContext执行许多与应用程序生命周期、bean生命周期甚至处理应用程序事件相关的任务。通过ApplicationStartup, Spring Framework允许你使用StartupStep对象来跟踪应用程序的启动顺序。收集这些数据可以用于分析目的，或者只是为了更好地理解应用程序启动过程。
```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup;
 
@SpringBootApplication
public class MyApplication {
 
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(MyApplication.class);
        application.setApplicationStartup(new BufferingApplicationStartup(2048));
        application.run(args);
    }
 
}
 
```
2. Externalized Configuration

Spring Boot允许您外部化您的配置，以便您可以在不同的环境中使用相同的应用程序代码。您可以使用各种外部配置源，包括Java属性文件、YAML文件、环境变量和命令行参数。

属性值可以通过使用@Value注释直接注入到bean中，通过Spring的环境抽象进行访问，或者通过@ConfigurationProperties绑定到结构化对象。

Spring Boot使用一个非常特殊的PropertySource顺序，旨在允许合理的值重写。以后的属性源可以覆盖在以前的属性源中定义的值。来源按下列顺序:
1. 默认属性(通过设置SpringApplication.setDefaultProperties指定)。
2. @PropertySource 你的注释 @Configuration类上的注释。请注意，在刷新应用程序上下文之前，不会将此类属性源添加到环境中。这对于配置某些属性(如日志记录)来说太晚了。*和spring.main。*在刷新开始前读取。
3. 配置数据(如应用程序)。属性文件)。
4. RandomValuePropertySource只具有random.*中的属性。
5. 操作系统环境变量。
6. Java系统属性(System. getproperties())。
7. 来自java:comp/env的JNDI属性。
8. ServletContext初始化参数。
9. ServletConfig初始化参数。
10. 来自SPRING_APPLICATION_JSON的属性(嵌入在环境变量或系统属性中的内联JSON)。
11. 处理命令行参数
12. 属性，可以在@SpringBootTest和测试注释中获得，用于测试应用程序的特定部分。
13. @DynamicPropertySource 测试中的注释。
14. @TestPropertySource 测试上的注释。
15. Devtools global settings properties in the $HOME/.config/spring-boot directory when devtools is active.
配置数据文件按以下顺序考虑:
1. Application properties 打包在您的jar(应用程序)中。属性和YAML变体)。
2. Profile-specific application properties 打包在jar (application-{profile})中。属性和YAML变体)。
3. Application properties 在打包的jar(应用程序)之外。属性和YAML变体)。
4. Profile-specific application properties 在打包的jar (application-{profile})之外。属性和YAML变体)。
建议在整个应用程序中坚持使用一种格式。如果在同一位置有.properties和YAML格式的配置文件，则.properties优先。

为了提供一个具体的例子，假设你开发了一个使用name属性的@Component，如下面的例子所示:
```
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
 
@Component
public class MyBean {
 
    @Value("${name}")
    private String name;
 
    // ...
 
}
 
```
2.1. Accessing Command Line Properties

默认情况下，SpringApplication将任何命令行选项参数(即以——开头的参数，例如——server.port=9000)转换为属性，并将它们添加到Spring环境中。如前所述，命令行属性总是优先于基于文件的属性源。
如果不希望将命令行属性添加到环境中，可以使用SpringApplication.setAddCommandLineProperties(false)禁用它们。

2.2. JSON Application Properties
```
java -Dspring.application.json='{"my":{"name":"test"}}' -jar myapp.jar
```
尽管JSON中的空值将被添加到结果属性源中，但PropertySourcesPropertyResolver将空属性视为缺失值。这意味着JSON不能用空值覆盖来自低阶属性源的属性。

2.3. External Application Properties

Spring Boot会自动找到并加载应用程序。属性和应用程序。当应用程序启动时，从以下位置获取Yaml文件:
1. 从类路径
  1. 类路径root
  2. 类路径/配置包
2. 从当前目录
  1. 使用当前目录
  2. 当前目录下的config/子目录
  3. config/子目录的直接子目录
该列表按优先级排序(较低项的值覆盖较早项的值)。加载文件中的文档作为propertresources添加到Spring环境中

不想写了，下回合见，记得关注不迷路
相关阅读:
Python程序设计——厄拉多塞素数筛选法的应用
 『现学现忘』Docker基础 — 22、使用Docker安装Nginx
socket 到底是个啥
 一次吃亏的运维经历
 UE5- c++ websocket里实现调用player里的方法
 【Java 基础篇】Java Consumer 接口详解
 [附源码]SSM计算机毕业设计高校教师教学助手系统的设计与实现JAVA
使用dumuz应用淘宝-收藏的宝贝批量下载导出
 java集合处理数据量过大导致超过Mysql in的最大值
 EN 12467纤维水泥平板产品—CE认证
原文地址：https://blog.csdn.net/m0_63251896/article/details/134068450

1. SpringApplication

1.1. Startup Failure

1.2. Lazy Initialization

1.3. Customizing the Banner

1.4. Customizing SpringApplication

1.5. Fluent Builder API

1.6. Application Availability

1.6.1. Liveness State

1.6.2. Readiness State

1.6.3. Managing the Application Availability State

1.7. Application Events and Listeners

1.8. Web Environment

1.9. Accessing Application Arguments

1.10. Using the ApplicationRunner or CommandLineRunner

1.11. Application Exit

1.12. Admin Features

1.13. Application Startup tracking

2. Externalized Configuration

2.1. Accessing Command Line Properties

2.2. JSON Application Properties

2.3. External Application Properties