15000 字详解 Spring Boot 注解

╰+攻爆jí腚メ 2021-09-08 07:38 369阅读 0赞

首先，先看 SpringBoot 的主配置类：

@SpringBootApplication
    public class StartEurekaApplication
    {
        public static void main(String[] args)
        {
            SpringApplication.run(StartEurekaApplication.class, args);
        }
    }

点进 @SpringBootApplication 来看，发现 @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 {
    
    }

首先我们先来看 @SpringBootConfiguration：

@Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    public @interface SpringBootConfiguration {
    }

可以看到这个注解除了元注解以外，就只有一个@Configuration，那也就是说这个注解相当于@Configuration，所以这两个注解作用是一样的，它让我们能够去注册一些额外的Bean，并且导入一些额外的配置。

那@Configuration还有一个作用就是把该类变成一个配置类，不需要额外的XML进行配置。所以@SpringBootConfiguration就相当于@Configuration。进入@Configuration，发现@Configuration核心是@Component，说明Spring的配置类也是Spring的一个组件。

@Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Configuration {
        @AliasFor(
            annotation = Component.class
        )
        String value() default "";
    }

继续来看下一个@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 {};
    }

可以看到它是由 @AutoConfigurationPackage，@Import 这两个而组成的，我们先说@AutoConfigurationPackage，他是说：让包中的类以及子包中的类能够被自动扫描到spring容器中。

@Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Import({Registrar.class})
    public @interface AutoConfigurationPackage {
    }

使用 @Import 来给 Spring 容器中导入一个组件 ，这里导入的是 Registrar.class。来看下这个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));
            }
        }

就是通过以上这个方法获取扫描的包路径，可以 debug 查看具体的值：

![b32f86948245615a575814472dbd867f.png][]

那 metadata 是什么呢，可以看到是标注在 @SpringBootApplication 注解上的 DemosbApplication，也就是我们的主配置类Application：

![1a65c845b3cd38ec95f06305901ee4bf.png][]

其实就是将主配置类（即@SpringBootApplication标注的类）的所在包及子包里面所有组件扫描加载到Spring容器。因此我们要把DemoApplication放在项目的最高级中（最外层目录）。

看看注解@Import，@Import注解就是给Spring容器中导入一些组件，这里传入了一个组件的选择器:AutoConfigurationImportSelector。

![f683e2040bf0fc859b7edbb5f9358827.png][]

可以从图中看出 AutoConfigurationImportSelector 继承了 DeferredImportSelector 继承了 ImportSelector，ImportSelector有一个方法为：selectImports。将所有需要导入的组件以全类名的方式返回，这些组件就会被添加到容器中。

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());
        }
    }

会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景需要的所有组件，并配置好这些组件。

![f1d6c8d222f6df835d1f5529136b07ea.png][]

有了自动配置类，免去了我们手动编写配置注入功能组件等的工作。那是如何获取到这些配置类的呢，看看下面这个方法：

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);
        }
    }

我们可以看到getCandidateConfigurations()这个方法，他的作用就是引入系统已经加载好的一些类，到底是那些类呢：

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());
    }

会从 META-INF/spring.factories 中获取资源，然后通过 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);
            }
        }
    }

可以知道SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作。以前我们需要自己配置的东西，自动配置类都帮我们完成了。如下图可以发现Spring常见的一些类已经自动导入。

![d65e0c47dde510c0c2331f034040dafa.png][]

接下来看@ComponentScan注解，@ComponentScan(excludeFilters = \{ @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) \})，这个注解就是扫描包，然后放入spring容器。

@ComponentScan(excludeFilters = {
      @Filter(type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class}), 
      @Filter(type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class})})
    public @interface SpringBootApplication {}

总结下 @SpringbootApplication：就是说，他已经把很多东西准备好，具体是否使用取决于我们的程序或者说配置。

接下来继续看run方法：

public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }

来看下在执行 run 方法到底有没有用到哪些自动配置的东西，我们点进 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);
        }
    }

那我们关注的就是 refreshContext(context); 刷新 context，我们点进来看。

private void refreshContext(ConfigurableApplicationContext context) {
       refresh(context);
       if (this.registerShutdownHook) {
          try {
             context.registerShutdownHook();
          }
          catch (AccessControlException ex) {
             // Not allowed in some environments.
          }
       }
    }

我们继续点进 refresh(context);

protected void refresh(ApplicationContext applicationContext) {
       Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
       ((AbstractApplicationContext) applicationContext).refresh();
    }

他会调用 ((AbstractApplicationContext) applicationContext).refresh();方法，我们点进来看：

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();
          }
       }
    }

由此可知，就是一个 spring 的 bean 的加载过程。继续来看一个方法叫做 onRefresh()：

protected void onRefresh() throws BeansException {
       // For subclasses: do nothing by default.
    }

他在这里并没有直接实现，但是我们找他的具体实现：

![6acea2710c0aa5dba362ce89156214dd.png][]

比如 Tomcat 跟 web 有关，我们可以看到有个 ServletWebServerApplicationContext：

@Override
    protected void onRefresh() {
       super.onRefresh();
       try {
          createWebServer();
       }
       catch (Throwable ex) {
          throw new ApplicationContextException("Unable to start web server", ex);
       }
    }

可以看到有一个 createWebServer();方法他是创建web容器的，而Tomcat不就是web容器，那是如何创建的呢，我们继续看：

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());他是通过工厂的方式创建的。

public interface ServletWebServerFactory {
       WebServer getWebServer(ServletContextInitializer... initializers);
    }

可以看到 它是一个接口，为什么会是接口。因为我们不止是Tomcat一种web容器。

![61a2dd4f115ed0182d18b2ee60efa662.png][]

我们看到还有Jetty，那我们来看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);
    }

那这块代码，就是我们要寻找的内置Tomcat，在这个过程当中，我们可以看到创建Tomcat的一个流程。

如果不明白的话， 我们在用另一种方式来理解下，大家要应该都知道stater举点例子。

<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>

首先自定义一个stater。

我们先来看 maven 配置写入版本号，如果自定义一个 stater 的话必须依赖 spring-boot-autoconfigure 这个包,我们先看下项目目录。

![bc342aeabf62db0417c0db01fe9a32ce.png][]

public class GwServiceImpl  implements GwService{
        @Autowired
        GwProperties properties;
    
        @Override
        public void Hello()
        {
            String name=properties.getName();
            System.out.println(name+"说:你们好啊");
        }
    }

我们做的就是通过配置文件来定制name这个是具体实现。

@Component
    @ConfigurationProperties(prefix = "spring.gwname")
    public class GwProperties {
    
        String name="zgw";
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

这个类可以通过 @ConfigurationProperties 读取配置文件。

@Configuration
    @ConditionalOnClass(GwService.class) //扫描类
    @EnableConfigurationProperties(GwProperties.class) //让配置类生效
    public class GwAutoConfiguration {
    
        /**
        * 功能描述 托管给spring
        * @author zgw
        * @return
        */
        @Bean
        @ConditionalOnMissingBean
        public GwService gwService()
        {
            return new GwServiceImpl();
        }
    }

这个为配置类，为什么这么写因为，spring-boot的stater都是这么写的，我们可以参照他仿写stater，以达到自动配置的目的，然后我们在通过spring.factories也来进行配置。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.gw.GwAutoConfiguration

然后这样一个简单的stater就完成了，然后可以进行maven的打包，在其他项目引入就可以使用。

来源：cnblogs.com/jing99/p/11504113.html

--------------------

**推荐阅读**

***1. ***[GitHub 上有什么好玩的项目？][GitHub]

***2. ***[这个牛逼哄哄的数据库开源了][Link 1]

***3.****** ***[SpringSecurity + JWT 实现单点登录][SpringSecurity _ JWT]

***4. ***[100 道 Linux 常见面试题][100 _ Linux]

![5e173068ad4b68e544e1a2c5256fc014.png][]

[b32f86948245615a575814472dbd867f.png]: /images/20210730/1f3e0e69ec5d42f695a2646f5df8ad2c.png
[1a65c845b3cd38ec95f06305901ee4bf.png]: /images/20210730/3abc62d2122944a3a98b83a8fd6f0251.png
[f683e2040bf0fc859b7edbb5f9358827.png]: /images/20210730/d26663e8ddd642a188d14ee963905aa8.png
[f1d6c8d222f6df835d1f5529136b07ea.png]: /images/20210730/0c215b0fd1e140c38119b1fa485fb10e.png
[d65e0c47dde510c0c2331f034040dafa.png]: /images/20210730/7adce157a1564e8fa19904b121cc2bff.png
[6acea2710c0aa5dba362ce89156214dd.png]: /images/20210730/91a5f0f689804379ab2d1cbd02ba7cde.png
[61a2dd4f115ed0182d18b2ee60efa662.png]: /images/20210730/9c8e23887ad246db9ad65c9b252eab34.png
[bc342aeabf62db0417c0db01fe9a32ce.png]: /images/20210730/7be7826a9f28498886b05ba289904fee.png
[GitHub]: http://mp.weixin.qq.com/s?__biz=MzUxNjg4NDEzNA%3D%3D&chksm=f9a2286fced5a1794eb9a73d0be7c2e16eaceabf3a0420647c40cb4202bd116d9a15dd57c008&idx=1&mid=2247498662&scene=21&sn=0087c4f3b79ba3420e917e9b42d45eda#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=Mzg2MjEwMjI1Mg%3D%3D&chksm=ce0e35e4f979bcf2c7c985dbabfe32f2a5f563e191d12a64325355e1c586853a4ab682077137&idx=1&mid=2247516775&scene=21&sn=43b3c7460718c40539512f56e4dd87fb#wechat_redirect
[SpringSecurity _ JWT]: http://mp.weixin.qq.com/s?__biz=Mzg2MjEwMjI1Mg%3D%3D&chksm=ce0e35bdf979bcabbb75366e1bad32bdbf8f41d1dc80b8be6e39225bd708913ce2c93472f2fc&idx=1&mid=2247516734&scene=21&sn=966d166d3052f10b9310ff4014733669#wechat_redirect
[100 _ Linux]: http://mp.weixin.qq.com/s?__biz=Mzg2MjEwMjI1Mg%3D%3D&chksm=ce0e367bf979bf6dec769decc0194bb36de4caeae7947671aba1852fe6bac8e5dab7d20916a5&idx=1&mid=2247516664&scene=21&sn=0dae1a8cf99c4bde8fd8c9c197769009#wechat_redirect
[5e173068ad4b68e544e1a2c5256fc014.png]: /images/20210730/3db8458a15b24d709e033b722455eca8.png