Spring Boot 使用Java代码创建Bean并注冊到Spring中

从 Spring3.0 開始，添加了一种新的途经来配置Bean Definition，这就是通过 Java Code 配置 Bean Definition。

与Xml和Annotation两种配置方式不同点在于：

前两种Xml和Annotation的配置方式为提前定义方式，即开发者通过 XML 文件或者 Annotation 提前定义配置 bean 的各种属性后，启动 Spring 容器，Spring 容器会首先解析这些配置属性，生成相应都?Bean Definition，装入到 DefaultListableBeanFactory 对象的属性容器中去。与此同一时候，Spring 框架也会定义一些内部使用的 Bean 定义。如 bean 名为”org.springframework.context.annotation.internalConfigurationAnnotationProcessor”的 ConfigurationClassPostProcessor 定义。

而后此刻不会做不论什么 Bean Definition 的定义解析动作。Spring 框架会依据前两种配置，过滤出 BeanDefinitionRegistryPostProcessor 类型的 Bean 定义，并通过 Spring 框架生成其相应的 Bean 对象（如 ConfigurationClassPostProcessor 实例）。结合 Spring 上下文源代码可知这个对象是一个 processor 类型工具类，Spring 容器会在实例化开发者所定义的 Bean 前先调用该 processor 的 postProcessBeanDefinitionRegistry(…) 方法。此处实现基于 Java Code 配置Bean Definition的处理。

基于 Java Code 解析 Bean 的顺序图（查看大图）



该图供大家了解就可以，这里不做具体说明。

基于 Java Code 的配置方式，其运行原理不同于前两种。

它是在 Spring 框架已经解析了基于 XML 和 Annotation 配置后，通过添加 BeanDefinitionRegistryPostProcessor 类型的 processor 来处理配置信息，让开发者通过 Java 编程方式定义一个 Java 对象。

其长处在于能够将配置信息集中在一定数量的 Java 对象中，同一时候通过 Java 编程方式，比基于 Annotation 方式具有更高的灵活性。而且该配置方式给开发者提供了一种很好的范例来添加用户自己定义的解析工具类。其主要缺点在于与 Java 代码结合紧密，配置信息的改变须要又一次编译 Java 代码，另外这是一种新引入的解析方式，须要一定的学习成本。

另外提及一点的就是，Spring框架有3个基本的Hook类，各自是：

org.springframework.context.ApplicationContextAware

它的setApplicationContext 方法将在Spring启动之前第一个被调用。我们用来同一时候启动Jdon框架。

org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor

它的postProcessBeanDefinitionRegistry 和 postProcessBeanFactory 方法是第二和第三被调用，它们在Bean初始化创建之前启动，假设Spring的bean须要的其它第三方中的组件，我们在这里将其注入给Spring。

org.springframework.context.ApplicationListener

用于在初始化完毕后做一些事情，当Spring全部XML或元注解的Bean都启动被创建成功了，这时会调用它的唯一方法onApplicationEvent。

以下我们来完毕一个，自己通过java代码创建bean，并注冊为Spring管理。

本例中，我们创建一个接口，然后创建该接口的2个实现类。分别命名不同的名字。然后在须要注入的地方使用@Qualifier 指定注入相应的实例。

1、接口Shanhy.java

package org.springboot.sample.config;

public interface Shanhy {

    void display();

}

2、实现类ShanhyA.java

package org.springboot.sample.config;

public class ShanhyA implements Shanhy {

    @Override
    public void display() {
        System.out.println("AAAAAAAAAAAA");
    }

}

3、实现类ShanhyB.java

package org.springboot.sample.config;

public class ShanhyB implements Shanhy {

    @Override
    public void display() {
        System.out.println("BBBBBBBBBBBB");
    }

}

4、定义接口BeanDefinitionRegistryPostProcessor的实现

package org.springboot.sample.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.context.annotation.AnnotationConfigUtils;
import org.springframework.context.annotation.AnnotationScopeMetadataResolver;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ScopeMetadata;
import org.springframework.context.annotation.ScopeMetadataResolver;

/**
 * 实现自己实例化bean并注冊为Spring管理
 *
 * @author   单红宇(365384722)
 * @myblog  http://blog.csdn.net/catoop/
 * @create    2016年1月21日
 */
@Configuration
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    private static final Logger logger = LoggerFactory.getLogger(MyBeanDefinitionRegistryPostProcessor.class);

    private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
    private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        logger.info("Invoke Metho postProcessBeanFactory");
        // 这里能够设置属性，比如
        BeanDefinition bd = beanFactory.getBeanDefinition("dataSourceA");
        MutablePropertyValues mpv =  bd.getPropertyValues();
        mpv.addPropertyValue("driverClassName", "com.mysql.jdbc.Driver");
        mpv.addPropertyValue("url", "jdbc:mysql://localhost:3306/test");
        mpv.addPropertyValue("username", "root");
        mpv.addPropertyValue("password", "123456");
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        logger.info("Invoke Metho postProcessBeanDefinitionRegistry");
        registerBean(registry, "shanhyA", ShanhyA.class);
        registerBean(registry, "shanhyB", ShanhyB.class);
        registerBean(registry, "dataSourceA", org.apache.tomcat.jdbc.pool.DataSource.class);
    }

    private void registerBean(BeanDefinitionRegistry registry, String name, Class<?> beanClass){
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);

        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        // 能够自己主动生成name
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, registry));

        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }
}

5、使用測试

和寻常一样能够直接注入我们的对象，对于相同接口的我们须要指定name

/**
 * 測试參数注入
 *
 * @author   单红宇(365384722)
 * @myblog  http://blog.csdn.net/catoop/
 * @create    2016年1月13日
 */
@Configuration
public class MyConfiguration {

    @Bean
    public FilterRegistrationBean filterRegistrationBean(@Qualifier("shanhyB") Shanhy shanhy) {
        FilterRegistrationBean filterRegistration = new FilterRegistrationBean();
        shanhy.display();
        // 省略代码
        return filterRegistration;
    }
}

使用@Resource 或者 @Autowired并指定@Qualifier 也能够

@RestController
@RequestMapping("/hello")
public class HelloController {

    @Resource(name="shanhyA")
    private Shanhy shanhyA;

    @Autowired
    @Qualifier("shanhyB")
    private Shanhy shanhyB;

    // 省略代码

}

这里有点经验要说一下。在 @Configuration 中，不能使用注入属性的方式注入。仅仅能通过參数的方式注入。其原因就是@Configuration的类一開始变被载入。此时你想进行属性注入，须要注入的bean对象都还不存在呢。

下一篇文章，我们将使用这样的方法动态创建基于MyBatis的多数据源。

---

以下的代码片段也能够注冊Bean，比較简单：

@Configuration
@Import(Registrar.class)
public class TestConfig {

}

class Registrar implements ImportBeanDefinitionRegistrar {

    private static final String BEAN_NAME = "myTestBean";

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        if (!registry.containsBeanDefinition(BEAN_NAME)) {
            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
            beanDefinition.setBeanClass(ExamplePostProcessor.class);
            beanDefinition.setSynthetic(true);
            registry.registerBeanDefinition(BEAN_NAME, beanDefinition);
        }
    }

}