Spring注解驱动开发---向Spring Ioc容器中注册Bean的7种方式

前言

Spring是一个非常强大的反转控制(IOC)框架，以帮助分离项目组件之间的依赖关系。因此可以说Spring容器对Bean的注册、管理可以说是它的核心内容，最重要的功能部分。

因此本文主要介绍：向Spring容器注册Bean的多种方式

向Spring IOC容器注册Bean 的7种方式

1、xml方式（老方式，现在使用得非常的少）

在resource类路径创建一个文件：beans.xml

然后main函数采用ClassPathXmlApplicationContext来启动Spring容器容器：

    public static void main(String[] args) {
        ApplicationContext applicationContext = createNewApplicationContext();
        Person bean = applicationContext.getBean(Person.class);
        System.out.println(bean); //Person(name=fsx, age=18)
    }

    //创建、启动Spring容器
    private static ApplicationContext createNewApplicationContext() {
        return new ClassPathXmlApplicationContext("classpath:beans.xml");
    }

从这便可以看出，这个bean就直接放到Spring容器里面了。

2、@Configuration @Bean配置类的方式

创建一个配置类

/**
 * @author fangshixiang
 * @description
 * @date 2019-01-30 14:28
 */
@Configuration //该注解就相当于一个xml配置文件
public class MainConfig {

    @Bean(value = "person")
    public Person person() {
        return new Person("fsx", 18);
    }

}

这样我们使用AnnotationConfigApplicationContext来启动容器了：

    //创建、启动Spring容器
    private static ApplicationContext createNewApplicationContext() {
        return new AnnotationConfigApplicationContext(MainConfig.class);
    }

效果同上，同样能向容器中放置一个Bean。

@Bean若不指定value值，bean的id默认为方法名的名称。可以指定init-method,destroy-method方法。但是需要注意：单实例Bean容器是管理bean的init和destroy方法的，但是多实例bean容器只管帮你创建和init，之后Spring就不管了

@Bean相关注解：@Scope、@Lazy等

如果是单实例Bean，IOC容器启动时就立马创建Bean，以后获取都从容器里拿(当然你也可以加上@Lazy这个注解，让单实例Bean也懒加载)。如果是多实例Bean，Bean只有获取的时候，获取一次就创建一次。

3、使用@ComponentScan扫描注册组件

只要标注了注解就能扫描到如：@Controller @Service @Repository @component

配置类中加上这个注解：

@Configuration //该注解就相当于一个xml配置文件
@ComponentScan("com.fsx")
public class MainConfig {

}

实体类上加上一个组件组件，让其能扫描到：

@Component
public class Person {

    private String name;
    private Integer age;

}

实体类上加上一个组件组件，让其能扫描到：

@Component
public class Person {

    private String name;
    private Integer age;

}

启动Spring容器输出可以看到：

    //创建、启动Spring容器
    private static ApplicationContext createNewApplicationContext() {
        return new AnnotationConfigApplicationContext(MainConfig.class);
    }

输出为：
Person(name=null, age=null)

备注：这种扫描的方式，请保证一定要有空构造函数，否则报错的。。。

@ComponentScan有很多属性，可以实现更加精确的扫描。比如：basePackageClasses、includeFilters、excludeFilters、lazyInit、useDefaultFilters等。需要注意的是，要使includeFilters生效，需要useDefaultFilters=false才行，否则默认还是全扫

FilterType枚举的过滤类型，可以实现注解、正则等的精确匹配。当然也能CUSTOM自己实现接口来过滤，功能不可谓不强大

4、@Conditional按照条件向Spring中期中注册Bean

 /*
 * @author Phillip Webb
 * @author Sam Brannen
 * @since 4.0
 * @see Condition
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {

	/**
	 * All {@link Condition}s that must {@linkplain Condition#matches match}
	 * in order for the component to be registered.
	 */
	Class[] value();

}

这个接口是Spirng4提供出来的。在SpringBoot底层大量的用到了这个接口来按照条件注册Bean。

从注解的属性value来看，我们可以传入Condition条件，因此我们可以传入系统自带的，也可以我们自己去实现这个接口，按照我们的需求来注册Bean

从上图可以看出，SpringBoot工程中对此接口有大量的实现。本文通过自己的实现，来看看根据条件注册Bean的强大之处。

比如我们要实现如下功能：
如果系统是windows，给容器中注入"bill"，如果系统是linux，给容器中注入"linus"

  public class WindowCondition implements Condition{
  
      /**
       * @param context 判断条件
       * @param metadata 注释信息
       * @return boolean
       */
      @Override
      public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
          Environment environment = context.getEnvironment();
          String property = environment.getProperty("os.name");
          if (property.contains("Windows")) {
              return true;
          }
          return false;
      }
  }

需要注意的是，context还有以下方法：

  // 能获取ioc使用的beanfactory
  ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
  // 能获取到类加载器
  ClassLoader classLoader = context.getClassLoader();
  // 获取到环境变量
  Environment environment = context.getEnvironment();
  // 获取到Bean定义的注册类
  BeanDefinitionRegistry registry = context.getRegistry();

LinuxCondition类的写法略。配置类如下：

@Configuration
public class MainConfig2 {

    @Conditional({WindowCondition.class})
    @Bean("bill")
    public Person person01() {
        return new Person("Bill Gates", 60);
    }
    @Conditional({LinuxCondition.class})
    @Bean("linux")
    public Person person02() {
        return new Person("linus", 45);
    }

}

运行：（测试时候可以设置运行时参数：-Dos.name=linux）

结果我们会发现，注册的Bean已经按照我们的条件去注册了

备注：@Conditonal注解不仅可以标注在方法上，还可以标注在类上。如果标注在配置类上，那么若不生效的话，这个配置类所有就将不会再生效了

5、@Improt快速导入一个组件

@Improt快速导入特别重要，在SpringBoot自动装配的过程中起到了非常关键的作用

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

	/**
	 * {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
	 * or regular component classes to import.
	 */
	Class[] value();

}

@Import可以导入第三方包，或则自己写的类，比较方便，Id默认为全类名(这个需要注意)

比如新建一个类Color：

public class Color {
}

配置类上：

@Import({Color.class})
@Configuration
public class MainConfig2 {}

6、ImportSelector和ImportBeanDefinitionRegistrar

ImportSelector：

public class MyImportSelector implements ImportSelector{

    // 返回值就导入容器组件的全类名
    // AnnotationMetadata:当前类标注的@Import注解类的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[] {"com.cuzz.bean.Car"};
    }
}

在配置类中，通过@Import导入

@Import({Color.class, MyImportSelector.class})
@Configuration
public class MainConfig2 {}

这样子我们发现，Car类已经被导入进去了。

ImportBeanDefinitionRegistrar：

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * @param importingClassMetadata 当前类的注解信息
     * @param registry 注册类
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 查询容器
        boolean b = registry.containsBeanDefinition("com.cuzz.bean.Car");
        // 如果有car, 注册一个汽油类
        if (b == true) {
            // 需要添加一个bean的定义信息
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Petrol.class);
            // 注册一个bean, 指定bean名
            registry.registerBeanDefinition("petrol", rootBeanDefinition);
        }

    }
}

配置类：

@Import({Color.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
@Configuration
public class MainConfig2 {}

在SpringBoot中的使用，举个栗子：
注解@ServletComponentScan的解析，从下面代码可以看出：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(ServletComponentScanRegistrar.class)
public @interface ServletComponentScan {}

在SpringBoot中的使用，举个栗子：
注解@ServletComponentScan的解析，从下面代码可以看出：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(ServletComponentScanRegistrar.class)
public @interface ServletComponentScan {}

是ServletComponentScanRegistrar注册进去和解析的。在看看这个类：

class ServletComponentScanRegistrar implements ImportBeanDefinitionRegistrar {}

它就是个标准的ImportBeanDefinitionRegistrar 。然后在方法registerBeanDefinitions这里面做了很多事：比如添加注解的后置处理器等等

7、使用FactoryBean注册组件

工厂Bean。此Bean非常的重要，因为第三方框架要和Spring整合，大都是通过实现此接口来实现的。

public interface FactoryBean {
	T getObject() throws Exception;
	Class getObjectType();
	default boolean isSingleton() {
		return true;
	}
}

举个例子，我自己来实现这个Bean接口：

public class ColorFactoryBean implements FactoryBean {
    // 返回一个Color对象
    @Override
    public Color getObject() throws Exception {
        return new Color();
    }

    @Override
    public Class getObjectType() {
        return Color.class;
    }
    // 是否为单例
    @Override
    public boolean isSingleton() {
        return true;
    }
}

通过@Bean注入到容器里：

    @Bean
    public ColorFactoryBean colorFactoryBean() {
        return new ColorFactoryBean();
    }

测试一下：

@Test
public void test05() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

    Object bean = applicationContext.getBean("colorFactoryBean");
    // 工厂bean调用的是getClass()方法
    System.out.println("colorFactoryBean的类型是: " + bean.getClass());
}

输出一下，发现此时的bean调用的方法是getObjectType方法输出为：class com.fsx.boot2demo1.bean.Color

如果需要获取FactoryBean本身，可以在id前面加一个“&”标识

Object bean2 = applicationContext.getBean("&colorFactoryBean");

这个时候输出的就是：com.fsx.boot2demo1.bean.ColorFactoryBean

抛出一个问题：为何不直接使用@Bean，而使用FactoryBean呢？
Spring 中有两种类型的Bean，一种是普通Bean，另一种是工厂Bean 即 FactoryBean。FactoryBean跟普通Bean不同，其返回的对象不是指定类的一个实例，而是该FactoryBean的getObject方法所返回的对象。创建出来的对象是否属于单例由isSingleton中的返回决定。

官方解释：
FactoryBean 通常是用来创建比较复杂的bean，一般的bean 直接用xml配置即可，但如果一个bean的创建过程中涉及到很多其他的bean 和复杂的逻辑，用xml配置比较困难，这时可以考虑用FactoryBean。

我的解释：
简单的说：它是用来处理复杂的Bean，在初始化过程中需要做很多事情（比如MyBatis的SqlSessionFactoryBean等等），从而屏蔽内部实现，对调用者/使用者友好的一种解决方案。
如果这种Bean用xml去配置，几乎是不可能的。当用注解驱动@Bean去做后，虽然也是可以的，但是很显然对调用很不友好的（因为我们使用MyBatis可不想去知道它初始化到底要做些啥事之类的）。因此使用这个方法是最优雅的解决方案。Spring在1.0就支持了这个接口，优秀~

总结
Spring提供了非常多的方式来向容器内注册Bean，从而来满足各式各样的需求。每种方式都有他独特的使用场景。比如@Bean是最长使用的，@Import导入Bean在SpringBoot的自动装配中得到了大量的使用。

一个成熟的框架很忌讳提供封闭的、不全的功能。而Spring在“开闭原则”上显然无疑是做得非常优秀的，值得深入学习