@Conditional註解 -【Spring底層原理】

時間  2021-08-14
標籤 java linux git github spring 數組 markdown app ide oop 欄目 Java 简体版
原文   原文鏈接

案例已上傳GitHub，歡迎star以鼓勵：github.com/oneStarLR/s…java

1、註解用法

@Conditional是Spring4新提供的註解，也是用來註冊bean的，做用以下：linux

  • 按照必定的條件進行判斷，知足條件的給容器註冊bean
  • 從源碼中咱們能夠看到，能夠做用在類和方法上
  • 須要傳入一個Class數組，並繼承Condition接口
// 能夠做用在類上，也能夠做用在方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    // 須要傳入一個Class數組
    Class<? extends Condition>[] value();
}

// 繼承Condition接口
@FunctionalInterface
public interface Condition {
    boolean matches(ConditionContext var1, AnnotatedTypeMetadata var2);
}
複製代碼

在繼承Condition接口中，咱們能夠獲取上下文環境，從而進行判斷，達到條件判斷的做用git

2、實例分析

經過實例來進行分析，以不一樣的操做系統爲條件，經過實現Condition接口，並重寫其matches方法來構造判斷條件，經過idea配置來改變操做系統環境，將注入的bean進行打印來進行判斷。github

// 啓動類
@Test
public void TestMain(){
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    String[] beanNames = applicationContext.getBeanDefinitionNames();
    for (String beanName : beanNames) {
        System.out.println(beanName);
    }
}

// User
public class User {
}

// 配置類
@Configuration
public class AppConfig {
    @Bean
    public User user1(){
        return new User();
    }

    @Bean
    public User user2(){
        return new User();
    }
}
複製代碼

上面的代碼，經過啓動測試類，會將user1和user2注入到容器，能夠看到打印結果以下：spring

image-20210221204501107

如今須要根據操做系統來進行條件注入，Windows系統下注入user1，Linux系統下注入user2，則須要實現Condition接口，並重寫其matches方法來構造判斷條件數組

  • 實現Condition接口：Windows系統判斷條件
// Windows系統判斷條件
public class WindowsCondition implements Condition {
    /** * @description TODO * @author ONESTAR * @date 2021/2/10 10:56 * @param conditionContext:判斷條件，能使用的上下問環境 * @param annotatedTypeMetadata：註釋信息 * @throws * @return boolean */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // 獲取當前環境
        Environment environment = conditionContext.getEnvironment();
        // 判斷是不是Windows系統
        String property = environment.getProperty("os.name");
        if (property.contains("Windows")){
            return true;
        }
        return false;
    }
}
複製代碼
  • 實現Condition接口：Linux系統判斷條件
// Linux系統判斷條件
public class LinuxCondition implements Condition {
    /** * @description 判斷操做系統是不是Linux系統 * @author ONESTAR * @date 2021/2/10 10:56 * @param conditionContext * @param annotatedTypeMetadata * @throws * @return boolean */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // 獲取當前環境
        Environment environment = conditionContext.getEnvironment();
        // 判斷是不是Linux系統
        String property = environment.getProperty("os.name");
        if (property.contains("linux")){
            return true;
        }
        return false;
    }
}
複製代碼
  • 修改配置類，使用@Conditional註解進行條件注入，修改後以下
@Configuration
public class AppConfig {
    // 若是WindowsCondition的實現方法返回true，則注入這個bean
    @Conditional({WindowsCondition.class})
    @Bean
    public User user1(){
        return new User();
    }

    // 若是LinuxCondition的實現方法返回true，則注入這個bean
    @Conditional({LinuxCondition.class})
    @Bean
    public User user2(){
        return new User();
    }
}
複製代碼

這時咱們再來運行啓動類，默認狀況下是Windows系統，能夠看到，只有user1注入進去了，user2並無注入markdown

image-20210221205808356

我們經過idea配置來模擬改變運行環境：添加：-Dos.name=linuxapp

image-20210221210032021

image-20210221205930027

改變運行環境後，我們再來運行啓動類，能夠看到，此時注入的是user2：ide

image-20210221210152727

3、源碼追蹤

參考：www.jianshu.com/p/566f22bda…oop

【1】ConditionEvaluator中matches方法

咱們知道，spring經過實現Condition接口，並重寫其matches方法來構造判斷條件，能夠從matches入手，查看源碼，發現ConditionEvaluator中調用了matches這個方法

image-20210224101144219

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    // 檢查註解中是否包含@Conditional類型的註解
    if (metadata != null && metadata.isAnnotated(Conditional.class.getName())) {
        // 判斷當前bean是解析仍是註冊
        if (phase == null) {
            // bean的註解信息封裝對象是AnnotationMetadata類型而且，類上有@Component，@ComponentScan，@Import，@ImportResource，則表示爲解析類型
            return metadata instanceof AnnotationMetadata && ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata)metadata) ? this.shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION) : this.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
        } else {
            List<Condition> conditions = new ArrayList();
            Iterator var4 = this.getConditionClasses(metadata).iterator();

            // 從bean的註解信息封裝對象中獲取全部的Conditional類型或者Conditional的派生註解
            while(var4.hasNext()) {
                String[] conditionClasses = (String[])var4.next();
                String[] var6 = conditionClasses;
                int var7 = conditionClasses.length;

                for(int var8 = 0; var8 < var7; ++var8) {
                    String conditionClass = var6[var8];
                    // 實例化Conditional中的條件判斷類（Condition的子類）
                    Condition condition = this.getCondition(conditionClass, this.context.getClassLoader());
                    // 添加到條件集合中
                    conditions.add(condition);
                }
            }

            // 根據Condition的優先級進行排序
            AnnotationAwareOrderComparator.sort(conditions);
            var4 = conditions.iterator();

            Condition condition;
            ConfigurationPhase requiredPhase;
            do {
                do {
                    if (!var4.hasNext()) {
                        return false;
                    }

                    condition = (Condition)var4.next();
                    requiredPhase = null;
                    // 若是是ConfigurationCondition類型的Condition
                    if (condition instanceof ConfigurationCondition) {
                        // 獲取須要對bean進行的操做，是解析仍是註冊
                        requiredPhase = ((ConfigurationCondition)condition).getConfigurationPhase();
                    }
                    //(若是requiredPhase==null或者指定的操做類型是目前階段的操做類型)而且不符合設置的條件則跳過
                } while(requiredPhase != null && requiredPhase != phase);
            } while(condition.matches(this.context, metadata));

            return true;
        }
    } else {
        return false;
    }
}
複製代碼

ConditionEvaluator這個類的做用是評估一個加了Conditional註解的類是否須要跳過。經過類上面的註解來判斷。該方法做用就是判斷當前bean處於解析仍是註冊

  • 若是處於解析階段則跳過，若是處於註冊階段則不跳過。
  • 其中Condition的matches方法就起到了判斷的是否符合的做用，進而判斷是否跳過當前bean。

【2】ConfigurationClassPostProcessor的processConfigBeanDefinitions

仍是經過查找ConditionEvaluator類的matches方法調用鏈的方式，發現最後都是在ConfigurationClassPostProcessor的processConfigBeanDefinitions中進行調用的。一共有兩個調用的位置，這裏用調用的位置的代碼進行展現

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList();
    // 獲取registry中定義的全部的bean的name
    String[] candidateNames = registry.getBeanDefinitionNames();
    ......
    do {
        // 第一個會調用shouldSkip的位置，這裏是解析可以直接獲取的候選配置bean。多是Component，ComponentScan，Import，ImportResource或者有Bean註解的bean
        StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
        parser.parse(candidates);
        parser.validate();
        // 獲取上面封裝已經解析過的配置bean的ConfigurationClass集合
        Set<ConfigurationClass> configClasses = new LinkedHashSet(parser.getConfigurationClasses());
        // 移除前面已經處理過的
        configClasses.removeAll(alreadyParsed);
        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment, this.importBeanNameGenerator, parser.getImportRegistry());
        }

        //第二個會調用shouldSkip的位置，這裏是加載configurationClasse中內部可能存在配置bean，好比方法上加了@Bean或者@Configuration標籤的bean
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);
        ......
    }
}
複製代碼
  • 經過parse方法解析BeanDefinitionRegistry中能直接獲取到的候選bean，並解析保存到ConfigurationClassParser類的保存解析過的配置類的集合configurationClasses中
  • loadBeanDefinitions則是對上面解析的集合configurationClasses中的bean內部的進一步的處理，處理類內部定義的bean

【3】ConfigurationClassParser的parse方法

public void parse(Set<BeanDefinitionHolder> configCandidates) {
    Iterator var2 = configCandidates.iterator();

    while(var2.hasNext()) {
        BeanDefinitionHolder holder = (BeanDefinitionHolder)var2.next();
        BeanDefinition bd = holder.getBeanDefinition();

        try {
            if (bd instanceof AnnotatedBeanDefinition) {
                this.parse(((AnnotatedBeanDefinition)bd).getMetadata(), holder.getBeanName());
            } else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition)bd).hasBeanClass()) {
                this.parse(((AbstractBeanDefinition)bd).getBeanClass(), holder.getBeanName());
            } else {
                this.parse(bd.getBeanClassName(), holder.getBeanName());
            }
        } catch (BeanDefinitionStoreException var6) {
            throw var6;
        } catch (Throwable var7) {
            throw new BeanDefinitionStoreException("Failed to parse configuration class [" + bd.getBeanClassName() + "]", var7);
        }
    }

    this.deferredImportSelectorHandler.process();
}

protected final void parse(@Nullable String className, String beanName) throws IOException {
    Assert.notNull(className, "No bean class name for configuration class bean definition");
    MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
    this.processConfigurationClass(new ConfigurationClass(reader, beanName), DEFAULT_EXCLUSION_FILTER);
}

protected final void parse(Class<?> clazz, String beanName) throws IOException {
    this.processConfigurationClass(new ConfigurationClass(clazz, beanName), DEFAULT_EXCLUSION_FILTER);
}

protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
    this.processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
複製代碼

在ConfigurationClassParser的parse方法中有三個分支，分別是對不一樣類型的BeanDefinition進行解析，這裏進入AnnotatedBeanDefinition類型的。

【4】調用processConfigurationClass方法

進入到parse方法後在進入裏面調用的processConfigurationClass方法，查看源碼，這裏就是對Conditional註解的做用了

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
    // 檢查當前解析的配置bean是否包含Conditional註解，若是不包含則不須要跳過
    // 若是包含了則進行match方法獲得匹配結果
    if (!this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
        ConfigurationClass existingClass = (ConfigurationClass)this.configurationClasses.get(configClass);
        if (existingClass != null) {
            if (configClass.isImported()) {
                if (existingClass.isImported()) {
                    existingClass.mergeImportedBy(configClass);
                }

                return;
            }

            this.configurationClasses.remove(configClass);
            this.knownSuperclasses.values().removeIf(configClass::equals);
        }

        ConfigurationClassParser.SourceClass sourceClass = this.asSourceClass(configClass, filter);

        do {
            sourceClass = this.doProcessConfigurationClass(configClass, sourceClass, filter);
        } while(sourceClass != null);

        this.configurationClasses.put(configClass, configClass);
    }
}
複製代碼

這裏就是對是否跳過bean解析的位置

  • 檢查當前解析的配置bean是否包含Conditional註解，若是不包含則不須要跳過
  • 若是包含了則進行match方法獲得匹配結果，若是是符合的而且設置的配置解析策略是解析階段不須要調過

4、總結

@Conditional註解主要經過指定的Condition實現類實現matches方法來決定是否須要進行解析，總結以下：

  1. 經過實現Condition接口，並重寫其matches方法來構造判斷條件
  2. 經過ConditionEvaluator中matches方法判斷當前bean處於解析仍是註冊，若是處於解析階段則跳過，若是處於註冊階段則不跳過
  3. 調用processConfigurationClass方法判斷當前解析的配置bean是否包含Conditional註解，若是不包含則不須要跳過，包含了則進行match方法獲得匹配結果
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程