精华内容
下载资源
问答
  • SpringBoot原理分析

    2019-07-14 16:07:39
    SpringBoot原理分析 1. 目标 理解SpringBoot原理-起步依赖 理解SpringBoot自动配置 2. 讲解 2.1 起步依赖 我们可以打开pom.xml中的parent,并查看spring-boot-starter-parent信息。 从上面的spring-boot-...

    SpringBoot原理分析

    1.  目标

    • 理解SpringBoot原理-起步依赖
    • 理解SpringBoot自动配置

    2. 讲解

    2.1 起步依赖

    我们可以打开pom.xml中的parent,并查看spring-boot-starter-parent信息。

    从上面的spring-boot-dependencies的pom.xml中可以看出,坐标的版本,依赖管理,插件管理已经预先定义好了。SpringBoot工程继承Spring-boot-starter-parent后,已经锁定了版本等配置。起步依赖的作用是进行依赖传递 。用啥取啥,随用随取即可。我们开发中彻底不用关心:jar包的版本、依赖等问题了,大大降低版本冲突,版本过期,更新一个jar一下就需要升级一个tree的jar包。

    相当于我们之前学习的过程中创建的父工程,在之前创建的父工程中,其中一个功能是用来统一管理jar包。这里的父工程其实作用是一样的。

    2.2 自动配置

    (1)@SpringBootApplication

    该注解是一个组合注解,包括如下注解

    • @SpringBootConfiguration:与之前@Configuration注解一样,声明为一个配置类
    • @ComponentScan:spring IoC容器的扫描包,默认扫描引导程序下的包以及子包,如果我们写的程序不在该包范围内,可以通过该注解指定。
    • @EnableAutoConfiguration:springboot实现自动化配置的核心注解。

    (2)@SpringBootConfiguration

    通过这段我们可以看出,在这个注解上面,又有一个@Configuration注解。通过上面的注释阅读我们知道:这个注解的作用就是声明当前类是一个配置类,然后Spring会自动扫描到添加了@Configuration的类,并且读取其中的配置信息。而@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类,项目中只能有一个。所以一般我们无需自己添加。

    (3)@EnableAutoConfiguration

    @EnableAutoConfiguration告诉Spring Boot基于你所添加的依赖,去“猜测”你想要如何配置Spring。比如我们引入了spring-boot-starter-web,而这个启动器中帮我们添加了tomcatSpringMVC的依赖。此时自动配置就知道你是要开发一个web应用,所以就帮你完成了web及SpringMVC的默认配置了!

    自动配置:自己一般不用修改配置,默认的配置都给配好了。

    3. 小结

    • 工程继承了spring-boot-starter-parent工程,spring-boot-starter-parent继承了spring-boot-dependencies,spring-boot-dependencies实现了jar包管理和版本锁定。工程引入spring-boot-starter-web依赖,该工程又依赖了其他web所需的jar包,maven依赖有传递性。
    • 通过@SpringBootApplication注解完成自动配置,会将当前类作为一个配置类,并且会根据我们所引入的依赖猜测我们的配置,并实现自动配置。
    展开全文
  • springboot原理分析

    2019-07-11 17:44:42
    这些是我看springboot原理分析的相关视频时写的笔记,后续会完善,先和大家分享分享 jsr 250 @Resource jsr 330 @Inject 初始化applicationContext的三种方式: 1.spring的注解 @Autowire 2.构造函数,将...

    这些是我看springboot原理分析的相关视频时写的笔记,后续会完善,先和大家分享分享

    jsr 250 @Resource
    jsr 330 @Inject

    初始化applicationContext的三种方式:
    1.spring的注解 @Autowire
    2.构造函数,将applicationContext作为唯一的构造函数参数(spring4.3的新特性)
    3.implement ApplicationContextAware接口 重写方法

    bean初始化回调:
    实现BeanPostProcesser需要重写的两个方法:(作用:会在每个bean初始化时候调用一次)
    PostProcesserBeforeInitialization() //在bean依赖装配完成之后(set属性设置完)触发,这里可以对bean处理,比如返回代理对象
    PostProcesserAfterInitialization() //是在init方法执行之后触发

    @Bean(iniMethod=init)这个init()方法会在上述两个方法的中间

    只在容器初始化后触发执行一次,但比BeanPostProcesser触发早
    BeanFactoryPostProcesser需要重写一个方法:
    postProcesserBeanFactory()

    BeanFactoryPostProcesser的一个子类 BeanDefinitionRegistryPostProcesser其下有一个方法:
    void postProcesserBeanDefinitionRegistry( BeanDefinitionRegistry registry)

    BeanDefinitionRegistry 是注册一个bean去spring容器,拿到这个东西就可以动态的注入bean

    默认的配置文件名字可以用–spring.config.name来指定,只需要指定文件名字,配置文件需要指定全路径,包括目录和文件名称,文件的指定方式有两种:class path和file
    配置文件可以加载多个

    加载配置项方式:
    @PropertySource或者@PropertySources(,)
    @configurationProperties

    获取配置项:
    1@Autowire env
    2@value

    动态操作配置文件:
    相关接口:EnviromentPostProcessor

    @ConditionalOnProperty(name="",havingValue="",macthIfMissing=true) 表示某个属性等于某个值时装配
    @ConditionalOnClass //表示classpath中存在某个class时装配---------------@ConditionalOnMissingClass
    @ConditionalOnBean //根据容器中是否存在某个bean来进行装配----------@ConditionalOnMissingBean
    自定义condition:
    @Conditional(UTF8condition.class)基于条件的自动配置,一般配合Condition接口一起使用,只有接口的实现返回true才装配,可以用在方法和类上

    @Enable注解
    @EnableConfigurationProperties 是用来启用一个特性的,这个特性是,可以把配置文件的属性注入到bean里
    @EnableAsync用来启用异步,和需要异步的方法上的@Async配合使用

    @Import(导入一个或多个普通的类或者@Configuration)
    @Import(ImportSelector的实现类/ImportBeanDefinitionRegistrar的实现类):
    ImportSelector接口的实现方法selectImports的返回值,必须是一个class的string[],该class会被spring容器所托管起来
    ImportBeanDefinitionRegistrar的实现方法registerBeanDefinitions方法的参数有一个BeanDefinitionRegistry,可以用来往spring容器注入bean

    @EnableAutoConfiguration作用:从classpth中获取META-INF/spring-factories配置文件,然后,拿其中org.springframework.boot.autoconfigure.EnableAutoConfiguration key对应的配置项
    加载到spring容器
    其内部实现的关键点:
    1.ImportSelector 该接口的方法返回值都会被纳入到spring容器中。
    2.SpringFactoriesLoader 该类可以从claspath中搜索META-INF/Spring.factories配置文件,并读取配置。

    添加监听器的方式:
    1.自定义事件:一般是继承ApplicatonEvent加载类
    2.定义事件监听器:一般是实现ApplicationListener接口
    3.配置监听器,启动的时候需要把监听器纳入到spring容器中 springApplication.addListener()/@Component/在application中配置context.listener.classes=/@EventListener/可以通过spring.factories机制
    4.发布事件,使用ApplicationContext.publishEvent发布事件

    ApplicationContextInitializer 接口是在spring容器执行refreshed之前的一个回调
    使用步骤:
    1.写一个类,实现ApplicationContextInitialize接口
    2.注册ApplicationContextInitializer
    注册方法:
    1.SpringApplication.addInitializers
    2.通过配置项context.initializer.classes 指定,可以指定多个,多个用逗号隔开
    3.可以通过spring.factories机制

    CommandLineRunner/ApplicationRunner接口是在容器启动成功后的最后一步回调(类似开机自启动)
    使用步骤:
    1.写一个类,实现CommandLineRunner接口
    2.把该类纳入到spring容器的管理之中
    注意:通过@Order注解或者ordered接口来控制执行顺序
    CommandLineRunner ApplicationRunner区别:
    区别在于方法的参数不一样
    CommandLineRunner的参数是最原始的参数,没有任何处理
    ApplicationRunner的参数是AppliatonArguemnts,是对原始参数进一步的封装

    拦截器使用步骤:
    1.写一个拦截器,实现HandlerInterceptor接口
    2.在写一个类,继承WebMvcConfigurerAdapter抽象类,然后重写addInterceptors方法,并调用register.addInterceptor把上一步的拦截器加进去。
    HandlerInterceptor接口,里面有三个方法
    1.perhandler: controller执行之前调用
    2.posthandler:controller执行之后,且页面渲染之前调用
    3.aftercomplier:页面渲染之后调用,一般用于页面清理操作

    异常处理:
    如可去掉springboot默认的异常处理逻辑:
    @SpringBootApplication(exclude=ErrorMvcAutoConfiguration.class)
    使用ErrorPageRegistrar方法:
    ErrorPageRegistrar抽象类 ErrorPage可以定义状态码和相应页面
    全局异常处理步骤:
    1.写一个类,需要加上@ControllerAdvice注解
    2.写一个异常处理方法,方法上需要加上@ExceptionHandler(value=Exception.class)这个注解,在该方法里面处理异常

    springboot定制和优化内嵌的tomcat
    springboot内嵌了三种容器:
    在这里插入图片描述
    定制化tomcat有两种方法:
    1. 实现EmbeddedServletContinaerCustomizer接口,并把实现类纳入到spring容器
    2. 在spring容器中装配一个EmbeddedServletContainerCustomizer对象

    相关类或者接口:
    TomcatConnectorCustomizer
    Connector.getPorocalHandler
    EmbeddedServletContainerAutoConfiguration

    展开全文
  • Springboot原理分析

    2021-04-20 08:35:32
    至今做了几年码农, 辞职后 接近着开始找工作,面试, 在我印象中最深刻的就是,XXX公司问我springboot实现原理及优势 坑坑巴巴的说了一下. 已自闭~ [面试官: 今天就到这里吧. 回去等通知!] 一首凉凉送给自己 回去后,...

    前言 :

    至今做了几年码农, 辞职后 接近着开始找工作,面试, 在我印象中最深刻的就是,XXX公司问我springboot实现原理及优势

    坑坑巴巴的说了一下. 已自闭~
    [面试官: 今天就到这里吧. 回去等通知!]
    一首凉凉送给自己
    回去后,阅读了下源码. 才恍然大悟.
    可以参考下 官方文

    之前需要我们自己装载, 之后springboot简化了这些
    室友的呼噜声好大~ 哈哈哈

    • 先从启动类开始
    • @SpringBootApplication 做了些什么
    • SpringApplication.run 干了什么
      在这里插入图片描述
    • 点进去 可以看到如下
    • @EnableAutoConfiguration
    • @SpringBootConfiguration

    在这里插入图片描述

    @SpringBootConfiguration  // 此注解 源码中引用了@Configuration  配置
    
    @EnableAutoConfiguration // 自动配置
    
    • 自动配置
      @EnableAutoConfiguration
      在这里插入图片描述
    1. @AutoConfigurationPackage 自动配置包
      导入了选择器
      在这里插入图片描述

    2. 选择组件
      在这里插入图片描述

    • 加载源数据
    	static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
    		return loadMetadata(classLoader, PATH);
    	}
    
    	static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
    		try {
    			Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
    					: ClassLoader.getSystemResources(path);
    			Properties properties = new Properties();
    			while (urls.hasMoreElements()) {
    				properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
    			}
    			return loadMetadata(properties);
    		}
    		catch (IOException ex) {
    			throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
    		}
    	}
    
    • getAutoConfigurationEntry 自动配置实体
    	protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
    			AnnotationMetadata annotationMetadata) {
    		if (!isEnabled(annotationMetadata)) {
    			return EMPTY_ENTRY;
    		}
    		AnnotationAttributes attributes = getAttributes(annotationMetadata);
    		// getCandidateConfigurations 获取所有配置
    		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    		configurations = removeDuplicates(configurations);
    		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    		checkExcludedClasses(configurations, exclusions);
    		configurations.removeAll(exclusions);
    		configurations = filter(configurations, autoConfigurationMetadata);
    		fireAutoConfigurationImportEvents(configurations, exclusions);
    		return new AutoConfigurationEntry(configurations, exclusions);
    	}
    
    • 获取候选配置
    	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    	//  spring工厂加载
    		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
    				getBeanClassLoader());
    				
    		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
    				+ "are using a custom packaging, make sure that file is correct.");
    		return configurations;
    	}
    

    在这里插入图片描述

    // 断言 非空, 如果不为空 就会加载spring.factories 配置文件
    在这里插入图片描述在这里插入图片描述
    例如: redis 自动配置 ,放入了容器中
    @ConditionalOnClass(RedisOperations.class) 条件成立后会加载,不成立不会导入对应的jar在这里插入图片描述

    • 当前了类的classLoader
      在这里插入图片描述
      在这里插入图片描述

    标注了: 是谁使用了 @EnableAutoConfiguration
    启动类启用了自动配置 自动导入了

    此致

    展开全文
  • springBoot原理分析

    2019-12-16 11:30:20
    1.1 起步依赖原理分析 1.1.1 分析spring-boot-starter-parent 按住Ctrl点击pom.xml中的spring-boot-starter-parent,跳转到了spring-boot-starter-parent的pom.xml,xml配置如下(只摘抄了部分重点配置): <...

    1.1 起步依赖原理分析

    1.1.1 分析spring-boot-starter-parent

    按住Ctrl点击pom.xml中的spring-boot-starter-parent,跳转到了spring-boot-starter-parent的pom.xml,xml配置如下(只摘抄了部分重点配置):

    <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>2.0.1.RELEASE</version>
      <relativePath>../../spring-boot-dependencies</relativePath>
    </parent>

    按住Ctrl点击pom.xml中的spring-boot-starter-dependencies,跳转到了spring-boot-starter-dependencies的pom.xml,xml配置如下(只摘抄了部分重点配置):

    <properties>
      	<activemq.version>5.15.3</activemq.version>
      	<antlr2.version>2.7.7</antlr2.version>
      	<appengine-sdk.version>1.9.63</appengine-sdk.version>
      	<artemis.version>2.4.0</artemis.version>
      	<aspectj.version>1.8.13</aspectj.version>
      	<assertj.version>3.9.1</assertj.version>
      	<atomikos.version>4.0.6</atomikos.version>
      	<bitronix.version>2.1.4</bitronix.version>
      	<build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
      	<byte-buddy.version>1.7.11</byte-buddy.version>
      	... ... ...
    </properties>
    <dependencyManagement>
      	<dependencies>
          	<dependency>
            	<groupId>org.springframework.boot</groupId>
            	<artifactId>spring-boot</artifactId>
            	<version>2.0.1.RELEASE</version>
          	</dependency>
          	<dependency>
            	<groupId>org.springframework.boot</groupId>
            	<artifactId>spring-boot-test</artifactId>
            	<version>2.0.1.RELEASE</version>
          	</dependency>
          	... ... ...
    	</dependencies>
    </dependencyManagement>
    <build>
      	<pluginManagement>
        	<plugins>
          		<plugin>
            		<groupId>org.jetbrains.kotlin</groupId>
            		<artifactId>kotlin-maven-plugin</artifactId>
            		<version>${kotlin.version}</version>
          		</plugin>
          		<plugin>
            		<groupId>org.jooq</groupId>
            		<artifactId>jooq-codegen-maven</artifactId>
            		<version>${jooq.version}</version>
          		</plugin>
          		<plugin>
            		<groupId>org.springframework.boot</groupId>
            		<artifactId>spring-boot-maven-plugin</artifactId>
            		<version>2.0.1.RELEASE</version>
          		</plugin>
              	... ... ...
        	</plugins>
      	</pluginManagement>
    </build>

    从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现,一部分坐标的版本、依赖管理、插件管理已经定义好,所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递。

    1.1.2 分析spring-boot-starter-web

    按住Ctrl点击pom.xml中的spring-boot-starter-web,跳转到了spring-boot-starter-web的pom.xml,xml配置如下(只摘抄了部分重点配置):

    <?xml version="1.0" encoding="UTF-8"?>
    <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      	<modelVersion>4.0.0</modelVersion>
      	<parent>
        	<groupId>org.springframework.boot</groupId>
        	<artifactId>spring-boot-starters</artifactId>
        	<version>2.0.1.RELEASE</version>
      	</parent>
      	<groupId>org.springframework.boot</groupId>
      	<artifactId>spring-boot-starter-web</artifactId>
      	<version>2.0.1.RELEASE</version>
      	<name>Spring Boot Web Starter</name>
      
      	<dependencies>
        	<dependency>
          		<groupId>org.springframework.boot</groupId>
          		<artifactId>spring-boot-starter</artifactId>
          		<version>2.0.1.RELEASE</version>
          		<scope>compile</scope>
        	</dependency>
        	<dependency>
          		<groupId>org.springframework.boot</groupId>
          		<artifactId>spring-boot-starter-json</artifactId>
          		<version>2.0.1.RELEASE</version>
          		<scope>compile</scope>
        	</dependency>
        	<dependency>
          		<groupId>org.springframework.boot</groupId>
          		<artifactId>spring-boot-starter-tomcat</artifactId>
          		<version>2.0.1.RELEASE</version>
          		<scope>compile</scope>
        	</dependency>
        	<dependency>
          		<groupId>org.hibernate.validator</groupId>
          		<artifactId>hibernate-validator</artifactId>
          		<version>6.0.9.Final</version>
          		<scope>compile</scope>
        	</dependency>
        	<dependency>
          		<groupId>org.springframework</groupId>
          		<artifactId>spring-web</artifactId>
          		<version>5.0.5.RELEASE</version>
          		<scope>compile</scope>
        	</dependency>
        	<dependency>
          		<groupId>org.springframework</groupId>
          		<artifactId>spring-webmvc</artifactId>
          		<version>5.0.5.RELEASE</version>
          		<scope>compile</scope>
        	</dependency>
      	</dependencies>
    </project>
    

    从上面的spring-boot-starter-web的pom.xml中我们可以发现,spring-boot-starter-web就是将web开发要使用的spring-web、spring-webmvc等坐标进行了“打包”,这样我们的工程只要引入spring-boot-starter-web起步依赖的坐标就可以进行web开发了,同样体现了依赖传递的作用。

    1.2 自动配置原理解析

    按住Ctrl点击查看启动类MySpringBootApplication上的注解@SpringBootApplication

    @SpringBootApplication
    public class MySpringBootApplication {
        public static void main(String[] args) {
            SpringApplication.run(MySpringBootApplication.class);
        }
    }

    注解@SpringBootApplication的源码

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = {
    		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication {
    
    	/**
    	 * Exclude specific auto-configuration classes such that they will never be applied.
    	 * @return the classes to exclude
    	 */
    	@AliasFor(annotation = EnableAutoConfiguration.class)
    	Class<?>[] exclude() default {};
    
    	... ... ...
    
    }

    其中,

    @SpringBootConfiguration:等同与@Configuration,既标注该类是Spring的一个配置类

    @EnableAutoConfiguration:SpringBoot自动配置功能开启

    按住Ctrl点击查看注解@EnableAutoConfiguration

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
    	... ... ...
    }

    其中,@Import(AutoConfigurationImportSelector.class) 导入了AutoConfigurationImportSelector类

    按住Ctrl点击查看AutoConfigurationImportSelector源码

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
            ... ... ...
            List<String> configurations = getCandidateConfigurations(annotationMetadata,
                                                                       attributes);
            configurations = removeDuplicates(configurations);
            Set<String> exclusions = getExclusions(annotationMetadata, attributes);
            checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = filter(configurations, autoConfigurationMetadata);
            fireAutoConfigurationImportEvents(configurations, exclusions);
            return StringUtils.toStringArray(configurations);
    }
    
    
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
    			AnnotationAttributes attributes) {
    		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
    				getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    		
    		return configurations;
    }
    

    其中,SpringFactoriesLoader.loadFactoryNames 方法的作用就是从META-INF/spring.factories文件中读取指定类对应的类名称列表

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ULFh0wsU-1576466612715)(img\11.png)]

    spring.factories 文件中有关自动配置的配置信息如下:

    ... ... ...
    
    org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
    
    ... ... ...
    

    上面配置文件存在大量的以Configuration为结尾的类名称,这些类就是存有自动配置信息的类,而SpringApplication在获取这些类名后再加载

    我们以ServletWebServerFactoryAutoConfiguration为例来分析源码:

    @Configuration
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
    @ConditionalOnClass(ServletRequest.class)
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @EnableConfigurationProperties(ServerProperties.class)
    @Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
    		ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
    		ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
    		ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
    public class ServletWebServerFactoryAutoConfiguration {
    	... ... ...
    }
    

    其中,

    @EnableConfigurationProperties(ServerProperties.class) 代表加载ServerProperties服务器配置属性类

    进入ServerProperties.class源码如下:

    @ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
    public class ServerProperties {
    
    	/**
    	 * Server HTTP port.
    	 */
    	private Integer port;
    
    	/**
    	 * Network address to which the server should bind.
    	 */
    	private InetAddress address;
      
      	... ... ...
      
    }

    其中,

    prefix = “server” 表示SpringBoot配置文件中的前缀,SpringBoot会将配置文件中以server开始的属性映射到该类的字段中。映射关系如下:
    在这里插入图片描述

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,280
精华内容 912
关键字:

springboot原理分析

spring 订阅