@Conditional和@Import

@Conditional

它是Spring-context包下的一个注解
按照一定的条件判断，满足条件给容器中注册Bean组件，它有很多扩展。

@Import

用法一：引入其他配置类

@Configuration
public class MyConfig3 {
	//....
}

@Configuration
@Import({MyConfig3.class})
public class SpringConfig {
}

用法二：引入包选择器

具体实现：实现ImportSelector 接口，重写selectImports方法

public class MyImportSelector implements ImportSelector {
    /**
     * @param importingClassMetadata: 当前标注了@Import注解类的所有注解的信息
     * @return String[] 数组，返回需要导入的组件的全类名数组
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        int i = 0;
        String className = importingClassMetadata.getClassName();
        System.out.println("标注@Import注解的类："+className);
        Set<String> annotationTypes = importingClassMetadata.getAnnotationTypes();
        for (String annotationType : annotationTypes) {
            System.out.println("标注@Import注解类上的全部注解"+i+": "+annotationType);
            i++;
        }
        String[] s = new String[]{"com.herd.bean.Person","com.herd.bean.Red"};
        return s;
    }
}

@Import({MyImportSelector.class)
public class SpringConfig {
}

用法三：引入bean定义注册信息 手工注册

具体实现：实现ImportBeanDefinitionRegistrar 接口，重写registerBeanDefinitions方法

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     *
     * @param importingClassMetadata 当前类的注解信息
     * @param registry  BeanDefinition注册类：
     *                  把所有需要添加到容器中的bean，注册; 
     *                  通过registry.registerBeanDefinitions()手工注册
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        //判断容器中是否包含某个bean
        boolean definition = registry.containsBeanDefinition("com.herd.bean.Person");
        System.out.println("是否含有com.herd.bean.Person的bean："+definition);
        int count = registry.getBeanDefinitionCount();
        System.out.println("容器中bean的数量："+count);
        /**
         * 手工注册
         */
        RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
        //自定义bean的名称
        registry.registerBeanDefinition("rainBow",beanDefinition);
    }
}

public class RainBow {
}

用法四：自己写的bean或者第三方

//自己写的类
public class Blue {
}

@Configuration
@Import({Blue.class, DateFormatterRegistrar.class})
public class MyConfig {

}

最后一种：引入一个FactoryBean

具体实现：实现FactoryBean，重写方法

public class ColorFactoryBean implements FactoryBean {

	//返回bean
    @Override
    public Object getObject() throws Exception {
        return new Pink();
    }
	//bean的类型
    @Override
    public Class<?> getObjectType() {
        return Pink.class;
    }
	//是否单例
    @Override
    public boolean isSingleton() {
        return true;
    }
}

//pink类
public class Pink {
}

@Configuration
@Import({ColorFactoryBean.class})
public class SpringConfig {
}

注意：默认获取的时getObject()方法中的对象，若是想要获取ColorFactoryBean对象，则在获取时加上一个&

 @Test
    public void test03(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        //打印容器中所有的bean
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        Object bean = context.getBean("com.herd.condition.ColorFactoryBean");
        System.out.println(bean);
        Object bean1 = context.getBean("&com.herd.condition.ColorFactoryBean");
        System.out.println(bean1);
    }

结果：

---

使用：AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(xxxConfig.class);加载配置类