Springboot启动配置原理/20190402---03---68/69/70/71(没学)

最新推荐文章于 2024-09-06 16:43:35 发布
原创 最新推荐文章于 2024-09-06 16:43:35 发布 · 437 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

 

主要讲启动原理 运行流程 启动配置原理 作为我springboot结课的最后一篇博客

github地址：https://github.com/FandyWw/spring-boot-07

运行这个：点进去run。

第一步创建SpringApplication对象

        调用initialize方法。

       

            

private void initialize(Object[] sources) {
        //第一步保存主配置类
		if (sources != null && sources.length > 0) {
			this.sources.addAll(Arrays.asList(sources));
		}
        //第二步决定是不是web应用
		this.webEnvironment = deduceWebEnvironment();
        //第三步实际上就是赋值 主要看getSpringFactoriesInstances方法
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
        //第四步还是啊找，此时是找listener
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

             注意看这个流程里面做了什么事情。

             加载保存主配置类

            第2步：

            判断当前的应用是不是web应用

           第3步的核心方法是：getSpringFactoriesInstances，点进去。

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

   上面的loadFactoryNames，点进去。

 public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();

        try {
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            ArrayList result = new ArrayList();

            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
                String factoryClassNames = properties.getProperty(factoryClassName);
                result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
            }

            return result;
        } catch (IOException var8) {
            throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() + "] factories from location [" + "META-INF/spring.factories" + "]", var8);
        }
    }

      实际上就是从，类路径下META-INF/spring.factories找到配置的所有的ApplicationContextInitializer，保存起来。

       就在这里面：

             

      好多包都有这个的，接下来还是从类路径下找

        最后一步：

this.mainApplicationClass = 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;
	}

这个是从多个配置类中找到主配置类,就是看那个类有main方法，可以传多个看哪个又main方法。

-------------------------------------------------------------------------------------------------------------------------------------------68

第二步执行run方法。

         //运行。

public ConfigurableApplicationContext run(String... args) {
        //开启关闭监听
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
        //声明ioc容器
		ConfigurableApplicationContext context = null;
		FailureAnalyzers analyzers = null;
		configureHeadlessProperty();
        //这个十分重要得，火气监听器就是那五个组件里面的
		SpringApplicationRunListeners listeners = getRunListeners(args);
        //开启监听器，回调所有的starting方法。
		listeners.starting();
		try {
            //不重要就是封装命令行参数
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
            //准备环境这个方法里同样回调所有的监听器的方法
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
            //打印banner图标
			Banner printedBanner = printBanner(environment);
            //创建ioc容器这里也要回调listener
			context = createApplicationContext();
            //不重要 异常分析报告
			analyzers = new FailureAnalyzers(context);
            //准备上下文环境  这里面又三个回调方法
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
            //重要
			refreshContext(context);
            //回调runner
			afterRefresh(context, applicationArguments);
            //回调所有的listener方法
			listeners.finished(context, null);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			return context;
		}
		catch (Throwable ex) {
			handleRunFailure(context, listeners, analyzers, ex);
			throw new IllegalStateException(ex);
		}
	}

   解析：

       

StopWatch stopWatch = new StopWatch();

       监听不用管。

ConfigurableApplicationContext context = null;

    声明一个ioc容器。

    进入这个方法：configureHeadlessProperty();


	private void configureHeadlessProperty() {
		System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(
				SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
	}

  jwt相关可以先不要看。

接下来获取比较重要的一个监听器：SpringApplicationRunListeners listeners = getRunListeners(args);

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

由getSpringFactoriesInstances可知，是在类路径下的META-INF/spring.factories，获取的。

打开监听器。

public void starting() {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.starting();
		}
	}

回调所有的starting方法。

这个starting方法是SpringApplicationRunListener类的，下面是这个类的代码

/*
 * Copyright 2012-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.boot;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.logging.Log;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.util.ReflectionUtils;

/**
 * A collection of {@link SpringApplicationRunListener}.
 *
 * @author Phillip Webb
 */
class SpringApplicationRunListeners {

	private final Log log;

	private final List<SpringApplicationRunListener> listeners;

	SpringApplicationRunListeners(Log log,
			Collection<? extends SpringApplicationRunListener> listeners) {
		this.log = log;
		this.listeners = new ArrayList<SpringApplicationRunListener>(listeners);
	}

	public void starting() {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.starting();
		}
	}

	public void environmentPrepared(ConfigurableEnvironment environment) {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.environmentPrepared(environment);
		}
	}

	public void contextPrepared(ConfigurableApplicationContext context) {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.contextPrepared(context);
		}
	}

	public void contextLoaded(ConfigurableApplicationContext context) {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.contextLoaded(context);
		}
	}

	public void finished(ConfigurableApplicationContext context, Throwable exception) {
		for (SpringApplicationRunListener listener : this.listeners) {
			callFinishedListener(listener, context, exception);
		}
	}

	private void callFinishedListener(SpringApplicationRunListener listener,
			ConfigurableApplicationContext context, Throwable exception) {
		try {
			listener.finished(context, exception);
		}
		catch (Throwable ex) {
			if (exception == null) {
				ReflectionUtils.rethrowRuntimeException(ex);
			}
			if (this.log.isDebugEnabled()) {
				this.log.error("Error handling failed", ex);
			}
			else {
				String message = ex.getMessage();
				message = (message == null ? "no error message" : message);
				this.log.warn("Error handling failed (" + message + ")");
			}
		}
	}

}

这几个函数就是用来回调的。

 

接下来看准备环境做了什么？

ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
        //注意创建环境完成后回调这个方法表示环境准备完成
		listeners.environmentPrepared(environment);
		if (!this.webEnvironment) {
			environment = new EnvironmentConverter(getClassLoader())
					.convertToStandardEnvironmentIfNecessary(environment);
		}
		return environment;
	}

准备环境就不看了，注意这个：listeners.environmentPrepared(environment);

所以创建环境完成后回调SpringApplicationRunListeners.environmentPrepared(environment)方法。表示环境准备完成。

接下来：

     Banner printedBanner = printBanner(environment);打印banner图标。

     

 

 

 

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

   接下来很重要：

context = createApplicationContext();

进入方法创建ioc容器。

protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				contextClass = Class.forName(this.webEnvironment
						? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, "
								+ "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
	}

创建web的ioc容器还是其他的普通的容器 。。。。。。。。。。。。     

return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);

利用反射最终创建ioc容器。

接下来：

analyzers = new FailureAnalyzers(context);

出现异常的时候做分析报告的。

接下来：

prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);

    准备上下文环境，点进去。将environment环境保存到ioc中，applyInitializers(context);

private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
        //环境保存到ioc中
		context.setEnvironment(environment);
                 //后置处理器组装了一些小组件
		postProcessApplicationContext(context);
        //回调所有的ApplicationInatializer的initialize方法
		applyInitializers(context);
                 //回调
		listeners.contextPrepared(context);
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}

		// Add boot specific singleton beans 注册命令行参数对象
		context.getBeanFactory().registerSingleton("springApplicationArguments",
				applicationArguments);
		if (printedBanner != null) {
			context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
		}

		// Load the sources
		Set<Object> sources = getSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		load(context, sources.toArray(new Object[sources.size()]));
                  //最后一步listener回调
		listeners.contextLoaded(context);
	}

 进去applyInitializers(context)------准备上下文环境;获取所有的 ApplicationContextInitializer调用initialize方法。

ApplicationContextInitializer是之前加入进去的

	protected void applyInitializers(ConfigurableApplicationContext context) {
		for (ApplicationContextInitializer initializer : getInitializers()) {
			Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
					initializer.getClass(), ApplicationContextInitializer.class);
			Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
			initializer.initialize(context);
		}
	}

10.16

             就是回调这个。

             进去这个方法：listeners.contextPrepared(context);  回调所有的listener.contextPrepared()方法。

public void contextPrepared(ConfigurableApplicationContext context) {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.contextPrepared(context);
		}
	}

  这句：

             

listeners.contextLoaded(context);

  几个方法的回调都是之前保存好的。

  接下来重要的之前讲过 刷新容器：  

refreshContext(context);

刷新容器，就是ioc容器初始化的过程，扫描配置类，初始化bean。如果是web应用还会创建嵌入式的tomcat。

refresh方法：

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

 

这个方法初始化剩下的单实例的bean，就是所有的组件。

再次进入这个方法：

afterRefresh(context, applicationArguments);

 

protected void afterRefresh(ConfigurableApplicationContext context,
			ApplicationArguments args) {
		callRunners(context, args);
	}
private void callRunners(ApplicationContext context, ApplicationArguments args) {
		List<Object> runners = new ArrayList<Object>();
        //在ioc容器获取所有的这个两种runner
		runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
		runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
		AnnotationAwareOrderComparator.sort(runners);
		for (Object runner : new LinkedHashSet<Object>(runners)) {
			if (runner instanceof ApplicationRunner) {
				callRunner((ApplicationRunner) runner, args);
			}
			if (runner instanceof CommandLineRunner) {
				callRunner((CommandLineRunner) runner, args);
			}
		}
	}

     

     注意这两个时间监听的组件：ApplicationRunner    CommandLineRunner

    

有优先级的ApplicationRunner先回调，CommandLineRunner再来回调。

 再下来：

listeners.finished(context, null);

 所有的listener回调finished方法。

 最后返回ioc容器。 

总结： 

              

               下面是几个事件监听机制。有些是初始化器。

         

70-------------------------------------------------------------------------------------------------

          事件监听机制，插手监听类。

          首先是初始化器ApplicationContextInitializer的实现类，是来监听启动的：

package com.atguigu.springboot.listener;

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

public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
    }
}

        

        传入的泛型是用来监听什么的具体的，我们监听ioc容器的启动。

        ctrl+H快捷键

------------------------------------------------------------------------------------------------

   下一个组件：HelloSpringApplicationRunListener

                  

package com.atguigu.springboot.listener;

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("SpringApplicationRunListener...starting...");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        Object o = environment.getSystemProperties().get("os.name");
        System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);
    }

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

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

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

几个时机：

      

            starting()方法在ioc容器还没创建调用的

           

                   基本环境准备好了调用。

                   

                   prepareContext准备好了调用

                   

                  prepareContext运行完了调用

 --------------------------------------------------------------------        

下一个组件：HelloApplicationRunner

package com.atguigu.springboot.listener;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class HelloApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...run....");
    }
}

  

   下一个组件：HelloCommandLineRunner

package com.atguigu.springboot.listener;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.Arrays;


@Component
public class HelloCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
    }
}

------------------------------------------------------------------------------------------------------------------------------------------------------------------------

重要的：

放在容器中的只要加一个注解@Component

配置的话就是要按照原来的规则：类路径下建文件夹。

          

org.springframework.context.ApplicationContextInitializer=\
com.atguigu.springboot.listener.HelloApplicationContextInitializer

org.springframework.boot.SpringApplicationRunListener=\
com.atguigu.springboot.listener.HelloSpringApplicationRunListener

原理源码：

            

启动查看结果：

 

71--------------------------------------------------------------------------------

    自定义starts场景启动器

               已经自动配置好了只要写属性就可以了。

         starter：

                 1.场景使用的依赖

                 2.如何编写自动配置

 例子：找到这个类

                    

        使用@configure注解指定是配置类 

       @ConditionalOnXXX指定条件成立再启动

       判断@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)指定自动配置类的顺序

       @Bean添加组件。

                      

             自动配置类要是能加载的话：

                   

        模式：启动器只是用来做依赖导入，专门写一个自动配置模块，启动器依赖自动配置模块，别人只需要引入启动器。

         启动器依赖自动配置 别人使用依赖启动器。

        

    

     导入模块。

     最后自定义启动器，移步我的博客：https://blog.youkuaiyun.com/qq_28764557/article/details/89005008

Spring Boot进阶(03)：【实战教程】MyBatis-Plus秒级实现字段自动填充，让你的代码更优雅！
**My Coding Family**
04-03 1万+
如何使用MyBatis-Plus提供的@TableField注解实现字段自动填充？这你若不会，还不点进来瞅瞅！或许就捡到宝啦。
【SpringBoot详细教程】-08-MybatisPlus详细教程以及SpringBoot整合Mybatis-plus【持续更新】
yueyehuguang的博客
09-30 2335
MybatisPlus(简称MP)是基于MyBatis框架基础上开发的增强型工具，旨在简化开发、提供效率。至于简化在哪里，我们先看一个案例然后再来详细探究MyBatisPlus。MyBatisPlus（简称MP）是基于MyBatis框架基础上开发的增强型工具，旨在简化开发提高效率通过刚才的案例，相信大家能够体会简化开发和提高效率这两个方面的优点。MyBatisPlus的官网为:https://mp.baomidou.com/
SpringBoot——启动配置原理
长不大的大灰狼
12-21 261
SpringBoot——启动配置原理一、启动流程：1、创建SpringApplication：2、run二、 事件监听机制测试 一、启动流程： 几个重要的事件回调机制 下面两个是配置在META-INF/spring.factories中的： ApplicationContextInitializer SpringApplicationRunListener 下面两个是配置在ioc容器中的 ApplicationRunner CommandLineRunner 1、创建SpringApplicatio
springboot启动配置文件-bootstrap.yml常用基本配置
qq_30166465的博客
06-07 3275
这里配置了mq的基本配置，例如地址、端口等，默认就是tjxt的地址，不需要修改。另外还配置类消费者的失败重试机制，如有需要可以按需修改。外，其它参数都有默认值，在没有配置的情况下会按照默认值来配置，也可以按照参数名来自定义这些参数值。注意配置了Redis的基本地址和连接池配置，省去了我们大部分的工作。这里配置了默认的Feign日志级别以及连接池配置，一般不需要修改。这里配置了xxl-job组件的地址等信息，一般不需要修改。接下来，我们就分别看看每一个共享的配置文件内容。
SpringBoot启动流程及自动配置
cliper9768的博客
07-30 1871
springboot
Spring Boot配置启动
Brandon_的博客
01-01 1264
Spring Boot配置启动
springboot启动类配置
学而不思则罔 思而不学则殆
02-15 2564
pom.xml：<properties> <start-class>com.shw.netdisk.application.Application</start-class> </properties>
「 jasypt-spring-boot」敏感信息加密/解密利器
大白吃饱了吗的技术博客
04-16 2328
文章目录1. 简介2. 如何整合3. 自定义环境4. 工作原理5. 加密的属性如何处理6. 基于密码的加密配置7. 使用自定义的加密程序8. 自定义`Property Detector`, `Prefix`, `Suffix` 和 `Resolver`8.1 自定义`EncryptablePropertyDetector`8.2 自定义加密属性前缀和后缀8.3 自定义`EncryptablePropertyResolver`9. 使用过滤器9.1 `DefaultPropertyFilter`类的属性9.2
SOFABoot源码解析之启动原理（1）-注解分析
闲来无事
06-27 3305
        SOFABoot是蚂蚁金服开源的基于 Spring Boot 的研发框架，它在Spring Boot 的基础上，提供了诸如 Readiness Check，类隔离，日志空间隔离等等能力。在增强了 Spring Boot 的同时，SOFABoot 提供了让用户可以在 SpringBoot中非常方便地使用 SOFA 中间件的能力。        为了基于SOFABoot框架进行研发，建...
SpringBoot结合Elasticsearch实现个性化搜索推荐模型-01
ZPJ优快云的博客
09-06 1684
对于我们传统的应用来说, 常见的搜索无非是用户通过前端发起请求给后端, 后端去DataBase中比如MySQL, Oracle 中完成查询，并返回，这个查询可能是精确匹配，模糊匹配等等，但是这样的搜索功能可以被称之为搜索引擎吗?
spring boot的启动与配置
qqqq0199181的博客
08-02 792
spring boot 命令行启动 mvn spring-boot:run 属性配置 //端口 server.port=8081 //上下文 server.servlet.context-path=/wei （这是2.x的配置，1.x是server.context-path） 程序中获取配置文件中的配置 单个获取 在application.properties 文...
java中spring boot启动配置
白小白的小白的博客
06-01 280
在pom.xml中的配置 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.10.RELEASE</version> <relativePath/> &l.
springboot启动自动配置
kuayueday的博客
02-21 750
1.自定义项命名启动类规范： 功能在前名字在后比如 aliyun-oss-spring-boot-starter starter表示启动 springboot版本需要2.7.5。3.创建org.springframework.boot.autoconfigure.AutoConfiguration.imports spring启动可读取的文件。6.需要注意的是maven文件也需要像这样导入相关的启动类和配置类项目。3.定义配置类 把编写好的需要加入baen里面的类放在配置类。
spring boot启动类配置,配置文件
qq_41622603的博客
02-05 2535
@ComponentScan可以配置SpringBoot启动类的扫描位置，因为项目启动类默认必须在项目最外层目录，所以当启动类位置发生变化要此注解进行配置 springboot配置文件 springboot配置文件有两个 application.properties和application.yml 读取配置文件配置 方式1：把配置文件读取到实体类 1.编写实体...
总结：SpringBoot启动参数配置
w2009211777的专栏
11-16 5841
SpringBoot启动参数配置
SpringBoot启动配置原理
蜗牛君
07-13 6541
文章目录一. 启动原理1.主配置类入口2.进入run方法3.创建SpringApplication对象：二. 运行流程三. 自动配置原理 一. 启动原理 1.主配置类入口 @SpringBootApplication public class DevServiceApplication { public static void main(String[] args) { SpringApplication.run(DevServiceApplication.class,args);
SpringBoot教程(一)一个简单的springboot应用启动和配置
蜜獾互联网
12-05 722
一.配置和启动第一个简单的Springboot应用 (1)使用idea创建springboot项目 (2)工程结构 (3)配置文件pom &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://w...
Springboot启动配置原理
zhou920786312的博客
06-04 402
1Springboot启动配置原理 几个重要的事件回调机制(配置在META-INF/spring.factories) ApplicationContextInitializer SpringApplicationRunListener 只需要放在ioc容器中 ApplicationRunner CommandLineRunner 1.1启动流程 initialize(sou...
springboot的RandomValuePropertySourceEnvironmentPostProcessor作用
最新发布
06-08
根据引用[1]和引用[2]，我们可以知道这个后置处理器属于SpringBoot在启动过程中加载的环境后置处理器之一。它的主要作用是在SpringEnvironment中添加一个能够生成随机值的属性源（PropertySource）。具体来说，它的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值