SpringBoot 学习之自动配置讲解

最新推荐文章于 2024-04-28 05:57:55 发布
最新推荐文章于 2024-04-28 05:57:55 发布
阅读量484 收藏
点赞数
分类专栏： Java springBoot 文章标签： spingBoot自动配置 EnableConfigurationProperties
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fw19940314/article/details/81412201
版权

       今天说一下SpringBoot自动配置的原理，在我们之前进行的web项目开发过程中，配置文件配置繁琐，如果是多个框架集成的话可能还维护多个配置文件。这样会将我们的很多时间去花在维护配置文件，假如加一个小的功能可能就需要一个繁杂的配置。到了SpringBoot后，这种情况就大大的改善，甚至于我们如果使用了默认的配置，我们就无需再去为这些配置文件所耗费时间，专心的去考虑我们的业务功能该如何实现了。

       SpringBoot是如何做到的我们之前的那么多配置项没有看到在哪里配置的，就起到了我们想要的效果呢？首先我们先创建一个web项目，通过IDEA工具，可以直接创建一个能运行的web项目，这里我就不演示了。创建完成后就是一个这样目录结构，而且还有默认的启动类。

     开始正题；SpringBoot自动配置主要还是依赖启动类中的@springBootApplication,我们点开这个注解，可以看到

自动配置原理：

   SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration；

  @EnableAutoConfiguration 作用:

     利用EnableAutoConfigurationImportSelector给容器中导入一些组件；我们可以在点击@EnableAutoConfiguration看他底层是如何实现的；如图

可以看到@Import(AutoConfigurationImportSelector.class)；一直点下去，我们会看到AutoConfigurationImportSelector类中的getCandidateConfigurations方法；

     

可以看到自动选择器类中的；List<String> configurations =SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());方法；通过SpringFactoriesLoader.loadFactoryNames()加载了什么？继续点击loadFactoryNames()往下找；

 

可以看到SpringFactoriesLoader类中，做了哪些操作；

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					List<String> factoryClassNames = Arrays.asList(
							StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
					result.addAll((String) entry.getKey(), factoryClassNames);
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

  1. SpringFactoriesLoader.loadFactoryNames()

  2. 扫描所有jar包类路径下 META‐INF/spring.factories

  3. 把扫描到的这些文件的内容包装成properties对象

  •  从properties中获取到EnableAutoConfiguration.class类(类名)对应的值，然后把他们添加在容器中；

将 类路径下 META-INF/spring.factories 里面配置的所有EnableAutoConfiguration的值加入到了容器中;

  • # 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.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
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.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
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.RedisReactiveAutoConfiguration,\
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.flyway.FlywayAutoConfiguration,\
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.http.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
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.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
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.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.core.ReactorCoreAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.OAuth2ClientAutoConfiguration,\
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.client.RestTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
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,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

          可以具体看一下自动配置类为我们做了哪些东西；发现我们经常用到的基本上SpringBoot都为我们考虑到了，已经将配置加入到容器中；而且这些配置类都有一个共同的特征就是以**AutoConfiguration结尾，每一个自动配置，就是通过配置类将配置加载到容器中；如果熟悉sping配置的都知道，我们想使用某种功能的时候，也都是将具体的配置配置到spring的容器中，这里springBoot已经将我们自动配置好了；

SpringBoot的自动配置是如何配置的呢？我们是否可以根据自己的需要定制化配置呢？下面我们就看一下到底这个自动配置是如何实现的，我们自己如果写的话，该怎么来定制化的配置。

      首先我们需要先熟悉两个注解：

      @Component  //将POJO对象注入到容器中，就是将每个属性值映射到容器中

      @ConfigurationProperties //告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定;  prefix = "":配置文件中哪个下面的所有属性进行一一映射

       我用一个小例子来演示一下这两个注解的作用，我们通过配置文件的形式来读取配置文件中的属性值（就是解释后面为什么我们在配置文件中配置完属性值后SpringBoot是如何解析到的）；

    首先我们见两个实体类，一个Cat类一个Person类；


public class Cat {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private int age;
    private List<String> list;
    private List<Cat> listCat;
    private Map<String,String> map;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", list=" + list +
                ", listCat=" + listCat +
                ", map=" + map +
                '}';
    }

    public List<Cat> getListCat() {
        return listCat;
    }

    public void setListCat(List<Cat> listCat) {
        this.listCat = listCat;
    }

然后我们在配置文件中，给这些属性赋值，再通过这些类的对象，看能否取到我们在配置文件中给这些属性赋的值；

配置文件application.yml(springBoot默认的配置文件是application.properties&application.yml)这两个springBoot都识别，只是使用了不同的语法；我这里使用的.yml的配置；详细的yml语法可以上网查一下资料，这里就不一一赘述了，下面就是我们通过配置文件给实体类属性赋的值；

server:
  port: 8081
person:
  name: jerry
  age: 24
  list:
    - tom
    - jack
  listCat:
    - cat:
      name: mary
      age: 4
    - cat:
      name: rose
      age: 30
  map:
   {k1: v1,k2: 12}

赋值完成后，肯定就要取值，这里我们就使用项目自动生成的测试类，来打印一下我们的生成的值；

 我们通过@ConfigurationProperties注解，配置注解prefix属性是可以将配置文件中的值，成功的读取到，并注入到容器中；

  接下来我们看一下SpringBoot的自动配置的如何获取到这些值得；首先我们还是找个一个自动配置类来讲，因为每一个配置类都是这样实现的，我们就随便在配置类中找一个；

org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\

这里我们也不找别的就找我们最熟悉的完成web项目必须的DispatcherServle这个配置，如果你对springMVC框架比较熟悉，而且用过SpringMvc框架进行过开发，应该对DispatcherServlet很熟悉的一个配置；我们看一下SpringBoot是如何替我们办了这件事；

首先找到这个类；

/**
 * {@link EnableAutoConfiguration Auto-configuration} for the Spring
 * {@link DispatcherServlet}. Should work for a standalone application where an embedded
 * web server is already present and also for a deployable application using
 * {@link SpringBootServletInitializer}.
 *
 * @author Phillip Webb
 * @author Dave Syer
 * @author Stephane Nicoll
 * @author Brian Clozel
 */
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
@EnableConfigurationProperties(ServerProperties.class)
public class DispatcherServletAutoConfiguration {

	/*
	 * The bean name for a DispatcherServlet that will be mapped to the root URL "/"
	 */
	public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";

	/*
	 * The bean name for a ServletRegistrationBean for the DispatcherServlet "/"
	 */
	public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";

	@Configuration
	@Conditional(DefaultDispatcherServletCondition.class)
	@ConditionalOnClass(ServletRegistration.class)
	@EnableConfigurationProperties(WebMvcProperties.class)
	protected static class DispatcherServletConfiguration {

		private final WebMvcProperties webMvcProperties;

		private final ServerProperties serverProperties;

		public DispatcherServletConfiguration(WebMvcProperties webMvcProperties,
				ServerProperties serverProperties) {
			this.webMvcProperties = webMvcProperties;
			this.serverProperties = serverProperties;
		}

		@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
		public DispatcherServlet dispatcherServlet() {
			DispatcherServlet dispatcherServlet = new DispatcherServlet();
			dispatcherServlet.setDispatchOptionsRequest(
					this.webMvcProperties.isDispatchOptionsRequest());
			dispatcherServlet.setDispatchTraceRequest(
					this.webMvcProperties.isDispatchTraceRequest());
			dispatcherServlet.setThrowExceptionIfNoHandlerFound(
					this.webMvcProperties.isThrowExceptionIfNoHandlerFound());
			return dispatcherServlet;
		}

		@Bean
		@ConditionalOnBean(MultipartResolver.class)
		@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
		public MultipartResolver multipartResolver(MultipartResolver resolver) {
			// Detect if the user has created a MultipartResolver but named it incorrectly
			return resolver;
		}

		@Bean
		public DispatcherServletPathProvider mainDispatcherServletPathProvider() {
			return () -> DispatcherServletConfiguration.this.serverProperties.getServlet()
					.getPath();
		}

	}

截取部分，全部截取的话占的篇幅太多；我们可以看到这个自动配置类身上有一大堆的注解；可以看一下具体都起到了什么作用：

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)

@Configuration

@ConditionalOnWebApplication(type=Type.SERVLET)

@ConditionalOnClass(DispatcherServlet.class)

@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)

@EnableConfigurationProperties(ServerProperties.class)

首先第一个@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)，如果对之前springMVC那套配置比较熟悉的话，这个配置大概能知道什么意思，Order就是我们之前配置的使用顺序，再来看下Order接口的源码如下，一目了然，值越小优先级越高，即被优先加载（precedence即优先级）：

     /**
	 * Useful constant for the highest precedence value. //最高优先值常数
	 * @see java.lang.Integer#MIN_VALUE
	 */
	int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;

就是我们在有相同配置的情况下，谁的值越小优先级越高，

第二个注解@Configuration，这个我们应该都很清楚了表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件；

第三个注解@ConditionalOnWebApplication Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效; 判断当前应用是否是web应用，如果是，当前配置类生效

第四个注解：@ConditionalOnClass  当前有没有某个类，这里传入的是DispatcherServlet.class，是否有DispatcherServlet这个类，如果有这个配置文件才会生效，

第五个注解：@AutoConfigureAfter  定义这些配置类的载入顺序。

*重点 第六个注解：@EnableConfigurationProperties 启动指定类的ConfigurationProperties功能;将配置文件中对应的值和ServerProperties绑定起来;并把ServerProperties加入到ioc容器中；

什么意思呢？我们可以据需看EnableConfigurationProperties是如何实现的，这里的配置类的属性是ServerProperties，就是我们配置的一些服务信息的配置；端口，地址之类；

@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;

	@NestedConfigurationProperty
	private final ErrorProperties error = new ErrorProperties();

	/**
	 * Whether X-Forwarded-* headers should be applied to the HttpRequest.
	 */
	private Boolean useForwardHeaders;

	/**
	 * Value to use for the Server response header (if empty, no header is sent).
	 */
	private String serverHeader;

	/**
	 * Maximum size, in bytes, of the HTTP message header.
	 */
	private int maxHttpHeaderSize = 0; // bytes

	/**
	 * Time that connectors wait for another HTTP request before closing the connection.
	 * When not set, the connector's container-specific default is used. Use a value of -1
	 * to indicate no (that is, an infinite) timeout.
	 */
	private Duration connectionTimeout;

我截取了部门，可以看到这里面正是我们前面做的那个小测试，使用的方法，该如何读取到配置文件里的参数值，正是运用了@ConfigurationProperties这个注解，可以看到这个类中的属性名，就是我们配置的具体属性；

而我们DispatcherServlet配置相关就是我们前面截取的DispatcherServletAutoConfiguration自动配置类，而mvc配置在哪，我们可以看具体的方法；随便挑一个，方法实现配置，就拿web的mvc配置来讲；前面已经复制过这段代码，为了更清楚我们抽出来说；

@Configuration
	@Conditional(DefaultDispatcherServletCondition.class)
	@ConditionalOnClass(ServletRegistration.class)
	@EnableConfigurationProperties(WebMvcProperties.class)
	protected static class DispatcherServletConfiguration {

		private final WebMvcProperties webMvcProperties;

		private final ServerProperties serverProperties;

		public DispatcherServletConfiguration(WebMvcProperties webMvcProperties,
				ServerProperties serverProperties) {
			this.webMvcProperties = webMvcProperties;
			this.serverProperties = serverProperties;
		}

		@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
		public DispatcherServlet dispatcherServlet() {
			DispatcherServlet dispatcherServlet = new DispatcherServlet();
			dispatcherServlet.setDispatchOptionsRequest(
					this.webMvcProperties.isDispatchOptionsRequest());
			dispatcherServlet.setDispatchTraceRequest(
					this.webMvcProperties.isDispatchTraceRequest());
			dispatcherServlet.setThrowExceptionIfNoHandlerFound(
					this.webMvcProperties.isThrowExceptionIfNoHandlerFound());
			return dispatcherServlet;
		}

		@Bean
		@ConditionalOnBean(MultipartResolver.class)
		@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
		public MultipartResolver multipartResolver(MultipartResolver resolver) {
			// Detect if the user has created a MultipartResolver but named it incorrectly
			return resolver;
		}

		@Bean
		public DispatcherServletPathProvider mainDispatcherServletPathProvider() {
			return () -> DispatcherServletConfiguration.this.serverProperties.getServlet()
					.getPath();
		}

	}

 

看一下这个类的配置文件@EnableConfigurationProperties(WebMvcProperties.class)，WebMvcProperties.class；类中的具体属性；

@ConfigurationProperties(prefix = "spring.mvc")
public class WebMvcProperties {


public static class Servlet {

		/**
		 * Load on startup priority of the dispatcher servlet.
		 */
		private int loadOnStartup = -1;

		public int getLoadOnStartup() {
			return this.loadOnStartup;
		}

		public void setLoadOnStartup(int loadOnStartup) {
			this.loadOnStartup = loadOnStartup;
		}

	}
public static class View {

		/**
		 * Spring MVC view prefix.
		 */
		private String prefix;

		/**
		 * Spring MVC view suffix.
		 */
		private String suffix;

		public String getPrefix() {
			return this.prefix;
		}

		public void setPrefix(String prefix) {
			this.prefix = prefix;
		}

		public String getSuffix() {
			return this.suffix;
		}

		public void setSuffix(String suffix) {
			this.suffix = suffix;
		}

	}

     只截取了部分；看到我们之前所使用的这些配置都在这里有相应的属性；他是通过ConfigurationProperties注解中的spring.mvc来读取配置文件中的属性值，那我们就可以直接在配置文件中使用spring.mvc.属性=值 的形式来给配置文件属性赋值；

总结：

1)、SpringBoot启动会加载大量的自动配置类

2)、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类;

3)、我们再来看这个自动配置类中到底配置了哪些组件;(只要我们要用的组件有，我们就不需要再来配置了)

4)、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在配置文件中指定这 些属性的值;

xxxxAutoConfigurartion:自动配置类; 给容器中添加组件

xxxxProperties:封装配置文件中相关属性;

SpringBoot的自动配置大大简化了我们的配置过程，可以让我们专注于业务的开发。

 

fw19940314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Springboot】| 从深入自动配置原理到实现 自定义Springboot starter
狮子也疯狂的博客
08-27 3413
是SpringBoot的一个重要概念，是“一站式服务 (one-stop)”的依赖 Jar 包包含 Spring 以及相关技术(比如 Redis)的所有依赖提供了自动配置的功能，开箱即用提供了良好的依赖管理，避免了包遗漏、版本冲突等问题。简单来说， Springboot starter 提供了一种自动配置的机制，我们只需要将需要的Starter引入项目中，它就会自动为我们配置相关的依赖和配置。这使得开发人员可以更加关注业务逻辑的实现；现在我们来学习一下它的原理，以便后面能更清晰地实现。这个技能对你有用么。
SpringBoot---自动配置【快乐的源码环节】
wowo
12-06 637
6、自动配置 a)、自动包加载规则 分析SpringBoot底层 首先来到主程序中找到SpringBoot注解@SpringBootApplication，进入源码，可以明显地发现这个注解是由 @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excludeFilters = {@Filter( type = FilterType.CUSTOM, classes = {TypeExcludeF...
Spring Security 实战干货：Spring Boot 中的 Spring Security 自动配置初探
码农小胖哥
10-14 2454
1. 前言 我们在前几篇对 Spring Security 的用户信息管理机制，密码机制进行了探讨。我们发现 Spring Security Starter相关的 Servlet 自动配置都在spring-boot-autoconfigure-2.1.9.RELEASE（当前 Spring Boot 版本为2.1.9.RELEASE） 模块的路径org.springframework.boot....
Error processing condition on org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConf
qq_53205955的博客
03-02 3173
Error processing condition on org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConf 这是依赖重复的问题，仔细检查你的依赖jar包，看是否有相同的jar包
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration
slxz001的博客
08-16 2381
异常描述 Springboot整合activiti6.0，启动项目时异常 java.lang.IllegalArgumentException: Could not find class [org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration] at org.springframework.util.ClassUtils.resolveClassName(ClassUtils.java:334) ~[sprin
04.Spring Boot 中的 Spring Security 自动配置初探
qq_43409973的博客
08-17 331
我们在前几篇对 Spring Security 的用户信息管理机制，密码机制进行了探讨。我们发现相关的Servlet自动配置都在（当前 Spring Boot 版本为） 模块的路径之下。其实官方提供的Starter组件的自动配置你都能在下找到。今天我们进一步来解密在的配置和使用。本文主要对 Spring Security 在 Spring Boot 中的自动配置一些机制进行了粗略的讲解。为什么没有细讲。因为从学习出发有些东西不是我们必须要深入了解的，但是又要知道一点点相关的知识。
Spring Boot面试杀手锏————自动配置原理
热门推荐
Morty的技术乐园
11-07 19万+
引言 不论在工作中，亦或是求职面试，Spring Boot已经成为我们必知必会的技能项。除了某些老旧的政府项目或金融项目持有观望态度外，如今的各行各业都在飞速的拥抱这个已经不是很新的Spring启动框架。 当然，作为Spring Boot的精髓，自动配置原理的工作过程往往只有在“面试”的时候才能用得上，但是如果在工作中你能够深入的理解Spring Boot的自动配置原理，将无往不利。 Spr...
5步带你玩转SpringBoot自定义自动配置那些知识点_springboot自定义配置类和配置文件
最新发布
2401_83977605的博客
04-28 733
要引入自定义Starter，我们需要在应用程序的pom.xml文件中添加Starter依赖关系。当我们添加这个依赖项时，Spring Boot会自动加载Starter中的自动配置类，并根据这些类自动配置应用程序。一旦我们引入了自定义Starter，我们就可以使用其中定义的Bean了。@Autowired在这个例子中，Spring会自动注入"MyBean"，并将其添加到应用程序的上下文中。上述就是如何创建、引入和使用自定义。
springboot自动配置流程
m0_51287945的博客
11-17 913
springboot自动配置功能
springboot自动配置没有生效的问题定位（条件断点）
08-25
在Spring Boot应用中，自动配置是其核心特性之一，它能根据依赖的jar包自动配置相关的Bean。然而，有时候我们可能会遇到自动配置没有生效的问题，这可能是由于多种原因导致的，比如配置不符合条件、缺少依赖或者...
聊聊spring boot的ErrorWebFluxAutoConfiguration
weixin_30783629的博客
07-10 682
　　序　　　　本文主要研究一下spring boot的ErrorWebFluxAutoConfiguration　　　　ErrorWebFluxAutoConfiguration　　　　spring-boot-autoconfigure-2.1.5.RELEASE-sources.jar!/org/springframework/boot/autoconfigure/web/reacti...
springboot中想要查找redis的配置项有哪些，怎么做？
c8051f340t的博客
06-14 490
springboot中想要查找redis的配置项有哪些，怎么做？ 这个方法不仅仅适用redis，还包括其他的。具体步骤如下： 1.先找到spring-boot-autoconfigure的jar包，在META-INF目录中找到spring.factories文件。 （或者直接全局搜索spring.factories文件） 2.打开这个文件，在文件中搜索redis，可以找到如下相关项： org.springframework.boot.autoconfigure.data.redis.RedisA
SpringBoot——自动配置原理
如不來的博客
03-20 214
1、SpringBoot启动时加载主配置类，主配置类中开启了自动配置功能：@EnableAutoConfigration @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration ...
java.lang.IllegalStateException: Error processing condition on org.springframework.boot.autoconfigur
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
06-01 2万+
在开发springboot项目时，我们整合了一些第三方的依赖，前几天是可以正常运行的，然后我添加了糊涂的jar包，出现了报错，我以为是糊涂冲突导致的，但是注释掉了jar包，还是报错，
Error processing condition on org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
chuju3227的博客
07-12 9999
spring-boot启动时报如下异常 java.lang.IllegalStateException: Error processing condition on org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration....
Spring Security 自动装配
weixin_30263073的博客
06-15 217
1、自动装配的配置类 org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration　　　　　　　　 // 自动装配类 注册DefaultAuthenticationEventPublisher org.springframework.boot.autoconfi...
Unable to read meta-data for class org.springframework.boot.autoconfigure.cloud.CloudAutoConfigurati
SCGH_Fx的专栏
05-16 6364
在执行jar包的时候，SpringBoot提示 java.lang.IllegalStateException: Unable to read meta-data for class org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration at org.springframework.boot.au...
spring解密后的class如何装载_Springboot之spring-boot-autoconfigure模块
weixin_36197581的博客
01-25 148
一、前言Spring的出现给我们管理bean的依赖注入提供了便捷，但是当我们需要使用通过pom引入的jar里面的一个bean时候，还是需要手动在xml配置文件里面主要注入的bean 。springboot则可以依据classpath里面的依赖内容来自动配置bean到IOC容器，Auto-configuration会尝试推断哪些beans是用户可能会需要的。比如如果HSQLDB包在当前classpa...
springboot集成springSecurity 普通版（非oauth2）
qqzhengwei的专栏
02-25 555
学习springSecurity之前，首先要了解springSecurity能够干些什么事情？能够处理哪些东西？ 参考 1、https://blog.csdn.net/qq_22172133/category_8615344.html 2、https://blog.csdn.net/wangooo/article/details/113922946写的很不错的 3、https://blog.csdn.net/weixin_38927257/article/details/10296...
SpringBoot入门：自动配置与激光振镜应用详解
2. **自动配置（@EnableAutoConfiguration）**：这是SpringBoot的核心特性之一，它通过分析应用的类路径来自动识别并配置相关的bean，如web应用的Servlet和控制器。@EnableAutoConfiguration注解用于启用了这种自动...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值