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配置容器类
 * 用于代替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 = 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 = 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 = 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;
    }
}