@Conditional 的学习

1、@Conditional 的用的方式

放在类上或者方法上

2、@Conditional 的作用

• 用在方法上让用@Conditional的方法返回的bean是否生效,判断依据是@Conditional注解的属性写的类中matchs方法的返回值。
• 用在类上让用@Conditional的类以及如果类里面的有bean的话是否让bean生效()判断依据是@Conditional注解的属性写的类中matchs方法的返回值

3、@Conditional 用在方法上

3.1 定义一个Condition

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class LinuxSystem implements Condition {

    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {

        ConfigurableListableBeanFactory configurableListableBeanFactory = conditionContext.getBeanFactory();

        Environment environment = conditionContext.getEnvironment();

        ClassLoader classLoader = conditionContext.getClassLoader();

        //获取bean定义的注册类
        BeanDefinitionRegistry beanDefinitionRegistry = conditionContext.getRegistry();
        
        //判断是否注册了某个bean
        beanDefinitionRegistry.containsBeanDefinition("person");
        
        String property = environment.getProperty("os.name");


        if(property.contains("Mac")){
            return true;
        }


        return false;
    }
}

3.2 使用Condition

@Configuration
public class MainConfig {

    /**
     *
     *
     * 如果是linux 系统就注册 person1
     * @return
     */
    @Bean("person1")
    @Conditional(LinuxSystem.class)
    public Person person(){
        Person p= new Person(12,"gaohq");

        return p;
    }
}

4、放在类上

4.1 放在配置类上

/**
 *
 *  Conditional 用在类上意思是LinuxSystem 接口返回的值是true就生效
 */
@Conditional(LinuxSystem.class)
@Configuration
public class MainConfig {

    /**
     *
     *
     * 如果是linux 系统就注册 person1
     * @return
     */
    @Bean("person1")
    @Conditional(LinuxSystem.class)
    public Person person(){
        Person p= new Person(12,"gaohq");

        return p;
    }
}

4.2 用在普通的类上

@Conditional(WindowsSystem.class)
@Component
public class Person {

    private int age;
    private String name;


//    public Person(int age, String name) {
//        this.age = age;
//        this.name = name;
//    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }


}

 

 

 

5、测试

public class TestA {
    public static void main(String[] args) {


		AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		String[] strings = annotationConfigApplicationContext.getBeanDefinitionNames();
		for (int i = 0; i < strings.length; i++) {
			System.out.println(strings[i]);
		}

	}
}

6、@Conditional 常见的派生注解

在SpringBoot中这样的派生注解有很多，这里用常见的几个举例来说明

6.1 @ConditionalOnBean

import com.ali.gts.provider.facade.provider.domain.Pet;
import com.google.inject.internal.cglib.proxy.$MethodProxy;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//1、告诉SpringBoot 这是一个配置类== 原来的配置文件
//2、并且这个配置类也是一个组件
//
@Configuration
public class MyConfig {

    @ConditionalOnBean(name = "user") //当容器里面有叫user 这个组件时当前组件才会注册到Spring容器里面
    @Bean  //给容器中添加组件，默认id是方法名，默认是单实例的
    public Pet tomcatPet(){
        return  new Pet("tomcat");
    }
}

//1、返回我们的IOC容器
ConfigurableApplicationContext configurableApplicationContext = SpringApplication.run(ProviderApplication.class, args);

System.err.println(configurableApplicationContext.containsBean("tomcatPet"));

6.2 @ConditionalOnMissingBean

import com.ali.gts.provider.facade.provider.domain.Pet;
import com.google.inject.internal.cglib.proxy.$MethodProxy;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//1、告诉SpringBoot 这是一个配置类== 原来的配置文件
//2、并且这个配置类也是一个组件
//
@Configuration
public class MyConfig {
    /**
     * 1、可以用在方法上
     *  当容器里面没有有叫user 这个组件时当前组件才会注册到Spring容器里面
     * 2、可以用在类上
     *   当容器里面没有有叫user 当前类里面注册的bean 才会放到Spring容器里面
     *
     */
    @ConditionalOnMissingBean(name = "user")
    @Bean  //给容器中添加组件，默认id是方法名，默认是单实例的
    public Pet tomcatPet(){
        return  new Pet("tomcat");
    }
}