Spring Boot注解学习之@SpringBootApplication(一)

hresh 443 0

Spring Boot注解学习之@SpringBootApplication(一)

@SpringBootApplication

在使用 Springboot 框架进行开发的时候，通常我们会在 main 函数上添加 @SpringBootApplication 注解 ，来使应用程序能够自动配置、组件扫描。

@SpringBootApplication
public class Application {

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

@SpringBootApplication 注解等价于默认属性使用@Configuration，@EnableAutoConfiguration 和 @ComponentScan，

这里可以查看一下@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 {

}

为什么@SpringBootApplication注解里没有包含@Configuration,实际上是在@SpringBootConfiguration里面 ：

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

@SpringBootConfiguration继承自@Configuration，二者功能也一致，标注当前类是配置类， 并会将当前类内声明的一个或多个以@Bean 注解标记的方法的实例纳入到 spring 容器中，并且实例名就是方法名。

接下来再介绍一下上面提到的三种注解。

@Configuration

从 Spring3.0 开始，@Configuration 用于定义配置类，可替换 xml 配置文件，被注解的类内部包含有一个或多个被@Bean 注解的方法，这些方法将会被 AnnotationConfigApplicationContext 或AnnotationConfigWebApplicationContext 类进行扫描，并用于构建 bean 定义，初始化 Spring 容器。

注意：@Configuration 注解修饰的配置类有如下要求：

  1. 不能是 final 类型；
  2. 不能是匿名类；
  3. 嵌套的 configuration 必须是静态类。

@Configuration 加载 Spring 方法

1、@Configuration 配置 Spring 并启动 Spring 容器

@Configuration标注在类上，相当于把该类作为 spring 的 xml 配置文件中的 ，作用为：配置 spring 容器(应用上下文) 。

@Configuration
public class TestConfiguration {

    public TestConfiguration(){
        System.out.println("TestConfiguration容器启动初始化。。。");
    }
}

等价于

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd" default-lazy-init="false">
    <bean id="testConfiguration" class="com.example.configuration.TestConfiguration"></bean>
</beans>

主方法进行测试：

public class TestMain {

    public static void main(String[] args) {
        // @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
//        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestConfiguration.class);

        //通过加载 spring-context.xml文件,此时将TestConfiguration上的注解取消
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
    }
}

上述方法有两种实现，可以分别进行测试，得到如下结果：

21:18:29.599 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration'
TestConfiguration容器启动初始化。。。
2、@Configuration 启动容器+@Bean 注册 bean

@Bean 标注在方法上（返回某个实例的方法），等价于 Spring 的 xml 配置文件中：注册 bean 对象。

bean 类：

public class TestBean {
    private String username;
    private String url;
    private String password;

    public void sayHello(){
        System.out.println("TestBean sayHello...");
    }

    public String toString(){
        return "username:"+this.username+",url:"+this.url+",password:"+this.password;
    }

    public void start(){
        System.out.println("TestBean 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("TestBean 销毁。。。");
    }
}

配置类：

@Configuration
public class TestConfiguration2 {
    public TestConfiguration2(){
        System.out.println("TestConfiguration容器启动初始化。。。");
    }

    @Bean
    @Scope("prototype")
    public TestBean testBean(){
        return new TestBean();
    }
}

主方法测试类：

public class TestMain2 {

    public static void main(String[] args) {
        // @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestConfiguration2.class);

        //获取 Bean
        TestBean testBean = (TestBean) applicationContext.getBean("testBean");
        testBean.sayHello();
        System.out.println(testBean.hashCode());

        //再次获取 bean,如果testBean方法上没加@Scope(“prototype”)，则@Bean注解默认作用域为单例singleton作用域，所以返回的都是同一个对象
        TestBean testBean1 = (TestBean) applicationContext.getBean("testBean");
        System.out.println(testBean1.hashCode());
    }
}

当 Bean 类不加 @Scope("prototype")注解时输出结果为：

09:12:58.279 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration2'
TestConfiguration容器启动初始化。。。
09:12:58.282 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBean'
TestBean sayHello...
2143437117
2143437117

加上 @Scope("prototype")注解时输出结果为：

09:13:42.796 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration2'
TestConfiguration容器启动初始化。。。
TestBean sayHello...
1989335500
1978869058

结论：

  1. @Bean 注解在返回实例的方法上，如果未通过@Bean 指定 bean 名称，则默认与标注的方法名相同；
  2. @Bean 注解默认作用域为单例 singleton 作用域，可通过 @Scope("prototype")设置为原型作用域；
  3. 既然@Bean 的作用是注册 bean 对象，那么完全可以使用@Component、@Controller、@Service、@Ripository 等注解注册 bean，当然需要配置@ComponentScan 注解进行自动扫描。
3、@Configuration 启动容器+@Component 注册 Bean

bean 类：

package com.example.domain;

import org.springframework.stereotype.Component;

@Component
public class BeanWithComponent {

    public void sayHello(){

        System.out.println("BeanWithComponent sayHello...");
    }

    public void start(){
        System.out.println("BeanWithComponent 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("BeanWithComponent 销毁。。。");
    }
}

配置类：

@Configuration
@ComponentScan(basePackages = "com.example.domain")
public class ComfigureWithScan {

    public ComfigureWithScan(){
        System.out.println("spring容器启动初始化。。。");
    }
}

主方法测试类：

public class TestComponnet {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan.class);

        BeanWithComponent bean = (BeanWithComponent) context.getBean("beanWithComponent");
        bean.sayHello();
        System.out.println(bean);

        BeanWithComponent bean2 = (BeanWithComponent) context.getBean("beanWithComponent");
        System.out.println(bean2);
    }
}

执行结果为：

10:03:56.791 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'comfigureWithScan'
spring容器启动初始化。。。
10:03:56.796 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'beanWithComponent'
BeanWithComponent sayHello...
com.example.domain.BeanWithComponent@d706f19
com.example.domain.BeanWithComponent@d706f19

从结果可以看到，使用@Component 注解+@ComponentScan 相当于使用了 @Bean 不加@Scope 注解，即得到的 bean 对象为同一个对象。

4、使用 AnnotationConfigApplicationContext 注册 AppContext 类的两种方法

a、配置类的注册方式是将其传递给 AnnotationConfigApplicationContext 构造函数

public class TestComponnet {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan.class);

    }
}

b、AnnotationConfigApplicationContext 的 register 方法传入配置类来注册配置类

public class TestComponnet {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(ComfigureWithScan.class);
        context.refresh();
        ApplicationContext ctx = context;

    }
}

该方法其实就是对 AnnotationConfigApplicationContext构造函数的拆分使用，参考该部分的源码如下：

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    this.register(componentClasses);
    this.refresh();
}

注意：网上关于该部分的代码都是这样的：

public static void main(String[] args) {
  ApplicationContext ctx = new AnnotationConfigApplicationContext();
  ctx.register(AppContext.class)
}

咱也不知道为啥他们都能测试通过，反正我本地没法这样编写代码，咱只能换个思路来实现。这里看一下 AnnotationConfigApplicationContext 类的结构层次图：

Spring Boot注解学习之@SpringBootApplication(一)

关于该类的分析，后续咱再学习一下 。

5、配置 Web 应用程序(web.xml中配置 AnnotationConfigApplicationContext)

过去，您通常要利用 XmlWebApplicationContext 上下文来配置 Spring Web 应用程序，即在 Web 部署描述符文件 web.xml 中指定外部 XML 上下文文件的路径。XMLWebApplicationContext 是 Web 应用程序使用的默认上下文类。以下代码描述了 web.xml 中指向将由 ContextLoaderListener 监听器类载入的外部 XML 上下文文件的元素。

<web-app>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <servlet>
    <servlet-name>sampleServlet</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    </servlet>
...
</web-app>

现在，您要将 web.xml 中的上述代码更改为使用 AnnotationConfigApplicationContext 类。切记，XmlWebApplicationContext 是 Spring 为 Web 应用程序使用的默认上下文实现，因此您永远不必在您的web.xml 文件中显式指定这个上下文类。现在，您将使用基于 Java 的配置，因此在配置 Web 应用程序时，需要在web.xml 文件中指定 AnnotationConfigApplicationContext 类。上述代码将修改如下：

<web-app>
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.
            support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            demo.AppContext
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <servlet>
    <servlet-name>sampleServlet</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.
            support.AnnotationConfigWebApplicationContext
        </param-value>
    </init-param>
    </servlet>

...
</web-app>

以上修改后的 web.xml 现在定义了 AnnotationConfigWebApplicationContext 上下文类，并将其作为上下文参数和 servlet 元素的一部分。上下文配置位置现在指向 AppContext 配置类。

组合多个配置类

在@configuration 中引入 spring 的 xml 配置文件

配置类：

@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
public class TestConfiguration2 {
    public TestConfiguration2(){
        System.out.println("TestConfiguration2容器启动初始化。。。");
    }

//    @Bean
//    @Scope("prototype")
//    public TestBean testBean(){
//        return new TestBean();
//    }
}

bean类：

public class TestBean {

    public void sayHello(){

        System.out.println("TestBean sayHello...");
    }

    public void start(){
        System.out.println("TestBean 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("TestBean 销毁。。。");
    }
}

applicationContext-configuration.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd" default-lazy-init="false">
    <bean id = "testBean" class="com.example.domain.TestBean"></bean>
</beans>

测试类：

public class TestMain2 {

    public static void main(String[] args) {
        // @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestConfiguration2.class);

        //获取 Bean
        TestBean testBean = (TestBean) applicationContext.getBean("testBean");
        testBean.sayHello();
        System.out.println(testBean);

        TestBean testBean1 = (TestBean) applicationContext.getBean("testBean");
        System.out.println(testBean1);
    }
}

执行结果为：

16:35:28.837 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration2'
TestConfiguration2容器启动初始化。。。
16:35:28.852 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBean'
TestBean sayHello...
com.example.domain.TestBean@78aab498
com.example.domain.TestBean@78aab498

虽然这样的组合也能达到同样的效果，但是直接在配置类中使用@Bean 注解看起来更加简单。

在@configuration中引入其它注解配置

修改配置类：

@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
@Import(TestConfiguration.class)
public class TestConfiguration2 {

}

其他内容不变，执行结果如下：

16:40:40.239 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'com.example.configuration.TestConfiguration'
TestConfiguration容器启动初始化。。。
16:40:40.239 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBean'
TestBean sayHello...
com.example.domain.TestBean@12e61fe6
com.example.domain.TestBean@12e61fe6
@configuration 嵌套（嵌套的 Configuration 必须是静态类）

通过配置类嵌套的配置类，达到组合多个配置类的目的。但注意内部类必须是静态类。

bean 类：

package com.example.domain;
@Component
public class BeanWithComponent {

    public void sayHello(){

        System.out.println("BeanWithComponent sayHello...");
    }

    public void start(){
        System.out.println("BeanWithComponent 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("BeanWithComponent 销毁。。。");
    }
}

package com.example.domain;
public class DataSource {

    @Override
    public String toString() {
        return "I am DataSource";
    }
}

配置类：

@Configuration
@ComponentScan(basePackages = "com.example.domain")
public class ComfigureWithScan2 {

    public ComfigureWithScan2(){
        System.out.println("spring容器启动初始化。。。ComfigureWithScan2");
    }

    @Configuration
    static class DataConfigure{
        @Bean
        DataSource dataSource(){
            return new DataSource();
        }
    }
}

测试类：

public class TestComponnet2 {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan2.class);

        BeanWithComponent bean = (BeanWithComponent) context.getBean("beanWithComponent");
        bean.sayHello();

        DataSource dataSource = (DataSource) context.getBean("dataSource");
        System.out.println(dataSource);
    }
}

执行结果为：

16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'comfigureWithScan2'
spring容器启动初始化。。。ComfigureWithScan2
16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'beanWithComponent'
16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'com.example.configuration.ComfigureWithScan2$DataConfigure'
16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'dataSource'
BeanWithComponent sayHello...
I am DataSource

参考链接： https://www.cnblogs.com/duanxz/p/7493276.html

@EnableAutoConfiguration

@EnableAutoConfiguration 借助@Import 的帮助，将所有符合自动配置条件的 bean 定义加载到 Ioc 容器。

@EnableAutoConfiguration 也是一个复合Annotation，其源码如下:

@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 {};
}

其中，最关键的要属@Import({AutoConfigurationImportSelector.class})，借助 AutoConfigurationImportSelector 这个类，@EnableAutoConfiguration 可以帮助 SpringBoot 应用将所有符合条件的@configuration 都加载到当前的 SpringBoot 创建并使用的 Ioc 容器。

Spring Boot注解学习之@SpringBootApplication(一)

AutoConfigurationImportSelector

在SpringBoot1.5以前，使用的是EnableAutoConfigurationImportSelector，它继承自AutoConfigurationImportSelector，1.5以后，EnableAutoConfigurationImportSelector已经不再被建议使用，而是推荐使用AutoConfigurationImportSelector。

何时被执行

Springboot 启动时会使用 ConfigurationClassParser 来解析被@Configuration 修饰的配置类，然后再处理这个类内部被其他注解修饰的情况，比如@Import 注解，@ComponentScan 注解，@Bean 注解等。

如果发现注解中存在@Import(ImportSelector)的情况下，就会创建一个相应的 importSelector 对象，并调用其 selectImports 方法，而 AutoConfigurationImportSelector就是一个 ImportSelector 的实现类。 更多关于ConfigurationClassParser 的分析，参阅文章:Spring类注册笔记

Spring Boot注解学习之@SpringBootApplication(一)

所以 ConfigurationClassParser 会实例化一个 AutoConfigurationImportSelector 并调用它的 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());
    }
}

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

在 selectImports 方法中有调用 getAutoConfigurationEntry()这个方法，进去查看该方法可以看到获取配置类的代码，具体就是 getCandidateConfigurations()方法，点进去查看其具体实现：

Spring Boot注解学习之@SpringBootApplication(一)

自动配置的关键类:SpringFactoriesLoader

SpringFactoriesLoader 的主要功能就是从指定的配置文件 META/spring.factories 加载配置，spring.factories 是一个典型的 java properties 文件，配置格式为 Key-Value 格式，只不过 Key 和 Value 都是 Java 类型的完整类名。

进入 loadFactoryNames()方法，就发现 loadFactoryNames()读取了 ClassPath 下面的 META-INF/spring.factories 文件。

Spring Boot注解学习之@SpringBootApplication(一)

在@EnableAutoConfiguration 的场景中，它更多是提供一种配置查找的功能支持，即根据@EnableAutoConfiguration 的完整类名org.springframework.boot.autoconfigure.EnableAutoConfiguration 作为查找的key,获取对应的一组@Configuration 类。

Spring Boot注解学习之@SpringBootApplication(一)

由于文章篇幅过长，关于@Component 注解的讲述放在下一章，欢迎来围观！

本文作者为hresh，转载请注明。

发表评论 取消回复
表情 图片 链接 代码

分享