spring boot 自动装配

转x33g5p2x  于2021-06-28 转载在 Spring  
字(12.8k)|赞(0)|评价(0)|浏览(586)

spring boot 自动装配

Spring Boot的很多特性都是基于spring framework来实现的，例如我们熟知的特性，也是它的核心特性：组件自动装配。它能够根据依赖的jar包自动配置Spring Boot的应用，例如： 如果类路径中存在DispatcherServlet类，就会自动配置springMvc相关的Bean。

而你需要的仅仅是编写一个启动类，加上@ SpringBootApplication注解，执行它的main方法，接下来的就交给Sping Boot：

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

为什么说Spring Boot很多特性是基于Spring framework实现的呢，在进入主题之前，需要先了解一下模式注解

模式注解

spring的模式注解：

一种用于声明在应用中扮演"组件"角色的注解,即标注了这个注解,表明一个类等在应用中扮演组件。比如@ Repository标注在一个类上，说明这个类是扮演的仓储角色。

而@ Component是作为通用模式组件，任何被@ Component标注的组件均为组件扫描的候选对象。类似地，凡是被 @ Component 标注的注解，如 @ Service ，当任何组件标注它时，也被视作组件扫描的候选对象。

Spring Framework注解场景说明起始版本
@ Repository数据仓储2.0
@ Component通用组件2.5
@ Service服务2.5
@ Controller控制器2.5
@ Configuration配置类3.0

装配方式

spring2.5之前，使用的是xml配置的方式实现：

<context:component-scan base-package=\"com.wxpay.*\"/>

spring3.1之后，可以使用注解实现：

@ ComponentScan(\"com.wxpay.*\")

自定义模式注解

模式注解的两种属性：

  1. 派生性： @ component,@ Repository注解，都有value签名，保留了签名的一致性，这就是注解的派生性，换句话说，就是被@ component标注的注解就具备了@ component的功能
  2. 层次性： 声明二级注解SecondLevelRepository，我们的SecondLevelRepository派生于FirstLevelRepository,这就是层次性

严格上讲 注解是没有派生性和层次性的，之所以这样讲，是为了方便理解，因为在spring中的很多注解都是有着派生性和层次性的结构

可能前面的说法有些不够明确，大家可能听的云里雾里的，接下来我们用一个例子来说明一下模式注解的特性。

首先我们先定义一个注解，使用@ Repository标注：

@ Target({ElementType.TYPE})
@ Retention(RetentionPolicy.RUNTIME)
@ Documented
@ Repository
public @ interface FirstLevelRepository {
    String value() default \"\";
}

然后定义一个类，使用上面的注解标注：

@ FirstLevelRepository(value = \"myFirstLevelRepository\")
public class MyFirstLevelRepository {

}

最后再定义一个引导类，这儿使用了@ ComponentScan扫描上面的类：

@ ComponentScan(\"com.lingxiao.springboot.Repository\")
public class RepositoryBootstrap {
    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext =
                new SpringApplicationBuilder(RepositoryBootstrap.class).web(WebApplicationType.NONE).run(args);
        MyFirstLevelRepository firstLevelRepository = applicationContext
                .getBean(\"myFirstLevelRepository\", MyFirstLevelRepository.class);
        System.out.println(\"获取到的bean\" + firstLevelRepository);
        applicationContext.close();
    }
}

最终也是成功获取到了MyFirstLevelRepository ，这里可以看出，被@ Repository标注的注解 @ FirstLevelRepository，就像是继承关系，是具备@ Repository的功能的。

然后我们再定义一个注解，使用@ FirstLevelRepository来标注它：

@ Target({ElementType.TYPE})
@ Retention(RetentionPolicy.RUNTIME)
@ Documented
@ FirstLevelRepository
public @ interface SeondLevelRepository {
    String value() default \"\";
}

同样的方法，使用这个注解标注上面的类MyFirstLevelRepository，运行引导类RepositoryBootstrap，也是可以成功获取到bean的。这也印证了模式注解的派生性和层次性。

@ SpringBootApplication也是模式注解

好了，上面的例子已经说明模式注解的特性了，我们接下来可以看@ SpringBootApplication这个注解了·，进去看看源码：

源码版本为 spring-boot-2.2.5.RELEASE

@ Target(ElementType.TYPE)
@ Retention(RetentionPolicy.RUNTIME)
@ Documented
@ Inherited
@ ComponentScan(excludeFilters = { @ Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  @ Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
@ SpringBootConfiguration
@ EnableAutoConfiguration
public @ interface SpringBootApplication {
}

可以看到@ SpringBootApplication是一个组合注解

@ ComponentScan，配置自动扫包，没什么好说的

再点开@ SpringBootConfiguration，我们可以看见：

@ Configuration
public @ interface SpringBootConfiguration {
    
}

@ SpringBootConfiguration被@ Configuration，说明@ SpringBootConfiguration以及被它标注的@ SpringBootApplication是模式注解

然后是@ EnableAutoConfiguration，这是接下来要讲的@ Enable模块装配，也是实现自动装配的核心

@ Enable模块装配

使用@ Enable模块装配，可以配置激活哪些模块

框架实现注解模块
Spring Framework@ EnableWebMvc
@ EnableTransationManagement
@ EnableCachingCaching模块
@ EnableMBeanExportJMX模块
@ EnableAsync异步处理模块
@ EnableWebFluxWeb Flux模块
Spring Boot@ EnableAutoConfiguration自动装配模块
@ EnableOAuth2SaoOAuth2单点登录模块

有两种方式实现@ Enable

基于注解驱动实现

先定义一个Bean：

@ Configuration
public class HelloWorldConfiguration {
 
    @ Bean
    public String helloWorld() { // 方法名即 Bean 名称
        return \"Hello,World\";
    }
}

然后再定义一个注解，使用@ Import导入刚刚定义的bean：

@ Retention(RetentionPolicy.RUNTIME)
@ Target(ElementType.TYPE)
@ Documented
@ Import(HelloWorldConfiguration.class)
public @ interface EnableHelloWorld {
}

完成上面两步之后，我们只要用@ EnableHelloWorld标注在某个类上时，这个Bean就会加载到Spring容器中。

@ EnableHelloWorld
public class EnableHelloWorldBootstrap {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new SpringApplicationBuilder(EnableHelloWorldBootstrap.class)
                .web(WebApplicationType.NONE)
                .run(args);
        // helloWorld Bean 是否存在
        String helloWorld =
                context.getBean(\"helloWorld\", String.class);
        System.out.println(\"获取到的bean: \" + hello);
        // 关闭上下文
        context.close();
    }
}

运行查看效果：

可以看到这个bean确实已经加载到Spring容器中了。

基于接口驱动实现

实现ImportSelector接口，实现它的selectImports方法，返回的是一个string类型的数组，数组里面存放的类名：

public class HelloWorldImportSelector implements ImportSelector {
    @ Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{HelloWorldConfiguration.class.getName()};
    }
}

然后将上面定义的注解改一下：

@ Target({ElementType.TYPE})
@ Retention(RetentionPolicy.RUNTIME)
@ Documented
//@ Import({HelloWorldConfiguration.class})  enable注解驱动的方式
@ Import({HelloWorldImportSelector.class})  //接口编程的方式
public @ interface EnableHelloWorld {

}

可以看到，基于接口的方式实现更加灵活，我们可以在selectImports中做一些判断，根据需要返回不同的类名数组，然后再根据类名进行装配。

Spring Boot自动装配核心

我们再回头看一下@ EnableAutoConfiguration这个注解：

@ Target(ElementType.TYPE)
@ Retention(RetentionPolicy.RUNTIME)
@ Documented
@ Inherited
@ AutoConfigurationPackage
@ Import(AutoConfigurationImportSelector.class)
public @ interface EnableAutoConfiguration {
 String ENABLED_OVERRIDE_PROPERTY = \"spring.boot.enableautoconfiguration\";
}

再点进@ AutoConfigurationPackage看一下

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

}

使用@ Import来给Spring容器中导入一个组件 ，这里导入的是Registrar.class

运行springboot项目，debug看一下，可以发现metadata是被@ SpringBootApplication标注的类，再看看new PackageImport(metadata).getPackageName()的值：

这个值就是扫描的包路径，也就是说，默认扫描的包路径是引导类所在的包以及子包。

接着我们再看EnableAutoConfiguration也使用了@ import，导入了 AutoConfigurationImportSelector.class，从这个类的名字我们就可以知道，它指定是实现了ImportSelector接口，重写了selectImports方法，所以我们直接看selectImports：

@ Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
 if (!isEnabled(annotationMetadata)) {
  return NO_IMPORTS;
 }
 AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
 AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,annotationMetadata);
  return tringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
 }

可以看到返回结果是通过autoConfigurationEntry的getConfigurations()获取的，所以我们直接看getAutoConfigurationEntry方法：

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
   AnnotationMetadata annotationMetadata) {
  if (!isEnabled(annotationMetadata)) {
   return EMPTY_ENTRY;
  }
  AnnotationAttributes attributes = getAttributes(annotationMetadata);
  List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
  configurations = removeDuplicates(configurations);
  Set<String> exclusions = getExclusions(annotationMetadata, attributes);
  checkExcludedClasses(configurations, exclusions);
  configurations.removeAll(exclusions);
  configurations = filter(configurations, autoConfigurationMetadata);
  fireAutoConfigurationImportEvents(configurations, exclusions);
  return new AutoConfigurationEntry(configurations, exclusions);
 }

同理，这里我们进入getCandidateConfigurations方法看一下：

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
  List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
    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;
}

想必英文不太好的童鞋从这里面也能看出一些端倪，没错，最终加载的配置类会从META-INF/spring.factories中获取，也就是说，Spring Boot在启动的时候会从类路径下的META-INF/spring.factories文件中将指定的值作为配置类导入到容器中，也就实现了自动配置。

条件装配

条件装配注解有两种：

Spring注解场景说明起始版本
@ Profile配置化条件装配3.1
@ Conditional编程条件装配4.0

在4.0之后@ profile也变成了@ Conditional来实现

应用场景：一般用于生产环境和开发环境之间的切换，就是在类或者方法上添加注解并设置环境标识比如java7、java8，我们以一个简单的多整数求和来演示如何使用

@ Profile实现条件装配

首先定义一个接口：

public interface CalCulateService {
    /**
     * 整数求和
     * @ param args
     * @ return
     */
    Integer sum(Integer... args);
}

然后分别实现一个JDK7和JDK8的求和方法。

首先是JDK7的实现：

/**
 * java7的方式实现求和
 */
@ Profile(\"Java7\")
@ Service
public class Java7CalCulateServiceImpl implements CalCulateService {
    @ Override
    public Integer sum(Integer... args) {
        System.out.println(\"java7的方式求和\");
        int sum = 0;
        for (int i = 0; i < args.length; i++) {
            sum+=args[i];
        }
        return sum;
    }
}

然后是JDK8的实现：

@ Profile(\"Java8\")
@ Service
public class Java8CalCulateServiceImpl implements CalCulateService {
    @ Override
    public Integer sum(Integer... args) {
        System.out.println(\"java8的方式求和\");
        int sum = Stream.of(args).reduce(0,Integer::sum);
        return sum;
    }
}

然后创建一个启动类，在启动容器的时候，使用.profiles(\"Java8\")来指定使用哪个版本来计算：

@ SpringBootApplication(scanBasePackages = \"com.lingxiao.springboot.service\")
public class CalCulateServiceBootstrap {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext =
                new SpringApplicationBuilder(CalCulateServiceBootstrap.class)
                        .web(WebApplicationType.NONE)
                        .profiles(\"Java8\")
                        .run(args);
        CalCulateService calCulateService = applicationContext
                .getBean(CalCulateService.class);
        System.out.println(\"求和: \" + calCulateService.sum(1,2,3,4,5));
        applicationContext.close();
    }
}

运行结果：

可以看到确实是java8的方式实现的求和

@ Conditional实现条件装配

在创建bean时，增加一系列条件限制，只有当所有指定的条件都满足是，组件才可以注册。在使用@ Conditional时，进行条件判断的类必须实现Condition接口

现在我们自定义一个条件装配，创建一个注解：

/**
 * 编程方式实现条件装配
 */
@ Retention(RetentionPolicy.RUNTIME)
@ Target({ElementType.TYPE,ElementType.METHOD})
@ Documented
@ Conditional(OnSystemPropertyCondition.class)
public @ interface ConditionalOnSystemProperty {
    /**
     * java系统属性名称
     * @ return
     */
    String name();

    /**
     * java系统属性值
     */
    String value();
}

在这个注解中定义了两个属性name和value，这两个属性在实现条件判断的OnSystemPropertyCondition中会用到。

创建条件判断类：

/**
 * 编程方式实现条件装配
 */
public class OnSystemPropertyCondition implements Condition {

    /**
     *
     * @ param context
     * @ param metadata 源信息
     * @ return
     */
    @ Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(ConditionalOnSystemProperty.class.getName());
        List<Object> nameObj = attributes.get(\"name\");
        String name = \"\";
        if (!CollectionUtils.isEmpty(nameObj)) {
            name = String.valueOf(attributes.get(\"name\").get(0));
        }
        String value = \"\";
        if (!CollectionUtils.isEmpty(nameObj)) {
            value = String.valueOf(attributes.get(\"value\").get(0));
        }
        String property = System.getProperty(name);
        return value.equals(property);  //条件满足才会返回装配
    }
}

使用metadata.getAllAnnotationAttributes获取注解中的属性值，然后判断是否满足条件，满足条件之后才会装配。

创建引导类：

public class ConditionalOnSystemPropertyBootstrap {

    @ Bean
    @ ConditionalOnSystemProperty(name = \"java.vm.specification.version\",value = \"1.8\")
    public String helloWorld(){
        return \"hello world\";
    }

    public static void main(String[] args) {
        ConfigurableApplicationContext context = new SpringApplicationBuilder(ConditionalOnSystemPropertyBootstrap.class)
                .web(WebApplicationType.NONE)
                .run(args);
        String helloWorld = context.getBean(\"helloWorld\", String.class);
        System.out.println(\"bean name:  \"+helloWorld);
        context.close();
    }
}

在这个引导类中我们申明了一个helloWorld的bean，在这个方法上添加了条件装配注释，其中java.vm.specification.version是获取的java虚拟机版本，如果满足虚拟机为1.8的条件，这个bean就会被加载到spring容器中

当前版本为1.8时，运行代码：

正常加载没有问题，当我们切换版本之后，再次运行：

发现报错了，spring找不到这个bean，也就是说bean没有满足被加载的条件

实现自动装配

罗里吧嗦了这么多，我们看看如何实现Spring Boot的自动装配

而Spring Boot的自动装配是结合了上面所说的技术，所以我们可以基于Spring Framework的知识点实现自动装配，步骤如下：

  • 实现需要装配的类
  • Spring工厂加载，配置需要装配的类
    • 实现类 ：SpringFactoriesLoader
    • 配置资源：META-INF/spring.factories
  • 激活自动装配-@ EnableAutoConfiguration

首先创建一个类：

/**
 * 自动装配
 */
@ Configuration   //模式注解
@ EnableHelloWorld  //Enable模块装配
@ ConditionalOnSystemProperty(name = \"java.vm.specification.version\",value = \"1.8\") //条件装配
public class HelloWorldAutoConfiguration {

}

可以看到，修饰的三个注解都是基于Spring Framework的，现在只需要配置spring.factories文件即可，我们在resouries目录下新建文件：

内容为key-value的格式，key为@ EnableAutoConfiguration，value为自动装配类的包路径：

# 自动装配
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\\
com.lingxiao.springboot.configuration.HelloWorldAutoConfiguration

然后再创建一个启动类：

@ EnableAutoConfiguration
public class EnableAutoConfigurationBootstrap {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new SpringApplicationBuilder(EnableAutoConfigurationBootstrap.class)
                .web(WebApplicationType.NONE)
                .run(args);
        String hello = context
                .getBean(\"helloWorld\", String.class);
        System.out.println(\"获取到的bean: \" + hello);
        context.close();
    }
}

运行结果也是能正确获取到bean。这里梳理一下整个流程：

  1. 使用@ EnableAutoConfiguration激活自动装配，Spring Boot会去spring.factories文件中解析需要自动装配的类 HelloWorldAutoConfiguration
  2. 装配HelloWorldAutoConfiguration的时候会去判断是否满足装配要求，这里是jdk1.8的环境，所以是满足要求的
  3. HelloWorldAutoConfiguration是被@ EnableHelloWorld标注了，@ EnableHelloWorld通过@ Import({HelloWorldImportSelector.class})的方式引入了HelloWorldImportSelector
  4. 在HelloWorldImportSelector的selectImports方法中返回了HelloWorldConfiguration的类名
  5. 在HelloWorldConfiguration中加载helloWorld

源码已上传至gitee：点击访问

参考：

SpringBoot自动装配原理分析

慕课网：Spring Boot2.0深度实践之核心技术篇

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.lingxiaomz.top/articleContent/?id=104722153606669090

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    微信公众号

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com