Spring Boot 使用Java代碼創建Bean並注冊到Spring中

版權聲明：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/catoop/article/details/50558333

 

聲明同一個類下的多個實例：

package com.thunisoft.ssptsppt.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
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.*;

@Configuration
public class MultiBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    private static final Logger logger = LoggerFactory.getLogger(MultiBeanDefinitionRegistryPostProcessor.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.Driver1");
        mpv.addPropertyValue("url", "jdbc:mysql://localhost:3306/test1");
        mpv.addPropertyValue("username", "root1");
        mpv.addPropertyValue("password", "1234561");

        BeanDefinition bd2 = beanFactory.getBeanDefinition("dataSourceB");
        MutablePropertyValues mpv2 = bd2.getPropertyValues();
        mpv2.addPropertyValue("driverClassName", "com.mysql.jdbc.Driver2");
        mpv2.addPropertyValue("url", "jdbc:mysql://localhost:3306/test2");
        mpv2.addPropertyValue("username", "root2");
        mpv2.addPropertyValue("password", "1234562");
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        logger.info("Invoke Metho postProcessBeanDefinitionRegistry");
        registerBean(registry, "dataSourceA", org.apache.tomcat.jdbc.pool.DataSource.class);
        registerBean(registry, "dataSourceB", 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());
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, registry));
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }
}

　　

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

}

 

=============

============

===========

 

Spring點滴十一：Spring中BeanFactoryPostProcessor和BeanPostProcessor區別

 

     Spring中BeanFactoryPostProcessor和BeanPostProcessor都是Spring初始化bean時對外暴露的擴展點。兩個接口從名字看起來很相似，但是作用及使用場景卻不同。

關於BeanPostProcessor介紹在這篇文章中已經講過：http://www.cnblogs.com/sishang/p/6576665.html 這里主要介紹BeanFactoryPostProcessor。

    Spring IoC容器允許BeanFactoryPostProcessor在容器實例化任何bean之前讀取bean的定義(配置元數據)，並可以修改它。同時可以定義多個BeanFactoryPostProcessor，通過設置'order'屬性來確定各個BeanFactoryPostProcessor執行順序。

   注冊一個BeanFactoryPostProcessor實例需要定義一個Java類來實現BeanFactoryPostProcessor接口，並重寫該接口的postProcessorBeanFactory方法。通過beanFactory可以獲取bean的定義信息，並可以修改bean的定義信息。這點是和BeanPostProcessor最大區別

    public interface BeanFactoryPostProcessor {  
      
        /** 
         * Modify the application context's internal bean factory after its standard 
         * initialization. All bean definitions will have been loaded, but no beans 
         * will have been instantiated yet. This allows for overriding or adding 
         * properties even to eager-initializing beans. 
         * @param beanFactory the bean factory used by the application context 
         * @throws org.springframework.beans.BeansException in case of errors 
         */  
        void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;  
      
    }  

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 支持Spring注解 -->
    <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />
    <!-- 注冊一個BeanPostProcessor -->
    <bean id="postProcessor" class="com.test.spring.PostProcessor"/>
    <!-- 注冊一個BeanFactoryPostProcessor -->
    <bean id="factoryPostProcessor" class="com.test.spring.FactoryPostProcessor"/>
    <!-- 普通bean -->
    <bean id="beanFactoryPostProcessorTest" class="com.test.spring.BeanFactoryPostProcessorTest">
           <property name="name" value="張三"/>
           <property name="sex" value="男"/>
     </bean>
</beans>

BeanPostProcessor.java

package com.test.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
 * bean后置處理器
 * @author zss
 *
 */
public class PostProcessor implements BeanPostProcessor{

    @Override
    public Object postProcessBeforeInitialization(Object bean,
            String beanName) throws BeansException {
        System.out.println("后置處理器處理bean=【"+beanName+"】開始");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean,
            String beanName) throws BeansException {
        System.out.println("后置處理器處理bean=【"+beanName+"】完畢!");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return bean;
    }
}

BeanFactoryPostProcessor.java

package com.test.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyValue;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class FactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(
            ConfigurableListableBeanFactory configurableListableBeanFactory)
            throws BeansException {
        System.out.println("******調用了BeanFactoryPostProcessor");
        String[] beanStr = configurableListableBeanFactory
                .getBeanDefinitionNames();
        for (String beanName : beanStr) {
            if ("beanFactoryPostProcessorTest".equals(beanName)) {
                BeanDefinition beanDefinition = configurableListableBeanFactory
                        .getBeanDefinition(beanName);
                MutablePropertyValues m = beanDefinition.getPropertyValues();
                if (m.contains("name")) {
                    m.addPropertyValue("name", "趙四");
                    System.out.println("》》》修改了name屬性初始值了");
                }
            }
        }
    }

}

BeanFactoryPostProcessorTest.java 

package com.test.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class BeanFactoryPostProcessorTest implements InitializingBean,DisposableBean,BeanNameAware,BeanFactoryAware {
    private String name;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public void setBeanFactory(BeanFactory paramBeanFactory)
            throws BeansException {
        System.out.println("》》》調用了BeanFactoryAware的setBeanFactory方法了");
    }

    @Override
    public void setBeanName(String paramString) {
        System.out.println("》》》調用了BeanNameAware的setBeanName方法了");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("》》》調用了DisposableBean的destroy方法了");        
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("》》》調用了Initailization的afterPropertiesSet方法了");
    }

    @Override
    public String toString() {
        return "BeanFactoryPostProcessorTest [name=" + name + ", sex=" + sex
                + "]";
    }
}

Test case:

package com.test.spring;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class T {
    ApplicationContext applicationcontext=null;
    @Before
    public void before() {
        System.out.println("》》》Spring ApplicationContext容器開始初始化了......");
        applicationcontext= new ClassPathXmlApplicationContext(new String[]{"spring-service.xml"});
        System.out.println("》》》Spring ApplicationContext容器初始化完畢了......");
    }
    @Test
    public void  test() {
        //BeanLifecycle beanLifecycle =applicationcontext.getBean("beanLifecycle",BeanLifecycle.class);
        BeanFactoryPostProcessorTest beanFactoryPostProcessorTest=applicationcontext.getBean(BeanFactoryPostProcessorTest.class);
        System.out.println(beanFactoryPostProcessorTest.toString());
    }
}

測試結果：

》》》Spring ApplicationContext容器開始初始化了......
2017-03-20 14:36:10  INFO:ClassPathXmlApplicationContext-Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@17ad352e: startup date [Mon Mar 20 14:36:10 CST 2017]; root of context hierarchy
2017-03-20 14:36:10  INFO:XmlBeanDefinitionReader-Loading XML bean definitions from class path resource [spring-service.xml]
******調用了BeanFactoryPostProcessor
》》》修改了name屬性初始值了
》》》調用了BeanNameAware的setBeanName方法了
》》》調用了BeanFactoryAware的setBeanFactory方法了
后置處理器處理bean=【beanFactoryPostProcessorTest】開始
后置處理器開始調用了
》》》調用了Initailization的afterPropertiesSet方法了
后置處理器處理bean=【beanFactoryPostProcessorTest】完畢!
后置處理器調用結束了
》》》Spring ApplicationContext容器初始化完畢了......
BeanFactoryPostProcessorTest [name=趙四, sex=男]
---------------------------------------------------------------------------------------------------------
從測試結果中可以看到beanFactoryPostProcessorTest定義的name值由"張三"變為"趙四"，同時發現postProcessorBeanFactory方法執行順序先於BeanPostProcessor接口中方法。

***************************************************************************************************************************

   在Spring中內置了一些BeanFactoryPostProcessor實現類：

• org.springframework.beans.factory.config.PropertyPlaceholderConfigurer
• org.springframework.beans.factory.config.PropertyOverrideConfigurer
• org.springframework.beans.factory.config.CustomEditorConfigurer：用來注冊自定義的屬性編輯器

      

    

    備注：下一篇將會介紹PropertyPlaceHoldConfigurer在Spring機制中如何讀取配置文件的信息