spring 注解、配置类@Configuration

一、@Configuration使用：     
作用：相当于配置文件application.xml文件，只是将配置放在类中使用注解模式 7、spring xml配置：

①环境配置如下：     

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>4.3.21.RELEASE</version>
</dependency>

②bean对象：     

public class Person {
    private String name;
    private int age;
    
    public Person() {}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
     }
        
    public void setName(String name) {
        this.name = name; 
     }
        
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

③配置类：     

@Configuration //配置类 = 配置文件
//使用包扫描，可以是数组,includeFilters包含哪些注解(默认)类型的组件，这里是扫描包含controller类型的组件；excludeFilters不包含哪些
@ComponentScan(value = {"com.zixue"},includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class})}) 
@Import(value = {Person.class,Person.class})//容器中导入多个组件，id是全类名
public class MainConfig {
	//bean 相当于application.xml配置中的bean标签<bean id="" class=""/>
    @Bean("persion01") //将bean注入ioc容器，类型为返回值类型，id默认为方法名
    public Person person(){
        return new Person("li",20);
    }
}

public class Demo {

    public static void main(String[] args) {
		//使用注解配置类，配置信息
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);

        Person p = applicationContext.getBean(Person.class);
        System.out.println(p);

        String[] names = applicationContext.getBeanDefinitionNames();
        for (String name : names) {
        System.out.println(name);

        }
    }

}

④自定义组件过滤器，实现容器限制某些bean注入：     

@ComponentScan(value = {"com.zixue"} ,excludeFilters = {@ComponentScan.Filter(
//        type = FilterType.ANNOTATION,value = {Controller.class} 注解过滤
        type = FilterType.CUSTOM,value = {MyTypeFilter.class}//自定义过滤规则，匹配成功就过滤掉
    )})
@Configuration //配置类 = 配置文件
public class MainConfig {

    @Bean("persion01") //将bean注入ioc容器，类型为返回值类型，id默认为方法名
    public Person person(){
        return new Person("li",20);
    }
}
===============================================================================
//metadataReader 可以获取当前类信息
//metadataReaderFactory 获取其他类信息
public class MyTypeFilter implements TypeFilter {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        //获取当前注解信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取类信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取类路径，资源
        Resource resource = metadataReader.getResource();
        //获取类名
        String className = classMetadata.getClassName();
        System.out.println("--->" + className + resource);
        if (className.contains("e")) {
            return true;//表示匹配成功，excludeFilters 就是不放容器中
        }
        return false;//表示匹配失败
    }
}

二、@Conditional 条件判断     

@Conditional(value = {WindowsConditional.class})//可以放在方法和类上用来表示哪些bean可以注入容器

@Conditional(value = {WindowsConditional.class})//可以放在方法和类上用来表示哪些bean可以注入容器
@ComponentScan(value = {"com.zixue"} ,excludeFilters = {@ComponentScan.Filter(
//        type = FilterType.ANNOTATION,value = {Controller.class}
        type = FilterType.CUSTOM,value = {MyTypeFilter.class}
    )})
@Configuration //配置类 = 配置文件
public class MainConfig {

    @Bean("persion01") //将bean注入ioc容器，类型为返回值类型，id默认为方法名
    public Person person(){
        return new Person("li",20);
    }
}

自定义一个过滤条件需要实现Condition ，让满足条件的bean注入ioc容器

public class WindowsConditional implements Condition {//
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //ConditionContext 条件使用的上下文信息
        //AnnotatedTypeMetadata 注解数据
        Environment environment = context.getEnvironment();//当前环境
        String property = environment.getProperty("os.name");
        if (null != property && property.contains("Windows")){
            return true;//true可以注入
        }

        return false;
    }
}

三、@Import 注入容器     
第二种方式是@Import(value = {Person.class,MyImportSelect.Class})，MyImportSelect实现ImportSelect类的方法实现将全包名的数组类，注入容器。

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {

	//返回值，就是到导入到容器中的组件全类名
	//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		// TODO Auto-generated method stub
		//importingClassMetadata
		//方法不要返回null值
		return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
	}

}

四、BeanFactory     
默认无参构造，如下然后使用配置类注入bean

import org.springframework.beans.factory.FactoryBean;

//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

	//返回一个Color对象，这个对象会添加到容器中
	@Override
	public Color getObject() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("ColorFactoryBean...getObject...");
		return new Color();
	}

	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Color.class;
	}

	//是单例？
	//true：这个bean是单实例，在容器中保存一份
	//false：多实例，每次获取都会创建一个新的bean；
	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return false;
	}

}