使用spring配置类代替xml配置文件注册bean类

spring配置类，即在类上加@Configuration注解，使用这种配置类来注册bean，效果与xml文件是完全一样的，只是创建springIOC容器的方式不同：

//通过xml文件创建springIOC容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-beans.xml");
//通过配置类创建springIOC容器
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);

0. 传统的xml配置文件方式注册bean类

单个注册

<!--单实例模式-->
<bean id="person" class="cn.monolog.entity.Person" scope="singleton" />
<!--多实例模式-->
<bean id="book" class="cn.monolog.entity.Book" scope="prototype" />

扫描批量注册，只能注册加了组件注解(@Repository、@Service、@Controller、@Component)的类

<!--通过扫描批量注册加了组件注解的bean-->
<context:component-scan base-package="cn.monolog.entity" />

1. 使用配置类单个注册

①在配置类上加@Configuration注解

②在方法上加@Bean注解，bean的id默认为方法名，如果需要自定义id，则在该注解上加value属性

③如果需要指定bean的作用域，则还要在方法上加@Scope注解，如果不加该注解，则默认为单例模式

该注解的value属性有如下几种常用取值(均为字符串格式)

单例模式(singleton): 创建IOC容器时即创建bean对象，以后每次取值都是取的这个bean对象

原型模式(protortype): 创建IOC容器时不创建bean对象，以后每次取值时再分别创建

另外还有request、session、global session

④对于单例模式，还可以加@Lazy注解，即懒加载，表示在创建IOC容器时并不创建bean对象，而是在第一次获取bean对象时才创建，之后再获取bean对象时不再创建，因此仍然是单实例

懒加载的作用：加快SpringIOC容器的启动速度、解决循环依赖的问题

/**
 * springIOC配置容器类
 * 用于代替spring-beans.xml，生成bean对象
 */
@Configuration
public class BeanConfig {

    //生成Person实例
    @Bean(value = "person")
    public Person person() {
        String name = "张三";
        int age = 29;
        return new Person(name, age);
    }

    /**
     * 使用单实例模式生成Book实例
     * 这时，是在springIOC容器启动时就创建了bean实例，然后每次获取实例时，直接从容器中拿
     */
    @Bean(value = "singleBook")
    @Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
    public Book singleBook() {
        String name = "hello world";
        double price = 29.00D;
        return new Book(name, price);
    }

    /**
     * 使用多实例模式生成Book实例
     * 这时，启动springIOC容器时并未创建bean实例，而是每次获取bean实例时再调用该方法去新创建
     */
    @Bean(value = "multipleBook")
    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public Book multipleBook() {
        String name = "hello world";
        double price = 29.00D;
        return new Book(name, price);
    }

  /**
     * 使用懒加载模式生成bean实例
     * 懒加载只对单实例模式有效
     * 本来，单实例模式，是在启动springIOC容器时创建bean实例
     * 使用懒加载后，在启动springIOC容器时并不创建bean实例，而是在首次获取bean时才创建
     */
    @Bean(value = "person")
    @Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
    @Lazy
    public Person person() {
        return new Person("刘能", 53);
    }  
}

2. 使用配置类扫描批量注册，只能注册加了组件注解(@Repository、@Service、@Controller、@Component)的类

①在配置类上加@Configuration注解

②在配置类上加@ComponentScan注解，并在其basePackages属性(字符串数组类型)中写明要扫描的包，可以写1个或多个包，如果想排除某些类，可以写在excludeFilter属性中

/**
 * 通过扫描批量注册加了组件注解的bean
 * 并排除Dog类
 */
@Configuration
@ComponentScan(basePackages = {"cn.monolog.entity", "cn.monolog.service", "cn.monolog.dao"},
excludeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {Dog.class})})
public class BeanConfig {
}

3. 按条件注册

①在配置类上加@Configuration注解

②在方法上加@Bean注解，bean的id默认为方法名，如果需要自定义id，则在该注解上加value属性

③在方法上加@Conditional注解，该注解的参数是字节码数组，什么样的类的字节码呢？必须是实现了Condition接口的。使用时，需要自定义1个或多个Condition的实现类，并在其实现方法中定义生效条件，当满足生效条件时，才会去注册该bean类

import org.springframework.context.annotation.Condition;

/**
 * springIOC条件注册中的条件类
 */
public class JuventusCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取bean注册器
        BeanDefinitionRegistry registry = context.getRegistry();

        //判断该IOC容器中是否含有id为juventus的组件，如果是，则生效
        if (registry.containsBeanDefinition("juventus")) {
            return true;
        }

        return false;
    }
}

/**
 * 按条件注册bean类
 */
@Configuration
public class BeanConfig {
    
    /**
     * 按条件生成名字为ronaldo的Person对象
     * 条件为写在JuventusCondition类中
     */
    @Bean(value = "ronaldo")
    @Scope(value = SCOPE_SINGLETON)
    @Conditional({JuventusCondition.class})
    public Person ronaldo() {
        return new Person("ronaldo", 34);
    }
}

4. 使用导入方式注册

①在配置类上加@Configuration注解

②在配置类上加@Import注解，该注解的value属性为字节码数组，可以接收以下三种类的字节码

要注册的类；

实现了ImportSelector接口的自定义类，其实现方法的返回值为要注册的类的全限定名数组；

实现了ImportBeanDefinitionRegistrar的自定义类，在其实现方法中，使用BeanDefinitionRegistry手动注册，前面两种方式注册的bean的id只能是类的全限定名，只有这种方式可以自定义bean的id；

import org.springframework.context.annotation.ImportSelector;

/**
 * 使用import注解注册bean的选择器
 * 注意该方法可以返回空数组，但不能返回null，因为在后续源码中会获取返回值的长度
 * 而且这里只能用类的全限定名
 */
public class ColorImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        String[] results = {"cn.monolog.entity.Green", "cn.monolog.entity.Pink"};
        return results;
    }
}

import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;

/**
 * 使用import注解注册bean时，自定义bean选择器
 * 在该类的实现方法中，使用bean注册器手动注册
 * 注意，如果多次为同一个id注册bean，后面的会覆盖前面的
 */
public class ColorDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //判断该容器中是否已经存在id为yellow的组件，如果不存在，则手动注册
        String id = "yellow";
        if (!registry.containsBeanDefinition(id)) {
            //bean的id
            String beanName = "yellow";
            //bean的类型
            BeanDefinition beanDefinition = new RootBeanDefinition(Yellow.class);
            registry.registerBeanDefinition(beanName, beanDefinition);
        }
    }
}

/**
 * springIOC容器配置类
 * 使用import注解注册bean
 * 该注解可以接收三种参数
 * 1.要注册的类的字节码
 * 2.ImportSelector的自定义实现类的字节码，在其实现方法中，将要注册的类的全限定名写入返回数组
 * 3.ImportBeanDefinitionRegistrar的自定义实现类的字节码，在其实现方法中，使用bean注册器手动注册
 * 其中，前两种方式注册的bean的id只能是该类的全限定名
 * 第三种方式注册的bean类可以自定义id
 */
@Configuration
@Import({Red.class, ColorImportSelector.class, ColorDefinitionRegistrar.class})
public class BeanConfig {
}

5. 使用工厂模式注册

工厂模式与第1条(单个注册)的方法完全相同，唯一的特别之处在于，注册的是一个"工厂类"，即实现了FactoryBean<T>接口的自定义类，这种类的特点是，在IOC容器中直接按id获取的并不是它本身的对象，而是它内部注册的bean类的对象。要想获取它本身的对象，要在id前面拼接"&"符号。

FactoryBean<T>接口有三个方法：

getObject——用于注册真正的bean类

getObjectType——用于获取bean类的类型，即泛型T

isSingleton——注册的bean类是否为单例模式

import org.springframework.beans.factory.FactoryBean;

/**
 * 工厂类
 */
public class ColorFactoryBean implements FactoryBean<Color> {

    //注册bean
    @Override
    public Color getObject() throws Exception {
        return new Color("#FFF");
    }

    //获取bean的类型
    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }

    //是否单实例模式
    @Override
    public boolean isSingleton() {
        return true;
    }
}