Spring Boot2.0深度实践 - 第3章 理解 SpringApplication

最新推荐文章于 2022-08-05 14:22:31 发布
最新推荐文章于 2022-08-05 14:22:31 发布
阅读量275 收藏 2
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013837825/article/details/100928368
版权

第3章 理解 SpringApplication

Spring Boot2.0深度实践之核心技术篇
– 第3章 理解 SpringApplication

SpringApplication 简介

参考 https://docs.spring.io/spring-boot/docs/2.1.8.RELEASE/reference/html/boot-features-spring-application.html 可以看到；
The SpringApplication class provides a convenient way to bootstrap a Spring application that is started from a main() method. In many situations, you can delegate to the static SpringApplication.run method

基础技术

  1. Spring 模式注解
  2. Spring 应用上下文
  3. Spring 工厂加载机制
  4. Spring 应用上下文初始化器
  5. Spring Environment 抽象
  6. Spring 应用事件/监听器

衍生技术

  1. SpringApplication
  2. SpringApplication Builder API
  3. SpringApplication 运行监听器
  4. SpringApplication 参数
  5. SpringApplication 故障分析
  6. SpringBoot 应用事件/监听器

SpringApplication 准备阶段

1. 使用方式

  1. 基础使用
        SpringApplication.run(MicroVideoApplication.class, args)
  1. SpringApplication API
        SpringApplication springApplication = new SpringApplication(MicroVideoApplication.class);
        springApplication.setBannerMode(Banner.Mode.CONSOLE);
        springApplication.setWebApplicationType(WebApplicationType.NONE);
        springApplication.setAdditionalProfiles("prod");
        springApplication.setHeadless(true);
        springApplication.run(args);
  1. SpringApplicationBuilder API
        ConfigurableApplicationContext applicationContext =
                new SpringApplicationBuilder(MicroVideoApplication.class)
                        .bannerMode(Banner.Mode.CONSOLE)
                        .web(WebApplicationType.NONE)
                        .profiles("prod")
                        .headless(true)
                        .run(args);
  1. sources
        Set<String> sources = new HashSet<>();
        sources.add(MicroVideoApplication.class.getName());

        SpringApplication springApplication = new SpringApplication();
        springApplication.setWebApplicationType(WebApplicationType.NONE);
        springApplication.setSources(sources);
        springApplication.run(args);

2. 配置 Spring Bean 来源

Java 配置 Class 或 XML 上下文配置文件集合，用于 Spring Boot BeanDefinitionLoader 读取 ，并且将配置源解析加载为 Spring Bean 定义；

  • Java 配置 Class
    用于 Spring 注解驱动中 Java 配置类，大多数情况是 Spring 模式注解所标注的类，如 @Configuration 。
  • XML 上下文配置文件
    用于 Spring 传统配置驱动中的 XML 文件。

3. 推断 Web 应用类型 和 主引导类

根据当前应用 ClassPath 中是否存在相关实现类来推断 Web 应用的类型，包括:

  • Web Reactive: WebApplicationType.REACTIVE
  • Web Servlet: WebApplicationType.SERVLET
  • 非 Web: WebApplicationType.NONE

参考方法: org.springframework.boot.SpringApplication#deduceWebApplicationType

    private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
			"org.springframework.web.context.ConfigurableWebApplicationContext" };

	private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

	private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

	private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

	static WebApplicationType deduceFromClasspath() {
		if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
				&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
			return WebApplicationType.REACTIVE;
		}
		for (String className : SERVLET_INDICATOR_CLASSES) {
			if (!ClassUtils.isPresent(className, null)) {
				return WebApplicationType.NONE;
			}
		}
		return WebApplicationType.SERVLET;
	}

根据 Main 线程执行堆栈判断实际的引导类
参考方法: org.springframework.boot.SpringApplication#deduceMainApplicationClass

	private Class<?> deduceMainApplicationClass() {
		try {
			StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
			for (StackTraceElement stackTraceElement : stackTrace) {
				if ("main".equals(stackTraceElement.getMethodName())) {
					return Class.forName(stackTraceElement.getClassName());
				}
			}
		}
		catch (ClassNotFoundException ex) {
			// Swallow and continue
		}
		return null;
	}

4. 加载 应用上下文初始化器 和 应用事件监听器

  1. 加载应用上下文初始化器

利用 Spring 工厂加载机制，实例化 ApplicationContextInitializer 实现类，并排序对象集合。

  • 实现
	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
		ClassLoader classLoader = getClassLoader();
		// Use names and ensure unique to protect against duplicates
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

org/springframework/boot/spring-boot-autoconfigure/2.1.6.RELEASE/spring-boot-autoconfigure-2.1.6.RELEASE.jar!/META-INF/spring.factories

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

  • 技术

    • 实现类: org.springframework.core.io.support.SpringFactoriesLoader
    • 配置资源: META-INF/spring.factories
    • 排序: AnnotationAwareOrderComparator#sort

  • 实践

package com.example.applicationdemo.context;

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;

public class HelloWorldInitializer<C extends ConfigurableApplicationContext> implements ApplicationContextInitializer<C> {

    @Override
    public void initialize(C applicationContext) {
        applicationContext.setId(System.currentTimeMillis() + "");
        System.out.println(applicationContext);
    }

}

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.applicationdemo.auto.HelloWorldAutoConfiguration


# Initializers
org.springframework.context.ApplicationContextInitializer=\
com.example.applicationdemo.context.HelloWorldInitializer
  1. 加载应用事件监听器

利用 Spring 工厂加载机制，实例化 ApplicationListener 实现类，并排序对象集合

	// ...
	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();

        // 1. 加载应用上下文初始化器
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

        // 2. 加载应用事件监听器
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));


		this.mainApplicationClass = deduceMainApplicationClass();
	}


# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

@Order(LoggingApplicationListener.DEFAULT_ORDER + 1)
public class BackgroundPreinitializer implements ApplicationListener<SpringApplicationEvent> {
    // ...
}

SpringApplication 运行阶段

	public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

1. 加载 SpringApplication 运行监听器(SpringApplicationRunListeners)

利用 Spring 工厂加载机制，读取 SpringApplicationRunListener 对象集合，并且封装到组合类 SpringApplicationRunListeners

SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();

	private SpringApplicationRunListeners getRunListeners(String[] args) {
		Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
		return new SpringApplicationRunListeners(logger,
				getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
	}

org/springframework/boot/spring-boot/2.1.6.RELEASE/spring-boot-2.1.6.RELEASE.jar!/META-INF/spring.factories

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

2. 运行 SpringApplication 运行监听器

在这里插入图片描述

3. 监听 SpringBoot 事件、Spring 事件

Spring Boot 通过 SpringApplicationRunListener 的实现类 EventPublishingRunListener 利用 Spring Framework 事件 API ，广播 Spring Boot 事件。

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

	private final SpringApplication application;

	private final String[] args;

	private final SimpleApplicationEventMulticaster initialMulticaster;

	public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
		for (ApplicationListener<?> listener : application.getListeners()) {
			this.initialMulticaster.addApplicationListener(listener);
		}
	}

	@Override
	public int getOrder() {
		return 0;
	}

	@Override
	public void starting() {
		this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));
	}

	@Override
	public void environmentPrepared(ConfigurableEnvironment environment) {
		this.initialMulticaster
				.multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));
	}

	@Override
	public void contextPrepared(ConfigurableApplicationContext context) {
		this.initialMulticaster
				.multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
	}

	@Override
	public void contextLoaded(ConfigurableApplicationContext context) {
		for (ApplicationListener<?> listener : this.application.getListeners()) {
			if (listener instanceof ApplicationContextAware) {
				((ApplicationContextAware) listener).setApplicationContext(context);
			}
			context.addApplicationListener(listener);
		}
		this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
	}

	@Override
	public void started(ConfigurableApplicationContext context) {
		context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
	}

	@Override
	public void running(ConfigurableApplicationContext context) {
		context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
	}

	@Override
	public void failed(ConfigurableApplicationContext context, Throwable exception) {
		ApplicationFailedEvent event = new ApplicationFailedEvent(this.application, this.args, context, exception);
		if (context != null && context.isActive()) {
			// Listeners have been registered to the application context so we should
			// use it at this point if we can
			context.publishEvent(event);
		}
		else {
			// An inactive context may not have a multicaster so we use our multicaster to
			// call all of the context's listeners instead
			if (context instanceof AbstractApplicationContext) {
				for (ApplicationListener<?> listener : ((AbstractApplicationContext) context)
						.getApplicationListeners()) {
					this.initialMulticaster.addApplicationListener(listener);
				}
			}
			this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
			this.initialMulticaster.multicastEvent(event);
		}
	}

	private static class LoggingErrorHandler implements ErrorHandler {

		private static Log logger = LogFactory.getLog(EventPublishingRunListener.class);

		@Override
		public void handleError(Throwable throwable) {
			logger.warn("Error calling ApplicationEventListener", throwable);
		}

	}

}

EventPublishingRunListener 监听方法与 Spring Boot 事件对应关系

在这里插入图片描述

Spring Framework 事件/监听器编程模型

  • Spring 应用事件
    • 普通应用事件: ApplicationEvent
    • 应用上下文事件: ApplicationContextEvent
  • Spring 应用监听器
    • 接口编程模型: ApplicationListener
    • 注解编程模型: @EventListener
  • Spring 应用事广播器
    • 接口: ApplicationEventMulticaster
    • 实现类: SimpleApplicationEventMulticaster
      • 执行模式:同步或异步

Spring Framework 监听事件

import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class AnnotationBootStrap {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();

        applicationContext.addApplicationListener(event -> {
            System.out.println("监听到事件 ----> " + event);
        });

        applicationContext.refresh();

        applicationContext.publishEvent("Hello Event");
        applicationContext.publishEvent(new ApplicationEvent("Hello ApplicationEvent") {
        });

        applicationContext.close();
    }
}

运行结果：

监听到事件 ----> org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@299a06ac, started on Tue Sep 17 16:51:49 CST 2019]
监听到事件 ----> org.springframework.context.PayloadApplicationEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@299a06ac, started on Tue Sep 17 16:51:49 CST 2019]
监听到事件 ----> com.example.applicationdemo.AnnotationBootStrap$1[source=Hello ApplicationEvent]
监听到事件 ----> org.springframework.context.event.ContextClosedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@299a06ac, started on Tue Sep 17 16:51:49 CST 2019]

自定义 SpringApplicationRunListener

import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {

    public HelloSpringApplicationRunListener(SpringApplication application, String[] args) {

    }

    @Override
    public void starting() {
        System.out.println("HelloSpringApplicationRunListener starting");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        System.out.println("HelloSpringApplicationRunListener environmentPrepared");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("HelloSpringApplicationRunListener contextPrepared");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("HelloSpringApplicationRunListener contextLoaded");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("HelloSpringApplicationRunListener started");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("HelloSpringApplicationRunListener running");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("HelloSpringApplicationRunListener failed");
    }
}


# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
com.example.applicationdemo.listener.HelloSpringApplicationRunListener

测试

    public static void main(String[] args) {
        new SpringApplicationBuilder(MicroVideoApplication.class)
                .bannerMode(Banner.Mode.CONSOLE)
                .web(WebApplicationType.NONE)
                .profiles("prod")
                .headless(true)
                .run(args);
    }

运行结果：

HelloSpringApplicationRunListener starting
HelloSpringApplicationRunListener environmentPrepared

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.1.6.RELEASE)

org.springframework.context.annotation.AnnotationConfigApplicationContext@4c40b76e, started on Thu Jan 01 08:00:00 CST 1970
HelloSpringApplicationRunListener contextPrepared
2019-09-17 17:06:07.365  INFO 16443 --- [           main] c.e.a.MicroVideoApplication              : Starting MicroVideoApplication on kevindeMacBook-Pro.local with PID 16443 (/Users/kevin/Documents/idea-project/application-demo/target/classes started by kevin in /Users/kevin/Documents/idea-project/application-demo)
2019-09-17 17:06:07.369  INFO 16443 --- [           main] c.e.a.MicroVideoApplication              : The following profiles are active: prod
HelloSpringApplicationRunListener contextLoaded
2019-09-17 17:06:08.508  INFO 16443 --- [           main] c.e.a.MicroVideoApplication              : Started MicroVideoApplication in 1.444 seconds (JVM running for 2.115)
HelloSpringApplicationRunListener started
HelloSpringApplicationRunListener running

Process finished with exit code 0

监听 SpringBoot 事件

import org.springframework.boot.context.config.ConfigFileApplicationListener;
import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;
import org.springframework.boot.context.event.ApplicationPreparedEvent;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.SmartApplicationListener;
import org.springframework.core.Ordered;
import org.springframework.core.env.Environment;

public class MyApplicationListener implements SmartApplicationListener, Ordered {

    @Override
    public int getOrder() { // 值越小 优先级越高
        return ConfigFileApplicationListener.DEFAULT_ORDER + 1;
    }

    @Override
    public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
        return ApplicationEnvironmentPreparedEvent.class.isAssignableFrom(eventType)
                || ApplicationPreparedEvent.class.isAssignableFrom(eventType);
    }

    @Override
    public boolean supportsSourceType(Class<?> aClass) {
        return true;
    }

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationEnvironmentPreparedEvent) {
            ApplicationEnvironmentPreparedEvent preparedEvent = (ApplicationEnvironmentPreparedEvent) event;
            Environment environment = preparedEvent.getEnvironment();
            System.out.println("environment.getProperty(\"name\") : " + environment.getProperty("name"));
        }
        if (event instanceof ApplicationPreparedEvent) {
        }
    }
}

# ApplicationListener 实现配置
org.springframework.context.ApplicationListener=\
com.example.applicationdemo.listener.MyApplicationListener

4. 创建 应用上下文 和 Environment

  1. 创建 应用上下文（ConfigurableApplicationContext）

根据准备阶段的推断 Web 应用类型创建对应的 ConfigurableApplicationContext 实例:

  • Web Reactive: AnnotationConfigReactiveWebServerApplicationContext
  • Web Servlet: AnnotationConfigServletWebServerApplicationContext
  • 非 Web: AnnotationConfigApplicationContext
    try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

            // 创建 Environment
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);

            // 创建 应用上下文
			context = createApplicationContext();

			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

	public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
			+ "annotation.AnnotationConfigApplicationContext";

	public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
			+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";

	public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
			+ "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";
    
	protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				switch (this.webApplicationType) {
				case SERVLET:
					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
					break;
				case REACTIVE:
					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
					break;
				default:
					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
				}
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}
  1. 创建 Environment

根据准备阶段的推断 Web 应用类型创建对应的 ConfigurableEnvironment 实例:

  • Web Reactive: StandardReactiveWebEnvironment
  • Web Servlet: StandardServletEnvironment
  • 非 Web: StandardEnvironment
	private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		listeners.environmentPrepared(environment);
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
					deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

	private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		switch (this.webApplicationType) {
		case SERVLET:
			return new StandardServletEnvironment();
		case REACTIVE:
			return new StandardReactiveWebEnvironment();
		default:
			return new StandardEnvironment();
		}
	}

测试

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext =
                new SpringApplicationBuilder(MicroVideoApplication.class)
                        .web(WebApplicationType.NONE)
                        .run(args);

        System.out.println(applicationContext.getClass().getName());
        System.out.println(applicationContext.getEnvironment().getClass().getName());
        applicationContext.close();
    }

5. 失败故障分析报告

6. 回调 CommandLineRunner、ApplicationRunner

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MicroVideoApplication implements CommandLineRunner {

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

    @Override
    public void run(String... args) throws Exception {
        System.out.println("启动成功");
    }
}
morningcat2018
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot系列5，SpringApplication运行阶段
耗子窝
02-09 292
对于SpringApplication准备阶段，实际上就是构造对象阶段，而运行阶段，就是.run。 对于运行阶段的运行流程： 1.加载SpringApplication运行监听器（SpringApplicationRunListeners） 利用spring工厂加载机制，读取SpringApplicationRunListener对象集合，并封装到组合类SpringApplicationRu...
Spring Boot 2.0深度实践之核心技术篇
04-21
《Spring Boot 2.0深度实践之核心技术篇》是一份深入探索Spring Boot 2.0核心功能和技术的教程，旨在帮助开发者充分利用这个流行的Java开发框架，提升开发效率和项目质量。Spring Boot以其“开箱即用”的特性，简化...
SpringBoot的启动方式，以及SpringApplicationBuilder
qq_51778285的博客
08-05 6897
今天在翻阅代码的时候，在主启动类偶然看见了SpringApplicationBuilder这样的代码，我也是第一次接触，对SpringApplicationBuilder的作用感到好奇 查阅了一些资料，明白了它的作用，首先SpringBoot的启动方式，大家都很了解了 但这类方式启动会有一个问题，那就是它默认的读取配置文件用的是application.yml或者application.properties，这就会导致，如果一个项目中有多个配置文件，比如需要配置测试环境，线上环境，运行
SpringApplicationBuilder
底层码农
09-19 2万+
SpringApplicationBuilder
深入学习Spring Boot中的SpringApplication
一只倔强的蜗牛的博客
09-15 1684
在Spring Boot的入口类中，我们通常是通过调用SpringApplication的run方法来启动Spring Boot项目。这节我们来深入学习下SpringApplication的一些细节。 自定义SpringApplication 默认的我们都是直接通过SpringApplication的run方法来直接启动Spring Boot，其实我们可以通过一些API来调整某些行为。 通过...
Spring Boot源码（二） - SpringApplication的run方法
it_lihongmin的博客
06-20 1088
Spring Boot在执行SpringApplication的run方法之前，其实在构造函数中已经完成了很多初始化的准备操作，并且在run方法之前我们可以配置很多信息（上一篇博客中分析了很多的字段都是有Setter的）。比如我们可以将代码写作如下：
Learning-Spring-Boot-2.0-Second-Edition:Packt出版的Learning Spring Boot 2.0，第二版
05-28
学习Spring Boot 2.0-第二版 这是发布的的代码存储库。 它包含从头到尾完成本书所必需的所有支持项目文件。 关于这本书 Spring Boot提供了多种功能，可满足当今的业务需求以及当今的可扩展需求。 在本书中，您将学习...
Spring-Boot-2.0-Cookbook-Second-Edition:Spring Boot 2.0 Cookbook-第二版，由Packt发行
05-28
Spring Boot 2.0食谱-第二版 这是发布的的代码库。 它包含从头到尾完成本书所必需的所有支持项目文件。 关于这本书 该实用指南使现有的开发过程更加有效。 Spring Boot Cookbook 2.0 Second Edition巧妙地结合了所有...
Hands-On-Full-Stack-Development-with-Spring-Boot-2.0-and-React:使用 Spring 5 和 React 进行全栈开发，由 Packt 发布
08-05
使用 Spring Boot 2.0 和 React 进行全栈开发 这是的代码库，由 Packt 发布。 使用基于 Java 的 Spring Framework 5.0 和 React 构建现代且可扩展的全栈应用程序这本书是关于什么的？ 全栈工程师除了知道如何编写...
Java寻秦源码文本-Spring-Boot-2.0:Spring-Boot-2.0
06-11
#Spring-Boot-2.0-Samples 欢迎购买本书《Spring Boot 2精髓：从构建小系统到架构分布式大系统》 各大书店，各大网站均有销售。 关于本书的更多说明，可以访问ibeetl.com官网 本书源码地址是： 依据本书技术栈实现的...
springboot学习7
coffeesunshine的博客
02-06 169
SpringApplication： 1、SpringApplication基本使用： 1.1 SpringApplication运行 SpringApplication.run(DemoSpringBootApplication.class, args) 1.2、自定义SpringApplication 1）通过SpringApplicationAPI 方式 SpringApplication springApplication = new SpringApplication(DemoSpringBoo
CONDITIONS EVALUATION REPORT
热门推荐
weixin_44021888的博客
09-11 5万+
CONDITIONS EVALUATION REPORT spring boot 项目显示：CONDITIONS EVALUATION REPORT 原因：日志配置了level的属性 解决办法： 在配置文件application.yml或者application.properties文件中加入： logging.level.org.springframework.boot.autoconfig...
springBoot特性整理(基础版)
weixin_41419401的博客
06-09 336
1、自定义SpringApplication 自定义bannnr public static void main(String[] args){ SpringApplication app = new SpringApplication(MySpringConfiguration.class); app.setShowBanner(false); app.run(args); }
SpringBoot2原理---SpringApplication的执行流程
MissOfSpring的博客
09-17 609
SpringBoot2原理—SpringApplication的run方法 由于在Spring Boot的入口类中，我们通常是通过调用SpringApplication的run方法来启动Spring Boot项目。这节我们来深入学习下SpringApplication的一些细节。 1.自定义SpringApplication 默认的我们都是直接通过SpringApplication的run方法来直...
【springboot高级】（四：自定义初始化器，实现ApplicationContextInitializer「ConfigurableApplicationContext」设置必须配置的属性）
CoderOu
07-03 756
在我们自定义启动器之自动装配的时候，有些属性需要进行配置，但是如果不配置的话，可能会引起系统异常。 那么这个时候我们就需要设置一些属性必须配置，在系统初始化的时候就应该进行检查，而不是等系统运行起来，运行到需要那个配置的时候在检查就来不及了。 那么今天我们通过自定义系统初始化器来进行实现： 详细的自定义系统初始化器请看【springboot高级】（一：自定义容器初始化器的三种方式，实现ApplicationContextInitializer接口。（使用篇）） 同时如果想看springboot实现的源码的，
理解SpringApplication
仰望星空
07-25 1万+
前言:这是在慕课网上学习Spring Boot2.0深度实践之核心技术篇 时所做的笔记,主要供本人复习之用。 目录 第一章 概要 1.1 基本使用 1.1.1 直接运行 1.1.2 自定义 1.2 用到的基础技术 1.3 用到的扩展衍生技术 第二章 SpringApplication的准备阶段 2.1 配置SpringBean的来源 2.2 推断Web应用类型 2.3 推断引...
springboot2启动信息去除CONDITIONS EVALUATION REPORT后引发的思考
AlbenXie的博客
03-02 2775
前言 最近启动一个springboot2.2+版本项目时，发现控制台输出 17:22:05 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.cloud.util.random.CachedRandomPropertySourceAutoConfiguration' 17:22:05 [main] DEBUG o.s.b.
springboot 设置web和非web启动
u012903200的博客
12-24 2万+
springBoot区分web和非web项目 老版本： #server config #web_environment是否是web项目 spring.main.web_environment=true #是否加载springboot banner spring.main.show_banner=false 现版本： #server config #是否设定web应用，none-非web，ser...
Springboot内置ApplicationContextInitializer--ConditionEvaluationReportLoggingListener
Details Inside Spring
11-23 7758
源码分析 本文代码基于 Springboot 2.1.0 package org.springframework.boot.autoconfigure.logging; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework...
spring-boot-starter-aop和spring-boot-starter-parent的区别
最新发布
03-17
spring-boot-starter-aop和spring-boot-starter-parent是Spring Boot框架的两个重要组件，它们有以下区别： 1. spring-boot-starter-aop： - spring-boot-starter-aop是一个用于支持面向切面编程（AOP）的Spring ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值