springboot启动之-本地配置(一)

已于 2024-06-06 21:06:37 修改
阅读量370 收藏 1
点赞数 12
文章标签： spring boot java spring
于 2024-06-06 07:51:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z2802533142/article/details/139454548
版权

没有前言，只有源码~~ ，依然是最简单的依赖

plugins {
	id 'java'
	id 'org.springframework.boot' version '3.3.0'
	id 'io.spring.dependency-management' version '1.1.5'
}
java {
	sourceCompatibility = '17'
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter'
}

EnvironmentPostProcessorApplicationListener怎么来的

	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();
		this.bootstrapRegistryInitializers = new ArrayList<>(
				getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		// 扫描spring.factories文件拿到 ApplicationListener的子类  
		// 放入private List<ApplicationListener<?>> listeners;属性
		// 这里差点漏了
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

环境类
这里要注意实例化 EnvironmentPostProcessorApplicationListener 的时候 它的postProcessorsFactory = SpringFactoriesEnvironmentPostProcessorsFactory 后面用的到

	public EnvironmentPostProcessorApplicationListener() {
		this(EnvironmentPostProcessorsFactory::fromSpringFactories);
	}

	private EnvironmentPostProcessorApplicationListener(
			Function<ClassLoader, EnvironmentPostProcessorsFactory> postProcessorsFactory) {
		this.postProcessorsFactory = postProcessorsFactory;
		this.deferredLogs = new DeferredLogs();
	}

	static EnvironmentPostProcessorsFactory fromSpringFactories(ClassLoader classLoader) {
		return new SpringFactoriesEnvironmentPostProcessorsFactory(
			SpringFactoriesLoader.forDefaultResourceLocation(classLoader));
	}

SpringApplicationRunListener怎么来的

public ConfigurableApplicationContext run(String... args) {
		Startup startup = Startup.create();
		if (this.registerShutdownHook) {
			SpringApplication.shutdownHook.enableShutdownHookAddition();
		}
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		// 配置从这一行开始看
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		// 入口应该是这里注意 listeners 被传入了
		ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
		Banner printedBanner = printBanner(environment);
		context = createApplicationContext();
	}

	private SpringApplicationRunListeners getRunListeners(String[] args) {
		ArgumentResolver argumentResolver = ArgumentResolver.of(SpringApplication.class, this);
		argumentResolver = argumentResolver.and(String[].class, args);
		// 获取监听器，随处可见的spi
		List<SpringApplicationRunListener> listeners = getSpringFactoriesInstances(SpringApplicationRunListener.class,
				argumentResolver);
		SpringApplicationHook hook = applicationHook.get();
		SpringApplicationRunListener hookListener = (hook != null) ? hook.getRunListener(this) : null;
		if (hookListener != null) {
			listeners = new ArrayList<>(listeners);
			listeners.add(hookListener);
		}
		return new SpringApplicationRunListeners(logger, listeners, this.applicationStartup);
	}

这个方法目前就获取了一个SpringApplicationRunListener
监听器

开始找配置application.yaml

进入org.springframework.boot.SpringApplication#prepareEnvironment

	private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		ConfigurationPropertySources.attach(environment);
		// 关键看这一行
		listeners.environmentPrepared(bootstrapContext, environment);
		DefaultPropertiesPropertySource.moveToEnd(environment);
		Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
				"Environment prefix cannot be set via properties.");
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
			environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

	void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
		doWithListeners("spring.boot.application.environment-prepared",
				(listener) -> listener.environmentPrepared(bootstrapContext, environment));
	}

这个方法干了什么，也就是循环使用前面获得的listener调用environmentPrepared方法，刚刚也看到了目前就一个也就是org.springframework.boot.context.event.EventPublishingRunListener

	@Override
	public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
			ConfigurableEnvironment environment) {
		multicastInitialEvent(
				// 注意事件类是 ApplicationEnvironmentPreparedEvent
				new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
	}

注意这里传递了ApplicationEnvironmentPreparedEvent事件

	EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
	}

在实例化EventPublishingRunListener的时候，指定了initialMulticaster 为SimpleApplicationEventMulticaster
进入SimpleApplicationEventMulticaster的multicastEvent方法

	private void multicastInitialEvent(ApplicationEvent event) {
		// 注意这个方法补充了一些listeners到 SimpleApplicationEventMulticaster
		// 的  Set<ApplicationListener<?>> defaultRetriever.applicationListeners
		refreshApplicationListeners();
		this.initialMulticaster.multicastEvent(event);
	}

	@Override
	public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : ResolvableType.forInstance(event));
		Executor executor = getTaskExecutor();
		// 循环 ApplicationListener 子类 invokeListener方法 让所有的listener去调用 onApplicationEvent(event);
		// 这里就用到EnvironmentPostProcessorApplicationListener
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			if (executor != null && listener.supportsAsyncExecution()) {
				try {
					executor.execute(() -> invokeListener(listener, event));
				}
				catch (RejectedExecutionException ex) {
					// Probably on shutdown -> invoke listener locally instead
					invokeListener(listener, event);
				}
			}
			else {
				invokeListener(listener, event);
			}
		}
	}
/*
这里要描述一下 getApplicationListeners(event, type) 如何得到 EnvironmentPostProcessorApplicationListener
不然莫名奇妙。
首先这个类来自 AbstractApplicationEventMulticaster 的 defaultRetriever属性的 applicationListeners 属性
而SimpleApplicationEventMulticaster是它的子类。
找一下applicationListeners 的add()方法调用位置，索性只有一个地方那就是AbstractApplicationEventMulticaster#addApplicationListener  方法，
加个断点就可以看到所有添加进来的listeners了，可以看到它是refreshApplicationListeners()来的,看这个方法发现listener来自
SpringApplication 的 List<ApplicationListener<?>> listeners;
listeners 什么时候添加的这个类呢，看本文开始

*/

其中有一个listener 为 EnvironmentPostProcessorApplicationListener
再进入org.springframework.boot.env.EnvironmentPostProcessorApplicationListener#onApplicationEvent

	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		if (event instanceof ApplicationEnvironmentPreparedEvent environmentPreparedEvent) {
			// 判断事件
			onApplicationEnvironmentPreparedEvent(environmentPreparedEvent);
		}
		if (event instanceof ApplicationPreparedEvent) {
			onApplicationPreparedEvent();
		}
		if (event instanceof ApplicationFailedEvent) {
			onApplicationFailedEvent();
		}
	}

	private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
		ConfigurableEnvironment environment = event.getEnvironment();
		SpringApplication application = event.getSpringApplication();
		// ConfigDataEnvironmentPostProcessor又是怎么来的，看下面注释
		for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
				event.getBootstrapContext())) {
			// postProcessor = ConfigDataEnvironmentPostProcessor的时候
			postProcessor.postProcessEnvironment(environment, application);
		}
	}

ConfigDataEnvironmentPostProcessor哪里来的？spi还是spi

	List<EnvironmentPostProcessor> getEnvironmentPostProcessors(ResourceLoader resourceLoader,
			ConfigurableBootstrapContext bootstrapContext) {
		ClassLoader classLoader = (resourceLoader != null) ? resourceLoader.getClassLoader() : null;
		EnvironmentPostProcessorsFactory postProcessorsFactory = this.postProcessorsFactory.apply(classLoader);
		// 前面讲到了  postProcessorsFactory = SpringFactoriesEnvironmentPostProcessorsFactory
		return postProcessorsFactory.getEnvironmentPostProcessors(this.deferredLogs, bootstrapContext);
	}

class SpringFactoriesEnvironmentPostProcessorsFactory implements EnvironmentPostProcessorsFactory {

	private final SpringFactoriesLoader loader;

	SpringFactoriesEnvironmentPostProcessorsFactory(SpringFactoriesLoader loader) {
		this.loader = loader;
	}

	@Override
	public List<EnvironmentPostProcessor> getEnvironmentPostProcessors(DeferredLogFactory logFactory,
			ConfigurableBootstrapContext bootstrapContext) {
		ArgumentResolver argumentResolver = ArgumentResolver.of(DeferredLogFactory.class, logFactory);
		argumentResolver = argumentResolver.and(ConfigurableBootstrapContext.class, bootstrapContext);
		argumentResolver = argumentResolver.and(BootstrapContext.class, bootstrapContext);
		argumentResolver = argumentResolver.and(BootstrapRegistry.class, bootstrapContext);
		// SpringFactoriesLoader 
		return this.loader.load(EnvironmentPostProcessor.class, argumentResolver);
	}

}

无尽的spi

进入 ConfigDataEnvironmentPostProcessor#postProcessEnvironment

	void postProcessEnvironment(ConfigurableEnvironment environment, ResourceLoader resourceLoader,
			Collection<String> additionalProfiles) {
		this.logger.trace("Post-processing environment to add config data");
		resourceLoader = (resourceLoader != null) ? resourceLoader : new DefaultResourceLoader();
		// 得到 ConfigDataEnvironment 实例 走processAndApply方法
		getConfigDataEnvironment(environment, resourceLoader, additionalProfiles).processAndApply();
	}

	ConfigDataEnvironment getConfigDataEnvironment(ConfigurableEnvironment environment, ResourceLoader resourceLoader,
			Collection<String> additionalProfiles) {
		return new ConfigDataEnvironment(this.logFactory, this.bootstrapContext, environment, resourceLoader,
				additionalProfiles, this.environmentUpdateListener);
	}

继续走 ConfigDataEnvironment#processAndApply

	void processAndApply() {
		ConfigDataImporter importer = new ConfigDataImporter(this.logFactory, this.notFoundAction, this.resolvers,
				this.loaders);
		registerBootstrapBinder(this.contributors, null, DENY_INACTIVE_BINDING);
		// 看这里
		ConfigDataEnvironmentContributors contributors = processInitial(this.contributors, importer);
		ConfigDataActivationContext activationContext = createActivationContext(
				contributors.getBinder(null, BinderOption.FAIL_ON_BIND_TO_INACTIVE_SOURCE));
		contributors = processWithoutProfiles(contributors, importer, activationContext);
		activationContext = withProfiles(contributors, activationContext);
		contributors = processWithProfiles(contributors, importer, activationContext);
		applyToEnvironment(contributors, activationContext, importer.getLoadedLocations(),
				importer.getOptionalLocations());
	}

	private ConfigDataEnvironmentContributors processInitial(ConfigDataEnvironmentContributors contributors,
			ConfigDataImporter importer) {
		this.logger.trace("Processing initial config data environment contributors without activation context");
		// 看这里
		contributors = contributors.withProcessedImports(importer, null);
		registerBootstrapBinder(contributors, null, DENY_INACTIVE_BINDING);
		return contributors;
	}

继续，不要停

ConfigDataEnvironmentContributors withProcessedImports(ConfigDataImporter importer,
			ConfigDataActivationContext activationContext) {
		ImportPhase importPhase = ImportPhase.get(activationContext);
		this.logger.trace(LogMessage.format("Processing imports for phase %s. %s", importPhase,
				(activationContext != null) ? activationContext : "no activation context"));
		ConfigDataEnvironmentContributors result = this;
		int processed = 0;
		while (true) {
			ConfigDataEnvironmentContributor contributor = getNextToProcess(result, activationContext, importPhase);
			if (contributor == null) {
				this.logger.trace(LogMessage.format("Processed imports for of %d contributors", processed));
				return result;
			}
			if (contributor.getKind() == Kind.UNBOUND_IMPORT) {
				ConfigDataEnvironmentContributor bound = contributor.withBoundProperties(result, activationContext);
				result = new ConfigDataEnvironmentContributors(this.logger, this.bootstrapContext,
						result.getRoot().withReplacement(contributor, bound), this.conversionService);
				continue;
			}
			ConfigDataLocationResolverContext locationResolverContext = new ContributorConfigDataLocationResolverContext(
					result, contributor, activationContext);
			ConfigDataLoaderContext loaderContext = new ContributorDataLoaderContext(this);
			List<ConfigDataLocation> imports = contributor.getImports();
			this.logger.trace(LogMessage.format("Processing imports %s", imports));
			// 看这里
			Map<ConfigDataResolutionResult, ConfigData> imported = importer.resolveAndLoad(activationContext,
					locationResolverContext, loaderContext, imports);
			this.logger.trace(LogMessage.of(() -> getImportedMessage(imported.keySet())));
			ConfigDataEnvironmentContributor contributorAndChildren = contributor.withChildren(importPhase,
					asContributors(imported));
			result = new ConfigDataEnvironmentContributors(this.logger, this.bootstrapContext,
					result.getRoot().withReplacement(contributor, contributorAndChildren), this.conversionService);
			processed++;
		}
	}

	Map<ConfigDataResolutionResult, ConfigData> resolveAndLoad(ConfigDataActivationContext activationContext,
			ConfigDataLocationResolverContext locationResolverContext, ConfigDataLoaderContext loaderContext,
			List<ConfigDataLocation> locations) {
		try {
			Profiles profiles = (activationContext != null) ? activationContext.getProfiles() : null;
			List<ConfigDataResolutionResult> resolved = resolve(locationResolverContext, profiles, locations);
			// load方法
			return load(loaderContext, resolved);
		}
		catch (IOException ex) {
			throw new IllegalStateException("IO error on loading imports from " + locations, ex);
		}
	}

渐入佳境

	private Map<ConfigDataResolutionResult, ConfigData> load(ConfigDataLoaderContext loaderContext,
			List<ConfigDataResolutionResult> candidates) throws IOException {
		Map<ConfigDataResolutionResult, ConfigData> result = new LinkedHashMap<>();
		for (int i = candidates.size() - 1; i >= 0; i--) {
			ConfigDataResolutionResult candidate = candidates.get(i);
			ConfigDataLocation location = candidate.getLocation();
			ConfigDataResource resource = candidate.getResource();
			this.logger.trace(LogMessage.format("Considering resource %s from location %s", resource, location));
			if (resource.isOptional()) {
				this.optionalLocations.add(location);
			}
			if (this.loaded.contains(resource)) {
				this.logger
					.trace(LogMessage.format("Already loaded resource %s ignoring location %s", resource, location));
				this.loadedLocations.add(location);
			}
			else {
				try {
					// 看这里
					ConfigData loaded = this.loaders.load(loaderContext, resource);
					if (loaded != null) {
						this.logger.trace(LogMessage.format("Loaded resource %s from location %s", resource, location));
						this.loaded.add(resource);
						this.loadedLocations.add(location);
						result.put(candidate, loaded);
					}
				}
				catch (ConfigDataNotFoundException ex) {
					handle(ex, location, resource);
				}
			}
		}
		return Collections.unmodifiableMap(result);
	}

public class StandardConfigDataLoader implements ConfigDataLoader<StandardConfigDataResource> {

	private static final PropertySourceOptions PROFILE_SPECIFIC = PropertySourceOptions.always(Option.PROFILE_SPECIFIC);

	private static final PropertySourceOptions NON_PROFILE_SPECIFIC = PropertySourceOptions.ALWAYS_NONE;

	@Override
	public ConfigData load(ConfigDataLoaderContext context, StandardConfigDataResource resource)
			throws IOException, ConfigDataNotFoundException {
		if (resource.isEmptyDirectory()) {
			return ConfigData.EMPTY;
		}
		ConfigDataResourceNotFoundException.throwIfDoesNotExist(resource, resource.getResource());
		StandardConfigDataReference reference = resource.getReference();
		Resource originTrackedResource = OriginTrackedResource.of(resource.getResource(),
				Origin.from(reference.getConfigDataLocation()));
		String name = String.format("Config resource '%s' via location '%s'", resource,
				reference.getConfigDataLocation());
		// 走这里
		List<PropertySource<?>> propertySources = reference.getPropertySourceLoader().load(name, originTrackedResource);
		PropertySourceOptions options = (resource.getProfile() != null) ? PROFILE_SPECIFIC : NON_PROFILE_SPECIFIC;
		return new ConfigData(propertySources, options);
	}

}

public class YamlPropertySourceLoader implements PropertySourceLoader {

	@Override
	public String[] getFileExtensions() {
		return new String[] { "yml", "yaml" };
	}

	@Override
	public List<PropertySource<?>> load(String name, Resource resource) throws IOException {
		if (!ClassUtils.isPresent("org.yaml.snakeyaml.Yaml", getClass().getClassLoader())) {
			throw new IllegalStateException(
					"Attempted to load " + name + " but snakeyaml was not found on the classpath");
		}
		// resource是什么，就是application.yaml,看它如何将application.yaml文件解析成Map
		List<Map<String, Object>> loaded = new OriginTrackedYamlLoader(resource).load();
		if (loaded.isEmpty()) {
			return Collections.emptyList();
		}
		List<PropertySource<?>> propertySources = new ArrayList<>(loaded.size());
		for (int i = 0; i < loaded.size(); i++) {
			String documentNumber = (loaded.size() != 1) ? " (document #" + i + ")" : "";
			propertySources.add(new OriginTrackedMapPropertySource(name + documentNumber,
					Collections.unmodifiableMap(loaded.get(i)), true));
		}
		return propertySources;
	}

}

最终进入 org.springframework.beans.factory.config.YamlProcessor#process(org.springframework.beans.factory.config.YamlProcessor.MatchCallback, org.yaml.snakeyaml.Yaml, org.springframework.core.io.Resource)

演示配置

yaml解析器

懒眉
关注
  • 12
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Spring Boot 项目启动的七种方式
田维常
04-15 3964
上一节中，我们讲了创建Spring Boot项目的几种方式，本文我们就来聊聊Spring Boot项目启动的7种方式。 本节的目标：掌握Spring Boot项目启动的7种方式 第一种 也是最常见的本地启动的一种，我们直接在IDEA编辑器中启动。 @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoAppli
spring boot 启动
AAAAA118的博客
05-17 4735
springboot启动流程主要分为三个部分： 第一部分进行SpringApplication的初始化模块，配置一些基本的环境变量、资源、构造器、监听器， 第二部分实现了应用具体的启动方案，包括启动流程的监听模块、加载配置环境模块、及核心的创建上下文环境模块， 第三部分是自动化配置模块，该模块作为springboot自动配置核心，在后面的分析中会详细讨论。在下面的启动程序中我们会串联起结构中的主要功能。 每个SpringBoot程序都有一个主入口，也就是main方法，main里面调用Sprin.
SpringBoot启动方式
JAVA技术博客
09-17 524
springboot的启动经过了一些一系列的处理，我们先看看整体过程的流程图SpringBoot的启动方式@EnableAutoConfiguration 作用开启自动装配，帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot，并创建对应配置类的Bean，并把该Bean实体交给IoC容器进行管理。新建文件 IndexController.java@ComponentScan() 注解作用。
本地启动一个SpringBoot项目
Janna_woo的博客
06-08 668
【代码】本地启动一个SpringBoot项目。
git clone 一个 SpringBoot 项目，如何在本地运行?
rain67的博客
03-19 2589
点击apply、ok。
Redission分布式锁-本地单机Redis实战-springboot-redis-lock.zip
最新发布
01-31
在这种模式下，开发者可以在本地启动一个Redis服务器，模拟分布式环境，验证锁的正确性。 6. **SpringBoot应用结构**：SpringBoot项目通常包含pom.xml（Maven）或build.gradle（Gradle）文件管理依赖，src/main/...
springboot整合etcd配置中心-etcd-config-spring-boot.zip
11-06
在现代微服务架构中，配置管理是一个至关重要的环节。Spring Boot作为Java开发的热门框架，提供了简化配置的机制。而Etcd是一款分布式键值存储系统，常被用作配置中心，提供高可用、强一致性的配置管理解决方案。...
springboot整合sharding-jdbc完整代码
05-14
SpringBoot整合Sharding-JDBC是将Sharding-JDBC这一分布式数据库中间件与SpringBoot框架结合，以实现数据分片、读写分离等高级数据库管理功能。这个完整的代码示例覆盖了Sharding-JDBC的主要技术点，使开发者可以...
springboot_project-master_honor7gn_springboot简单实战后端代码_discoverqu
10-04
SpringBoot 是一个由 Pivotal 团队开发的框架，旨在简化 Spring 应用程序的初始搭建以及开发过程。它集成了大量常用的第三方库配置，如 JDBC、MongoDB、JPA、RabbitMQ、Quartz 等，使得开发者能够快速地创建一个独立...
springbootprofile-dio：Springboot配置文件-示例
02-14
数字创新：Aula-Spring启动：配置文件和配置Nesta aula explicamos e detalhamos como funciona o uso do recurso de Profiles。 推荐，执行和执行的环境对象：本地，teste，produção等。 杜randint（Durante）...
SpringBoot启动程序方式（服务器启动SpringBoot）
小流至江河的博客
08-26 1389
概述 使用SpringBoot框架的方便之处就不谈了，今天介绍下SpringBoot的几种启动方式和在生产环境应该如何启动。 一、通过IDE工具（开发阶段） 通过IDE工具（Eclipse、IDEA等）运行启动类的main方法（适合开发阶段使用），第一种方法应该是同学们最熟悉的方式了，启动起来也是最容易的，只要点击运行按钮就ok，不做详细介绍了，会Java的都懂。 @SpringBo...
9千字长文带你了解SpringBoot启动过程--史上最详细 SpringBoot启动流程-图文并茂
叶新东老师的博客
06-14 1万+
SpringBoot springboot是依赖于spring的，bi'qi
HC物业系统-springboot版本本地环境部署启动
cralchan的博客
08-15 717
最后在网址中输入：http://localhost:3000 即可访springboot版本HC物业系统啦！前端代码：git https://gitee.com/java110/WechatOwnerService.git。后端代码 ： git https://gitee.com/wuxw7/MicroCommunity.git。两处更改数据地址（我把两个数据库文件合并了，所以两个库地址是一样的）直接使用代码中文件即可（我是导入一个库中，也可以分开导入）...
Springboot非web项目启动（本地）
z69183787的专栏
04-05 3078
无
SpringBoot本地化配置
ja.rome
08-12 1842
SpringBoot本地化配置 前提概要 相信做过Spring项目的同学应该对下面一行代码比较熟悉： &amp;lt;bean class=&quot;org.springframework.beans.factory.config.PropertyPlaceholderConfigurer&quot;&amp;gt; &amp;lt;property name=&quot;systemPropertiesModeNam...
springboot启动方式
m0_67394002的博客
04-26 585
第一种（本地开发使用） 在项目的根目录下有一个带有main函数的Application类，可以直接执行这个main函数。（使用的是SpringBoot内置的tomcat） 第二种（本地开发使用） 在pom文件中配置使用启动SpringBoot的maven插件。配置如下 启动的使用可以使用mvn spring-boot:run启动，我用的是IDEA的maven插件 第三种（线上部署使用）也就是使用spring boot内置的tomcat运行 使用maven工具打包（jar包），打包时要注意，由于模块与模
Spring Boot 读取配置文件的几种方式
DingSJ 的博客
10-14 12万+
Spring Boot 读取配置文件的方式可以分为 1. 注解 2. 获取 Spring Boot 的环境变量 来获取配置文件的信息，其中注解的方式又有集中表现形式。第一步：创建 Spring Boot 工程（ Maven 工程添加 Spring Boot 相应的依赖）。 现在我们只是测试 Spring Boot 的 配置文件的读取，不需要其他的依赖，所以什么都没选，直接下一步
Springboot——最简单详细的配置
Hongcj的博客
06-07 3万+
首先，我们得知道Springboot是什么？Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。用我的话来理解，就是spring boot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了...
SpringBoot项目运行jar包启动
热门推荐
code_monkey的博客
09-14 31万+
人工智能，零基础入门！http://www.captainbed.net/inner SpringBoot项目在开发中，方便快捷，有一点原因就是SpringBoot项目可以打jar包运行：把jar包直接扔服务器上，然后运行jar包就能访问项目接口了。下面介绍SpringBoot项目打jar包运行的步骤流程： 一、我们所熟悉的是在开发环境下，直接用开发工具来运行那个启动类，然后就能启动这个项...
springboot启动后怎么通过localhost访问本地文件夹
03-31
2. 在Spring Boot应用程序的配置文件（application.properties或application.yml）中添加以下配置： ``` spring.resources.static-locations=file:C:/myfiles/ ``` 3. 在应用程序中创建一个控制器，例如： ``` @...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

懒眉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值