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;
}
}
