First, look at the main configuration class of SpringBoot:
@SpringBootApplication
public class StartEurekaApplication
{
public static void main(String[] args)
{
SpringApplication.run(StartEurekaApplication.class, args);
}
}
Click into @SpringBootApplication and find that @SpringBootApplication is a composite annotation.
@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 {
}
First, let's look at @SpringBootConfiguration:
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}
You can see that besides the meta-annotation of this annotation, there is only one @Configuration, that is to say, this annotation is equivalent to @Configuration, so these two annotations have the same effect. It allows us to register some additional beans and import them. Some additional configuration. The other function of @Configuration is to turn this class into a configuration class without additional XML configuration. So @SpringBootConfiguration is equivalent to @Configuration. Enter @Configuration and find that @Configuration core is @Component, indicating that Spring's configuration class is also a component of Spring.
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
@AliasFor(
annotation = Component.class
)
String value() default "";
}
Continue to look at the next @EnableAutoConfiguration, this annotation is to enable the automatic configuration function.
@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 {};
}
You can see that it is composed of @AutoConfigurationPackage and @Import(EnableAutoConfigurationImportSelector.class). Let’s talk about @AutoConfigurationPackage first. He means: Let the classes in the package and the classes in the sub-packages be automatically scanned to spring In the container.
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}
Use @Import to import a component into the Spring container, here is Registrar.class. Take a look at this Registrar:
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
Registrar() {
}
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
}
public Set<Object> determineImports(AnnotationMetadata metadata) {
return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
}
}
It is through the above method to get the scanned package path, you can debug to view the specific value:
What is metadata? You can see that it is DemosbApplication marked on the @SpringBootApplication annotation, which is our main configuration class Application:
In fact, it is to scan and load all the components in the package and sub-packages of the main configuration class (that is, the class marked by @SpringBootApplication) into the Spring container . Therefore, we have to put DemoApplication in the top level of the project (the outermost directory).
Take a look at the annotation @Import(AutoConfigurationImportSelector.class). The @Import annotation is to import some components into the Spring container. Here is a component selector: AutoConfigurationImportSelector.
It can be seen from the figure that AutoConfigurationImportSelector inherits DeferredImportSelector and ImportSelector. ImportSelector has a method: selectImports. Return all the components that need to be imported as full class names, and these components will be added to the container.
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry =
this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}
A lot of automatic configuration classes (xxxAutoConfiguration) will be imported into the container; that is, all the components needed for this scenario will be imported into the container, and these components will be configured.
With the automatic configuration class, we can avoid the work of manually writing configuration injection functional components. How do you get these configuration classes? Take a look at the following method:
protected AutoConfigurationImportSelector.AutoConfigurationEntry
getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
} else {
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 new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
}
}
We can see the getCandidateConfigurations() method. Its role is to introduce some classes that have been loaded by the system. Which classes are they?
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());
}
Will get resources from META-INF/spring.factories, and then load the resources through Properties:
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
if (result != null) {
return result;
} else {
try {
Enumeration<URL> urls = classLoader !=
null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
LinkedMultiValueMap result = new LinkedMultiValueMap();
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()) {
Map.Entry<?, ?> entry = (Map.Entry)var6.next();
String factoryClassName = ((String)entry.getKey()).trim();
String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
int var10 = var9.length;
for(int var11 = 0; var11 < var10; ++var11) {
String factoryName = var9[var11];
result.add(factoryClassName, factoryName.trim());
}
}
}
cache.put(classLoader, result);
return result;
} catch (IOException var13) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
}
}
}
You can know that SpringBoot obtains the values specified by EnableAutoConfiguration from META-INF/spring.factories under the classpath when it starts, and imports these values into the container as an auto-configuration class, and the auto-configuration class takes effect and helps us with auto-configuration work . Before we need to configure things by ourselves, the automatic configuration class has done it for us. As shown in the figure below, you can find that some common classes in Spring have been automatically imported.
Next look at the @ComponentScan annotation, @ComponentScan(excludeFilters = {@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }), this annotation is Scan the package and put it into the spring container.
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class}),
@Filter(type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class})})
public @interface SpringBootApplication {}
Summarizing @SpringbootApplication: In other words, he has prepared a lot of things, and whether to use it depends on our program or configuration.
Next, continue to look at the run method:
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
To see if there are any automatic configuration things used in the execution of the run method, let's click into the run:
public ConfigurableApplicationContext run(String... args) {
//计时器
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
this.configureHeadlessProperty();
//监听器
SpringApplicationRunListeners listeners = this.getRunListeners(args);
listeners.starting();
Collection exceptionReporters;
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
this.configureIgnoreBeanInfo(environment);
Banner printedBanner = this.printBanner(environment);
//准备上下文
context = this.createApplicationContext();
exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class[]{ConfigurableApplicationContext.class}, context);
//预刷新context
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
//刷新context
this.refreshContext(context);
//刷新之后的context
this.afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
}
listeners.started(context);
this.callRunners(context, applicationArguments);
} catch (Throwable var10) {
this.handleRunFailure(context, var10, exceptionReporters, listeners);
throw new IllegalStateException(var10);
}
try {
listeners.running(context);
return context;
} catch (Throwable var9) {
this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
throw new IllegalStateException(var9);
}
}
Then what we are concerned about is refreshContext(context); refresh context, let's click in and take a look.
private void refreshContext(ConfigurableApplicationContext context) {
refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
}
catch (AccessControlException ex) {
// Not allowed in some environments.
}
}
}
We continue to click refresh(context);
protected void refresh(ApplicationContext applicationContext) {
Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
((AbstractApplicationContext) applicationContext).refresh();
}
He will call ((AbstractApplicationContext) applicationContext).refresh(); method, we click in and see:
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
It can be seen that it is the loading process of a spring bean. Continue to look at a method called onRefresh():
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}
He is not directly realized here, but we are looking for his concrete realization:
For example, Tomcat is related to the web, we can see that there is a ServletWebServerApplicationContext:
@Override
protected void onRefresh() {
super.onRefresh();
try {
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}
You can see that there is a createWebServer(); method that creates a web container, and Tomcat is not a web container. How is it created? Let’s continue to see:
private void createWebServer() {
WebServer webServer = this.webServer;
ServletContext servletContext = getServletContext();
if (webServer == null && servletContext == null) {
ServletWebServerFactory factory = getWebServerFactory();
this.webServer = factory.getWebServer(getSelfInitializer());
}
else if (servletContext != null) {
try {
getSelfInitializer().onStartup(servletContext);
}
catch (ServletException ex) {
throw new ApplicationContextException("Cannot initialize servlet context",
ex);
}
}
initPropertySources();
}
factory.getWebServer(getSelfInitializer()); He is created by way of a factory.
public interface ServletWebServerFactory {
WebServer getWebServer(ServletContextInitializer... initializers);
}
You can see why it is an interface. Because we are more than a Tomcat web container.
We see Jetty, then we look at TomcatServletWebServerFactory:
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
Tomcat tomcat = new Tomcat();
File baseDir = (this.baseDirectory != null) ? this.baseDirectory
: createTempDir("tomcat");
tomcat.setBaseDir(baseDir.getAbsolutePath());
Connector connector = new Connector(this.protocol);
tomcat.getService().addConnector(connector);
customizeConnector(connector);
tomcat.setConnector(connector);
tomcat.getHost().setAutoDeploy(false);
configureEngine(tomcat.getEngine());
for (Connector additionalConnector : this.additionalTomcatConnectors) {
tomcat.getService().addConnector(additionalConnector);
}
prepareContext(tomcat.getHost(), initializers);
return getTomcatWebServer(tomcat);
}
Then this piece of code is the built-in Tomcat we are looking for. In this process, we can see a process of creating Tomcat.
If you don't understand, we are using another way to understand, everyone should know the statuser to give some examples.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
First customize a statuser.
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
<relativePath/>
</parent>
<groupId>com.zgw</groupId>
<artifactId>gw-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
</dependency>
</dependencies>
Let's first look at the version number written in the maven configuration. If you customize a statuser, you must rely on the spring-boot-autoconfigure package. Let's look at the project directory first.
public class GwServiceImpl implements GwService{
@Autowired
GwProperties properties;
@Override
public void Hello()
{
String name=properties.getName();
System.out.println(name+"说:你们好啊");
}
}
What we do is to customize the name through the configuration file. This is a concrete realization.
@Component
@ConfigurationProperties(prefix = "spring.gwname")
public class GwProperties {
String name="zgw";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
This class can read configuration files through @ConfigurationProperties.
@Configuration
@ConditionalOnClass(GwService.class) //扫描类
@EnableConfigurationProperties(GwProperties.class) //让配置类生效
public class GwAutoConfiguration {
/**
* 功能描述 托管给spring
* @author zgw
* @return
*/
@Bean
@ConditionalOnMissingBean
public GwService gwService()
{
return new GwServiceImpl();
}
}
This is a configuration class. Why is it written like this? Because spring-boot's statuser is written this way, we can refer to him to imitate the statuser to achieve the purpose of automatic configuration, and then we will also configure it through spring.factories.
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.gw.GwAutoConfiguration
Then such a simple statuser is completed, and then it can be packaged in maven, and it can be used in other projects.