大家都知道基于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.REACTIVEractive web应用
WebApplicationType.SERVLETservelt 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（）方法的类似工作。实际就是一个初始化入口操作。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
