目录
一、运行原理探究
1、pom.xml文件
1.1、父依赖
1.2、启动器Spring-boot-starter
2、主启动类
2.1、默认的主启动类:
2.2、分析主启动类注解:@SpringBootApplication
1、@Target(ElementType.TYPE)
2、@Retention(RetentionPolicy.RUNTIME)
3、@Documented
4、@Inherited
5、@SpringBootConfiguration
@Configuration:说明这是一个配置类,配置类就是对应Spring的XML配置文件;
@Component:说明启动类本身也是Spring中的一个组件而已,负责启动应用。
6、@EnableAutoConfiguration
@AutoConfigurationPackage:自动配置包
@Import({AutoConfigurationImportSelector.class}) :给容器导入组件
7、结论:
2.3、分析主启动类:SpringApplication
2.3.1、主启动类开启一个服务
2.3.2、SpringApplication.run分析:
2.3.3、SpringApplication
一、运行原理探究
1、pom.xml文件
1.1、父依赖
它是一个父项目,主要是管理项目的资源过滤插件!
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
点进去还有一个父依赖:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.5.RELEASE</version>
<relativePath>../../spring-boot-dependencies</relativePath>
</parent>
注意:这里才是真正管理SpringBoot应用里面所有依赖版本的地方,SpringBoot的版本控制中心
以后我们导入依赖默认是不需要写版本;但是如果导入的包没有在依赖中管理着就需要手动 配置版本了。
1.2、启动器Spring-boot-starter
<!--web场景启动器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
- spring-boot-starter-xxx:就是spring-boot的场景启动器;
- spring-boot-starter-web:帮我们导入了web模块正常运行所依赖的组件;
SpringBoot将所有的功能场景都抽取出来,做成一个个的starter(启动器),只需要在项目种引入这些starter即可,所有相关的依赖都会导入进来,我们要用什么功能就导入什么样的场景启动器即可;我们未来也可以自己自定义starter。
2、主启动类
2.1、默认的主启动类:
//@SpringBootApplication 来标注一个主程序类
@SpringBootApplication
public class Springboot03WebApplication {
public static void main(String[] args) {
SpringApplication.run(Springboot03WebApplication.class, args);
}
}
2.2、分析主启动类注解:@SpringBootApplication
作用:标注在某个类上说明这个类是SpringBoot的主配置类,SpringBoot就应该运行这个类的main方法来启动SpringBoot应用;进入@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 {
/....省略......../
}
1、@Target(ElementType.TYPE)
作用:注释类型的上下文(即注解的作用目标),这里是接口、类、枚举、注解等;
2、@Retention(RetentionPolicy.RUNTIME)
作用:具有注释类型的注释要保留多长时间,这里注解是将被JVM保留,所以在运行时被JVM或其他使用了反射机制的代码所读取和使用;
3、@Documented
作用:默认情况下,带有类型的注释将由javadoc和类似工具记录;
4、@Inherited
作用:自动继承注释类型(即子类可以继承父类)。
5、@SpringBootConfiguration
作用:Spring的配置类,标注在某个类上,表示这是一个SpringBoot的配置类;
-
@Configuration:说明这是一个配置类,配置类就是对应Spring的XML配置文件;
-
@Component:说明启动类本身也是Spring中的一个组件而已,负责启动应用。
-
6、@EnableAutoConfiguration
作用:开启自动配置功能,这样自动配置才生效;以前我们需要手动配置的东西,现在SpringBoot可以自动帮我们配置;
-
@AutoConfigurationPackage:自动配置包
@Import(AutoConfigurationPackages.Registrar.class) public @interface AutoConfigurationPackage { }
- @Import:Spring底层注解@import,给容器中导入一个组件;
- Register.class作用:将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器;
-
@Import({AutoConfigurationImportSelector.class}) :给容器导入组件
- AutoConfigurationImportSelector:自动配置导入选择器,它会导入哪些组件的选择器呢?
①这个类中有一个获取候选配置的方法:getCandidateConfigurations
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
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;
}
//返回的是启动自动导入配置文件的注解类:EnableAutoConfiguration
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
return EnableAutoConfiguration.class;
}
②这个方法又调用了SpringFactoriesLoader类的静态方法:loadFactoryNames
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
String factoryTypeName = factoryType.getName();
return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}
③继续查看loadSpringFactories方法
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
//获得classloader,我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
if (result != null) {
return result;
} else {
try {
//去获取一个资源:"META-INF/spring.factories"
Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
LinkedMultiValueMap result = new LinkedMultiValueMap();
//将读取到的资源遍历,封装成为一个Properties
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
while(var6.hasNext()) {
Entry<?, ?> entry = (Entry)var6.next();
String factoryTypeName = ((String)entry.getKey()).trim();
String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
int var10 = var9.length;
for(int var11 = 0; var11 < var10; ++var11) {
String factoryImplementationName = var9[var11];
result.add(factoryTypeName, factoryImplementationName.trim());
}
}
}
cache.put(classLoader, result);
return result;
} catch (IOException var13) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
}
}
}
④发现一个多次出现的文件:spring.factories,从源头打开该配置文件
发现很多自动配置的文件,这就是自动配置根源所在
⑤WebMvcAutoConfiguration
以org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\配置为例:
可以看到这些一个个都是JavaConfig配置类,而且都注入了一些Bean。所以自动配置真正实现的是从classpath中搜寻所有的META-INF/spring.factories配置文件,并将其中对应的org.springframework.boot.autoconfigure包下的配置项,通过反射实例化为对应标注了@Configuration注解的JavaConfig形式的IOC容器配置类,然后将这些都汇总成为一个实例并加载到IOC容器中。
7、结论:
- SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值;
- 将这些值作为自动配置类导入容器,自动配置类就生效,帮我们进行自动配置工作;
- 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中;
- 它会给容器中导入非常多的自动配置类(xxxAutoconfiguration),就是给容器中导入这个场景需要的所有组件,并配置好这些组件。
- 有了自动配置类,免去了我们手动编写配置注入功能组件等的工作。
2.3、分析主启动类:SpringApplication
2.3.1、主启动类开启一个服务
//@SpringBootApplication 来标注一个主程序类
@SpringBootApplication
public class Springboot03WebApplication {
public static void main(String[] args) {
SpringApplication.run(Springboot03WebApplication.class, args);
}
}
2.3.2、SpringApplication.run分析:
分析该方法主要分为两部分:
一是SpringApplication的实例化;
二是run方法的执行。
2.3.3、SpringApplication
这个类主要做了一下四件事情:
- 推断应用的类型是普通项目还是web项目;
- 查找并加载所有可用的初始化器,设置到initializers属性中;
- 找出所有的应用程序监听器,设置到listeners属性中;
- 推断并设置main方法的定义类,找到运行的主类。
查看构造器:
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
//.....
this.webApplicationType = WebApplicationType.deduceFromClasspath();
this.setInitializers(
this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass = this.deduceMainApplicationClass();
}
run方法流程分析: