大家都知道基于spring-boot的spring应用,启动处理源于一个注解@SpringBootApplication
,启动应用运行main方法就可以执行整个spring应用的上下文建立、bean注册等操作。所以这是进行分析的入口。
基本的几种启动方式
基于spring boot的启动应用方式其实也是有不同的,分析之前可以简单罗列一下。
第一种
第一种是最常见的直接不设置任何参数启动
@SpringBootApplication
public class CommonSpringApplication {
public static void main(String[] args) {
SpringApplication.run(CommonSpringApplication.class, args);
}
}
第二种
第二种就是可以先建立一个SpringApplication
对象,然后利用这个对象进行相应的参数设置,配置以及一些其他属性设置,这里还可以尝试输出获得的spring 应用上下文,可以看到是AnnotationConfigEmbeddedWebApplicationContext,是一个注解驱动的上下文。
@SpringBootApplication
public class SpringApplication1 {
public static void main(String[] args) {
SpringApplication springApplication = new SpringApplication(SpringApplication1.class);
Map<String, Object> properties = new LinkedHashMap<>();
properties.put("server.port", "8081");
//设置启动参数
springApplication.setDefaultProperties(properties);
//运行spring应用并且获得上下文
ConfigurableApplicationContext applicationContext = springApplication.run(args);
System.out.println(applicationContext.getClass());
System.out.println(applicationContext.getBean(SpringApplication1.class).getClass());
}
}
第三种
第三种可以改用SpringApplicationBuilder
方式进行构建应用,同样可以设置参数,另外可以使用fluent风格代码进行编写
@SpringBootApplication
public class SpringApplication2 {
public static void main(String[] args) {
new SpringApplicationBuilder(SpringApplication2.class)
.properties("server.port=0")//0表示随机获取端口
.run(args);
//fluent风格构建spring应用
}
}
如何判定启动何种spring应用
上面的基本使用方式都是基于引入spring-boot-starter-web来进行操作的,启动应用都是启动一个基于tomcat的web应用服务。那么在这里面是如何进行判断启动的应用是不是web应用的呢?
我们跟踪一个SpringApplication
的构造方法,调用层级如下。
- SpringApplication
- initialize
- deduceWebEnvironment
- initialize
下面的代码是spring-boot2.0.3里面的,可能跟1.4.x版本不一样
public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
+ "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";
private static final String REACTIVE_WEB_ENVIRONMENT_CLASS = "org.springframework."
+ "web.reactive.DispatcherHandler";
private static final String MVC_WEB_ENVIRONMENT_CLASS = "org.springframework."
+ "web.servlet.DispatcherServlet";
//......
private WebApplicationType deduceWebApplicationType() {
if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)
&& !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)) {
return WebApplicationType.REACTIVE;
}
for (String className : WEB_ENVIRONMENT_CLASSES) {
if (!ClassUtils.isPresent(className, null)) {
return WebApplicationType.NONE;
}
}
return WebApplicationType.SERVLET;
}
WebApplicationType.REACTIVE
ractive web应用
WebApplicationType.SERVLET
servelt web应用,启动tomcat服务器
WebApplicationType.NONE
不是web应用,main执行完成就结束应用
根据deduceWebApplicationType
里面的判断,可以知道这里是按照类路径是否存在某个class来推断应该启动哪一个类型的WebApplicationType,所以在实际应用中,我们只需要导入对应的类所在的模块就能启动对应类型的应用。例如我想启动一个webFlux应用,只需要引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
<version>2.0.3.RELEASE</version>
</dependency>
根据判断REACTIVE_WEB_ENVIRONMENT_CLASS存在且MVC_WEB_ENVIRONMENT_CLASS不存在就能启动一个webFlux的web应用。
@SpringBootApplication
分析
注解组合
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class))
public @interface SpringBootApplication {
Class<?>[] exclude() default {};
String[] excludeName() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
Class<?>[] scanBasePackageClasses() default {};
}
上面可以看到@SpringBootApplication
注解上面还被很多其他注解进行注解,这里就涉及到注解组合的情况。这里主要看
- @SpringBootConfiguration
- @EnableAutoConfiguration
- @ComponentScan
一个注解上面有什么注解,那么这个注解就会含有上面这些注解的语义。例如@SpringBootApplication
注解,就会含有@SpringBootConfiguratio、@EnableAutoConfiguration、@ComponentScan的语义。
既然拥有了这些注解的语义,那么就必定需要等效的配置方式来针对某个注解语义进行配置。例如@SpringBootApplication
有@ComponentScan
注解的语义,那么由于@ComponentScan
是可以配置属性basePackages来定义扫描路径所在的,由于@SpringBootApplication
是含有@ComponentScan
的语义,但是不能访问@ComponentScan
中的属性,所以@SpringBootApplication
是无法定义basePackages属性的值的,那么是通过什么方式进行配置呢?
@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
上面代码就是解决方式,通过@AliasFor
为@SpringBootApplication
注解中的属性定义成为别的注解中属性的别名,从而完成属性配置,所以@SpringBootApplication
只需要配置scanBasePackages属性就可以定义扫描路径了。
另外@ComponentScan
在注解@SpringBootApplication
时,已经带了某些固定值excludeFilters,这个值就是固定委托给了@SpringBootApplication
,@SpringBootApplication
处理@ComponentScan
语义时,excludeFilters属性就只能是这个值。
@ComponentScan(excludeFilters = @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class))
然后我们可以跟踪@SpringBootApplication
注解上面的注解组合链路
@SpringBootConfiguration
- @SpringBootApplication
- @SpringBootConfiguration
- @Configuration
- @Component
-
跟踪到最后是有个@Component修饰,所以其实SpringApplication也是一个bean来的,在spring应用中被@Component语义修饰的类都会注册为bean。在启动时,会扫描被@Component注解的类,然后进行注册,代码路径:
org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan
- @Component
- @Configuration
- @SpringBootConfiguration
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
for (String basePackage : basePackages) {
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
在findCandidateComponents方法里面会根据初始化的filter扫描basepackge路径里面符合filter的所有类,查出来之后就进行bean注册。默认的include filter包含当然就有我们的目标@Component注解啦,然后就能扫描到@Component语义的类了,例如被@Service、@Repositry、@Controller等注解修饰的类,进行注册。
protected void registerDefaultFilters() {
//默认就有@Component注解扫描
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
@EnableAutoConfiguration
主要是开启spring-boot的自动配置
何时执行bean查找注册?
利用 @SpringBootConfiguration
做好自动化配置引入,以及@Component语义赋予后,我们在main方法里面执行run,查看源码就可以知道,run方法里面实际上是创建了一个spring应用的上下文,当上下文refresh()的时候,就执行了spring bean的查找与注册。
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
configureHeadlessProperty();
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.started();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
Banner printedBanner = printBanner(environment);
//创建context
context = createApplicationContext();
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
//refresh
refreshContext(context);
afterRefresh(context, applicationArguments);
listeners.finished(context, null);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
return context;
}
catch (Throwable ex) {
handleRunFailure(context, listeners, ex);
throw new IllegalStateException(ex);
}
}
看到这里,其实我们可以自己手动完成部分@SpringBootApplication
的功能来启动一个spring应用,怎么玩呢?我们可以不需要@SpringBootConfiguration、@EnableAutoConfiguration语义,@SpringBootConfiguration用@Component替代,再加上一个@ComponentScan
,得出下面的一个spring应用,当然不是web的。
package com.garine.common;
import com.garine.component.TestBean;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
@Component
@ComponentScan(basePackages = "com.garine.component")
public class MySpringApplication {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
// 注册一个 总配置Class = MySpringApplication.class
context.register(MySpringApplication.class);
// 上下文启动,注册bean
context.refresh();
System.out.println(context.getBean(TestBean.class));
}
}
注册一个 总配置Class, MySpringApplication.class,上下文启动,当spring处理这个class的注解时,就能扫描到在com.garine.component下定义的TestBean,从而完成了类型@SpringBootApplication + run()方法的类似工作。实际就是一个初始化入口操作。