Spring Boot(四)：自动配置原理

最新推荐文章于 2023-03-09 15:12:08 发布
最新推荐文章于 2023-03-09 15:12:08 发布
阅读量221 收藏
点赞数
分类专栏： SpringBoot 文章标签： springboot自动配置原理 自动配置原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mahao25/article/details/103057816
版权

对于springboot的自动配置原理，就是spring官方帮助我们写好了默认的配置，我们创建应用直接使用他们写好的配置就行。如果官方没有提供我们需要的场景组件的配置，这个时候，则需要我们去写配置。

springboot实现方式是，将现在使用的功能，封装成一个个启动器，当使用某个场景的时候，导入我们需要的启动器，对应的依赖jar包则会自动添加到项目中。springboot在启动的时候，会开启自动配置功能，功能的底层就是导入配置类(xxxAutoConfiguration),根据我们导入的依赖包，去判断哪些配置类是需要导入的。如果根据jar包确定了配置类，那么这些配置类中的配置文件，则在同包下有个xxxProperties，这里面是该配置类所有需要的配置信息，只需要在配置类中将场景需要的组件设置好参数，然后注入到spring容器中，即可完成了自动配置功能。

1. 注解：@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 {

标注在主配置类上，使用@SpringBootConfiguration表明是配置类。关于自动配置的功能，是@EnableAutoConfiguration 注解。

2. 注解： @EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage //自动注册的包下面的类，这个上面已经讲过。
@Import(EnableAutoConfigurationImportSelector.class)//导入自动配置类，重点
public @interface EnableAutoConfiguration {

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 * @return the classes to exclude
	 */
	Class<?>[] exclude() default {};

	/**
	 * Exclude specific auto-configuration class names such that they will never be
	 * applied.
	 * @return the class names to exclude
	 * @since 1.3.0
	 */
	String[] excludeName() default {};

}

4. 注解： @Import(EnableAutoConfigurationImportSelector.class)

//该注解 @Import导入ImportSelector传入的组件全类名，查看导入了那些全类名：
@Deprecated
public class EnableAutoConfigurationImportSelector
		extends AutoConfigurationImportSelector {

	@Override
	protected boolean isEnabled(AnnotationMetadata metadata) {
		if (getClass().equals(EnableAutoConfigurationImportSelector.class)) {
			return getEnvironment().getProperty(
					EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class,
					true);
		}
		return true;
	}

}
//父类中的方法：
public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		try {
			AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
					.loadMetadata(this.beanClassLoader);
			AnnotationAttributes attributes = getAttributes(annotationMetadata);
            //这是获取所有的要加载的自动配置类的全类名
			List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
			configurations = removeDuplicates(configurations);
			configurations = sort(configurations, autoConfigurationMetadata);
			Set<String> exclusions = getExclusions(annotationMetadata, attributes);
			checkExcludedClasses(configurations, exclusions);
			configurations.removeAll(exclusions);
			configurations = filter(configurations, autoConfigurationMetadata);
			fireAutoConfigurationImportEvents(configurations, exclusions);
			return configurations.toArray(new String[configurations.size()]);
		}
		catch (IOException ex) {
			throw new IllegalStateException(ex);
		}
	}

//根据元注解获取要加载的自动配置类。
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
    	//从这里获取值，参数是getSpringFactoriesLoaderFactoryClass()，下面贴出来了具体方法
    	//就是EnableAutoConfiguration类，也就是他的全类名
    	//org.springframework.boot.autoconfigure.EnableAutoConfiguration
		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;
	}

//
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

//如何根据指定的类名获取对应的配置文件。
public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
		String factoryClassName = factoryClass.getName();
		try {
			Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			List<String> result = new ArrayList<String>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
                //可以看到是properties文件，文件的位置在
//public static final String FACTORIES_RESOURCE_LOCATION = "METAINF/spring.factories";
				Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
				String factoryClassNames = properties.getProperty(factoryClassName);
				result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
			}
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
					"] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

通过上面的查找，我们可以加载所有的配置类的全类名，在springboot-autoconfiguration包下面：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

这些自动配置类，都在spring-boot-autoconfiguration项目下面，每一个类都是被配置类，我们查看较为简单的自动配置类，比如 HttpEncodingAutoConfiguration：

5. HttpEncodingAutoConfiguration.java

@Configuration//标记该类是配置类。

@EnableConfigurationProperties(HttpEncodingProperties.class)//绑定配置文件类，并将配置文件类注入到IOC容器中。

@ConditionalOnWebApplication //判断自动配置类是否生效
@ConditionalOnClass(CharacterEncodingFilter.class)
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)
public class HttpEncodingAutoConfiguration {

	private final HttpEncodingProperties properties;

	public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
		this.properties = properties;
	}

	@Bean//向容器中注入该场景需要的组件
	@ConditionalOnMissingBean(CharacterEncodingFilter.class)//判断组件是否需要
	public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
		return filter;
	}

	@Bean
	public LocaleCharsetMappingsCustomizer localeCharsetMappingsCustomizer() {
		return new LocaleCharsetMappingsCustomizer(this.properties);
	}

	private static class LocaleCharsetMappingsCustomizer
			implements EmbeddedServletContainerCustomizer, Ordered {

		private final HttpEncodingProperties properties;

		LocaleCharsetMappingsCustomizer(HttpEncodingProperties properties) {
			this.properties = properties;
		}

		@Override
		public void customize(ConfigurableEmbeddedServletContainer container) {
			if (this.properties.getMapping() != null) {
				container.setLocaleCharsetMappings(this.properties.getMapping());
			}
		}

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

	}

}

对于上面的几个注解，下文将会进行详细的解析：

6. 注解：@Configuration

这是spring的原生注解，标记一个类是spring的配置类，spring容器在创建时，会加载这个类，取出里面的配置信息，在spring注解版的笔记中有详细的介绍。通过他可以向spring容器中添加组件等操作。

7. 注解：@EnableConfigurationProperties(HttpEncodingProperties.class)

**该注解是开启自动配置类绑定配置文件类，并将配置文件注入到IOC容器中。**每一个配置类都有对应的配置文件类，而这个配置文件类，就是通过@EnableConfigurationProperties注解和配置类相绑定。我们查看这个绑定的文件，HttpEncodingProperties

@ConfigurationProperties(prefix = "spring.http.encoding")//从配置文件中获取指定的值和bean的属
性进行绑定
public class HttpEncodingProperties {

	public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

	/**
	 * Charset of HTTP requests and responses. Added to the "Content-Type" header if not
	 * set explicitly.
	 */
	private Charset charset = DEFAULT_CHARSET;

	/**
	 * Force the encoding to the configured charset on HTTP requests and responses.
	 */
	private Boolean force;

	/**
	 * Force the encoding to the configured charset on HTTP requests. Defaults to true
	 * when "force" has not been specified.
	 */
	private Boolean forceRequest;

	/**
	 * Force the encoding to the configured charset on HTTP responses.
	 */
	private Boolean forceResponse;

	/**
	 * Locale to Encoding mapping.
	 */
	private Map<Locale, Charset> mapping;

	public Charset getCharset() {
		return this.charset;
	}

	public void setCharset(Charset charset) {
		this.charset = charset;
	}

	public boolean isForce() {
		return Boolean.TRUE.equals(this.force);
	}

	public void setForce(boolean force) {
		this.force = force;
	}

	public boolean isForceRequest() {
		return Boolean.TRUE.equals(this.forceRequest);
	}

	public void setForceRequest(boolean forceRequest) {
		this.forceRequest = forceRequest;
	}

	public boolean isForceResponse() {
		return Boolean.TRUE.equals(this.forceResponse);
	}

	public void setForceResponse(boolean forceResponse) {
		this.forceResponse = forceResponse;
	}

	public Map<Locale, Charset> getMapping() {
		return this.mapping;
	}

	public void setMapping(Map<Locale, Charset> mapping) {
		this.mapping = mapping;
	}

	boolean shouldForce(Type type) {
		Boolean force = (type == Type.REQUEST ? this.forceRequest : this.forceResponse);
		if (force == null) {
			force = this.force;
		}
		if (force == null) {
			force = (type == Type.REQUEST);
		}
		return force;
	}

	enum Type {

		REQUEST, RESPONSE

	}

}

@ConfigurationProperties注解指定对应的配置文件前缀，这个类中含有自动配置类所有需要的配置参数。通过注解，我们可以知道在application.yml文件中需要去写那些配置参数了吧。

8. 注解： @ConditionalOnxxx

**判断该自动配置类是否生效,**这一些注解是 @Conditional的衍生注解。

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
    
    
    Class<?>[] value() default {};

	/**
	 * The classes names that must be present.
	 * @return the class names that must be present.
	 */
	String[] name() default {};

}

其功能都是通过@Conditional(OnClassCondition.class)决定是否让当前组件注入到spring容器中，而决定是否的则是 Condition的子类；

public interface Condition {

	/**
	 * Determine if the condition matches.
	 * @param context the condition context
	 * @param metadata metadata of the {@link org.springframework.core.type.AnnotationMetadata class}
	 * or {@link org.springframework.core.type.MethodMetadata method} being checked.
	 * @return {@code true} if the condition matches and the component can be registered
	 * or {@code false} to veto registration.
	 */
	boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

}

Condition是一个接口，返回true则让当前组件注入到容器中，否则不注入。在HttpEncodingAutoConfiguration配置类中，设置了三个条件判断，这些条件都是web场景下的条件，如果是进行web开发，则这个自动配置类则会生效。一但这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取
的，这些类里面的每一个属性又是和配置文件绑定的；
在这里插入图片描述

9. 总结:

  • springboot启动会加载大量的自动配置类
  • 我们看我们需要的功能有没有自动配置类
  • 我们在来看这个自动配置类中到底注册了那些组件（只要有我们要用的组件，就不需要来配置了）
  • 给容器中自动配置类添加组件的时候，会从从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值；

10. debug=true

我们可以通过启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置
类生效；

=========================
AUTO-CONFIGURATION REPORT
=========================


Positive matches:
-----------------

   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
      - @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)
 
 
 Negative matches:
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
小么嘛小二郎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot2 系列教程(七)理解自动化配置的原理
江南一点雨的专栏
09-23 2045
Spring Boot 中的自动化配置确实够吸引人，甚至有人说 Spring Boot 让 Java 又一次焕发了生机，这话虽然听着有点夸张，但是不可否认的是，曾经臃肿繁琐的 Spring 配置确实让人感到头大，而 Spring Boot 带来的全新自动化配置，又确实缓解了这个问题。 你要是问这个自动化配置是怎么实现的，很多人会说不就是 starter 嘛！那么 starter 的原理又是什么呢？...
SpringBoot(7) 自动配置原理
不负年华
04-12 215
大家有没有想过，SpringBoot的配置文件到底能写什么？如何写？懂自动配置原理就懂能写什么！ 【点我查看官方】配置文件属性参照 一，自动配置原理 1），SpringBoot启动的时候加载主配置类，由 @EnableAutoConfiguration开启了自动配置功能。 2），@EnableAutoConfiguration 作用。 利用 AutoConfigurationImportSel...
spring boot 自动配置调试
热门推荐
乔志勇笔记
02-28 1万+
在application.properties中加debug=true分析 Positive matches:和 Negative matches:和Exclusions:和Unconditional classes:
解决springboot项目Positive matches: AopAutoConfiguration matched: 报错
qq_54302777的博客
03-09 776
解决springboot项目Positive matches: AopAutoConfiguration matched: 报错
笔记2
ljcgit的博客
03-30 214
1.Servlet 使用@ServletComponentScan+@WebServlet注解实现 定义一个类用@WebServlet(urlPatterns = “url路径”)注解修饰； urlPatterns表示映射的url路径 新创建的类继承HttpServlet类，可以重写里面的doGet等方法； @ServletComponentScan(basePackages = “包路径”)使...
Spring Boot自动化配置原理
12-22
Spring Boot自动化配置原理依赖于 @Conditional 注解来实现： @Conditional是Spring4提供的一个新特性用于根据条件来控制Bean的创建行为。 我们从大家熟知的Spring Boot 的启动类开始 @SpringBootApplication public...
Spring Boot：启动原理解析.docx
最新发布
11-20
这些注解的结合使用，使得 Spring Boot 能够自动配置和扫描应用程序的组件。 1. @Configuration 注解 @Configuration 注解是 JavaConfig 形式的 Spring IoC 容器的配置类使用的那个注解。它表明该类是一个配置类，...
初识Spring Boot框架之Spring Boot的自动配置
08-30
1. **什么是Spring Boot自动配置**： Spring Boot自动配置通过`@EnableAutoConfiguration`注解启动。它会查找类路径中的`META-INF/spring.factories`文件，该文件包含了所有可用的自动配置类。这些配置类会根据项目...
Spring Boot中自动化配置的利弊以及解决方法
08-29
Spring Boot自动化配置的原理：Spring Boot的自动化配置是通过 Condition 和 ConditionalOnClass 等注解来实现的。这些注解可以根据不同的条件来决定是否加载自动化配置。例如，ConditionalOnClass 注解可以根据类...
springboot整合swagger2依赖冲突问题解决思路
qq_45823787的博客
07-11 6467
实验环境 1.swagger版本 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.9.2</version> </dependency> <depende
SpringBoot配置笔记超详细版
weixin_42759988的博客
02-16 3109
一、配置文件：文件名是固定的 --SpringBoot使用一个全局的配置文件 application.properties application.yml 配置文件的作用：修改SpringBoot自动配置的默认值 SpringBoot在底层都给我们自动配置好 配置文件放在src/main/resources目录或者类路径/config下 yml是YAML(YAML Ain't ...
Springboot自动配置生效原理分析
我能在河边钓一整天的鱼
05-09 675
目录 自动装配原理举例分析 自动装配的精髓 自动配置类是怎么生效的 自动装配原理举例分析 以HttpEncodingAutoConfiguration类（Http编码自动配置）为例解释自动配置原理； //表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件； @Configuration //启动指定类的ConfigurationProperties功能； //进入这个HttpProperties查看，将配置文件中对应的值和HttpProperties绑..
Spring Boot 探索 | Actuator 端点详细说明
挖坑埋你
12-25 1万+
先在这里声明一下：这一系列的文章都是自己查询网上资料学习而来，不可避免有些内容从其他地方copy过来，如有侵犯请联系我删除，谢谢！（引用部分都会添加注脚） 本系列文章的写作环境为：Spring Boot 1.5.18.RELEASE、JDK 1.8.0_131、IntelliJ IDEA ULTIMATE 2018.1。并没有使用最新版本的Spring Boot进行学习，新版本还不稳定，存在...
报错：程序报错并打印CONDITIONS EVALUATION REPORT Positive matches:
你今天真好看呀
07-31 1701
============================ CONDITIONS EVALUATION REPORT Positive matches: CodecsAutoConfiguration matched: - @ConditionalOnClass found required class ‘org.springframework.http.codec.CodecConfigurer’ (OnClassCondition) CodecsAutoConfiguration.JacksonCodec
SpringBoot的自动配置原理
art_code的博客
04-18 223
SpringBoot的自动配置原理 自动配置原理 配置文件到底能写什么?怎么写?自动配置原理; 配置文件能配置的属性参照 ：https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#common-application-properties 1、自动配置原理: 1)、Sp...
Spring Boot 核心(二)
ETFOX
05-13 709
。。。
Springboot 使用 Gson 并排除 Fastjson 和 Jackson
Nelson.Feng 的专栏
01-12 2322
众所周知，Gson、Fastjson、Jackson 各有优缺点，此处不赘述，看到本文的肯定是已经决定让 Springboot 项目完全使用 Gson 了，直接上内容！ 在 pom 依赖中排除掉所有的 fastjson 和 jackson，此处可能需要打印依赖树。 mvn dependency:tree 1、排除依赖，包括但不限于以下 <exclusions> <exclusion> <artifactId>jackson-core&l
SpringBoot(四) SpringBootBean扫描介入及自动装配
u012098021的博客
12-31 1653
这里开始分析SpringBoot如何让spring扫描并自动装配。 BeanDefition 这里需要提到Spring一个重要知识点—BeanDefition。Spring实例化bean是一个复杂的过程，不仅仅金是new出实例，Bean有很多属性例如作用域、懒加载、别名等。Spring通过BeanDefition记录bean构造时的属性值、构造函数参数值以及具体实现提供的进一步信息。 核心-SpringBoot扫描bean Spring 启动过程首先扫描获取所有BeanDefition，放入一个map中，然
SpringBoot-起步依赖与自动装配原理
sinat_41847989的博客
12-11 1425
简化开发，约定大于配置，开箱即用，提供了各种默认配置来简化项目 1. 起步依赖分析 在起步依赖上，SpringBoot 帮我们管理了各个依赖的版本，使各个依赖不会出现版本冲突；另外，Spring Boot还帮我们打包了各个依赖让不用再像之前使用Spring那样导入一堆的依赖，只要引入起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的用。 pom.xml 配置文件 spring-boot-dependencies： 核心依赖在父工程 spring-boot-starter-parent 中，部分坐
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值