本文将介绍SpringBoot的自动配置，到底是怎么做到？的详细情况，特别是关于springboot自动化配置的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉
本文将介绍Spring Boot 的自动配置，到底是怎么做到？的详细情况，特别是关于spring boot自动化配置的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于DIY一个Spring Boot的自动配置、Idea 打包maven项目 以及spring boot 的自动配置、Spring Boot 中自定义 SpringMVC 配置，到底继承谁？、Spring Boot 关闭特定的自动配置的知识。
本文目录一览：- Spring Boot 的自动配置，到底是怎么做到？（spring boot自动化配置）
- DIY一个Spring Boot的自动配置
- Idea 打包maven项目 以及spring boot 的自动配置
- Spring Boot 中自定义 SpringMVC 配置，到底继承谁？
- Spring Boot 关闭特定的自动配置
Spring Boot 的自动配置，到底是怎么做到？（spring boot自动化配置）
链接：juejin.im/post/5b679fbc5188251aad213110
SpringBoot 的故事从一个面试题开始
Spring Boot、Spring MVC 和 Spring 有什么区别？
先来个 SpringBoot 的启动结构图
分开描述各自的特征
Spring 框架就像一个家族，有众多衍生产品例如 boot、security、jpa等等。但他们的基础都是Spring 的ioc和 aop，ioc 提供了依赖注入的容器， aop解决了面向横切面的编程，然后在此两者的基础上实现了其他延伸产品的高级功能。
Spring MVC提供了一种轻度耦合的方式来开发web应用。它是Spring的一个模块，是一个web框架。通过Dispatcher Servlet, ModelAndView 和 View Resolver，开发web应用变得很容易。解决的问题领域是网站应用程序或者服务开发——URL路由、Session、模板引擎、静态Web资源等等。
Spring Boot实现了自动配置，降低了项目搭建的复杂度。它主要是为了解决使用Spring框架需要进行大量的配置太麻烦的问题，所以它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。同时它集成了大量常用的第三方库配置(例如Jackson, JDBC, Mongo, Redis, Mail等等)，Spring Boot应用中这些第三方库几乎可以零配置的开箱即用(out-of-the-box)。
Tips：关注微信公众号：Java后端，每日技术博文推送。
所以，用最简练的语言概括就是
. Spring 是一个“引擎”;
. Spring MVC 是基于Spring的一个 MVC 框架;
. Spring Boot 是基于Spring4的条件注册的一套快速开发整合包。
SpringBoot到底是怎么做到自动配置的？
从代码里看项目SpringBoot的项目启动类只有一个注解@SpringBootApplication和一个run方法。
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}@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 {
@AliasFor(
annotation = EnableAutoConfiguration.class
)
Class<?>[] exclude() default {};
@AliasFor(
annotation = EnableAutoConfiguration.class
)
String[] excludeName() default {};
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackages"
)
String[] scanBasePackages() default {};
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackageClasses"
)
Class<?>[] scanBasePackageClasses() default {};
}@Configuration
对比一下传统XML方式和config配置方式的区别：
XML声明和定义配置方式
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
">
<bean id="app" class="com..." />用一个过滤器举例，JavaConfig的配置方式是这样
@Configuration
public class DruidConfiguration {
@Bean
public FilterRegistrationBean statFilter(){
//创建过滤器
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
//设置过滤器过滤路径
filterRegistrationBean.addUrlPatterns("/*");
//忽略过滤的形式
filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
}任何一个标注了@Bean的方法，其返回值将作为一个bean定义注册到Spring的IoC容器，方法名将默认成该bean定义的id。
@ComponentScan
我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，如果不指定，则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。
注：所以SpringBoot的启动类最好是放在rootpackage下，因为默认不指定basePackages。
@EnableAutoConfiguration
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}SpringFactoriesLoader详解
public abstract class SpringFactoriesLoader {
//...
public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
...
}
public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
....
}
}AutoConfigurationImportSelector
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
configurations = this.removeDuplicates(configurations);
Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
this.checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
configurations = this.filter(configurations, autoConfigurationMetadata);
this.fireAutoConfigurationImportEvents(configurations, exclusions);
return StringUtils.toStringArray(configurations);
}
}protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
}public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
String factoryClassName = factoryClass.getName();
return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration@org.springframework.context.annotation.Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnBean({DataSource.class})
@EnableConfigurationProperties({MybatisProperties.class})
@AutoConfigureAfter({DataSourceAutoConfiguration.class})
public class MybatisAutoConfiguration
{
private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
private final MybatisProperties properties;
private final Interceptor[] interceptors;
private final ResourceLoader resourceLoader;
private final DatabaseIdProvider databaseIdProvider;
private final List<ConfigurationCustomizer> configurationCustomizers;<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>- End -
技术连载目录（可点击跳转即可阅读）：
Maven系列教程 点击--> Maven技术干货连载目录 跳转
MyBatis系列教程 点击--> MyBatis技术干货连载目录 跳转
JVM调优总结系列教程 点击--> JVM调优技术干货连载目录 跳转
点击在看,愿你我不再陌生
本文分享自微信公众号 - 程序员书单（CoderBooklist）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。
DIY一个Spring Boot的自动配置
按：最近公众号文章主要是整理一些老文章，以个人CSDN上的博客为主，也会穿插一些新的技术点。
在上篇博客初识Spring Boot框架中我们初步见识了SpringBoot的方便之处，很多小伙伴可能也会好奇这个Spring Boot是怎么实现自动配置的，那么今天我就带小伙伴我们自己来实现一个简单的Spring Boot 自动配置的案例，看看这一切到底是怎么发生的。
假设我的需求是这样的：当我的项目中存在某个类的时候，系统自动为我配置该类的Bean，同时，我这个Bean的属性还可以在application.properties中进行配置，OK，就这样一个需求，我们来看看怎么实现。
- 新建starter的Maven项目
我这里以IntelliJ IDEA创建Project为例，其实很简单，创建一个Maven项目，但是注意创建的时候选择quickstart，步骤如下：
OK，这样我们就创建好一个Project了。
2.添加依赖
由于我们要使用Spring Boot的自动配置功能，所以在工程创建成功之后首先要添加Spring Boot自身的自动配置作为依赖，如下：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<version>1.4.2.RELEASE</version>
</dependency>3.属性配置
@ConfigurationProperties(prefix = "hello")
public class HelloServiceProperties {
private static final String MSG = "world";
private String msg = MSG;
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}这里就是一个简单的类，和上篇博客中我们提到的 类型安全的属性获取是一致的，这里属性的值我们可以在application.properties中来直接设置，如果不设置的话默认为world。
4.判断依据类
public class HelloService {
private String msg;
public String sayHello(){
return "hello " + msg;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}我们一会的例子就是根据这个类是否存在来创建这个类的Bean，当然这个类也可以是第三方类库。
5.自动配置类
@Configuration
@EnableConfigurationProperties(HelloServiceProperties.class)
@ConditionalOnClass(HelloService.class)
@ConditionalOnProperty(prefix = "hello",value = "enable",matchIfMissing = true)
public class HelloServiceAutoConfiguration {
@Autowired
private HelloServiceProperties helloServiceProperties;
@Bean
public HelloService helloService() {
HelloService helloService = new HelloService();
helloService.setMsg(helloServiceProperties.getMsg());
return helloService;
}
}这里@ConditionalOnClass注解主要是用来判断HelloService这个类在路径中是否存在，在存在且容器中没有该类的Bean的情况下系统会自动配置需要的Bean，@ConditionalOnProperty注解则表示指定的属性要满足的条件，在helloService方法中我们则使用了HelloServiceProperties提供的参数。
6.注册配置
在resources目录下新建META-INF目录，然后在META-INF目录下创建spring.factories文件，文件内容如下，表示设置自动配置类的位置，若有多个配置类用”,”隔开即可。：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=org.sang.HelloServiceAutoConfiguration正常情况下我们按步骤一创建出来的Project是没有resources这个文件夹的，在IntelliJ IDEA这个工具中，我们需要先创建一个directory，然后将之设置为resources root即可，设置方式如下：选中resources目录右键单击—》Mark Directory as—》Resource Root。
7.在项目中使用
OK，经过上面几个步骤我们的自动配置功能就算死写好了，接下来我们要在自己的项目中来使用它了，正常情况下做好自动配置类之后我们需要将之上传到
maven 私服上然后直接在项目中引用，也可以将之安装到本地库，这里我选择后者的一个简化方式，直接创建Module来引用这个自动配置Module（如果小伙伴是用STS或者MyEclipse之类的开发工具直接创建新工程然后添加引用类库即可）。
创建Module方式很简单，选中刚才的Project右键单击，New一个Module，这个Module是一个SpringBoot项目（不清楚怎么创建SpringBoot项目可以查看这篇文章初识Spring Boot框架），创建成功之后选择新建的Module按F4打开Module设置，然后选择右边的加号添加依赖，如下：
然后在新建Module的pom.xml文件中添加如下依赖：
<dependency>
<groupId>org.sang</groupId>
<artifactId>org.sang.mystarter</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>实际上就是我们刚刚创建的自动配置文件的坐标。然后新Module的入口类中添加如下代码：
@Autowired
private HelloService helloService;
@RequestMapping("/")
public String index(){
return helloService.sayHello();
}使用刚刚创建的HelloService，如果需要我们可以在application.properties中添加如下配置：
hello.msg = 卖花担上看桃李, 拍酒楼头听管弦。运行Module，然后在浏览器中访问，结果如下：
.
OK，这就是一个简单的自定义自动配置类。
本案例下载地址：
本案例GitHub地址 https://github.com/lenve/JavaEETest/tree/master/Test19-MyStarter
以上。
参考资料：
《JavaEE开发的颠覆者 Spring Boot实战》第六章
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
