spring BeanDefinition与bean在创建过程中的扩展

扩展测试

神级文章bean的扩展

自测代码

package com.zf.springlearn.lifecycle;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.*;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Component;
import org.springframework.util.StringValueResolver;

import javax.annotation.PostConstruct;
@Component
public class OneBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware
        , EmbeddedValueResolverAware, ResourceLoaderAware, ApplicationEventPublisherAware, MessageSourceAware
        , ApplicationContextAware, InitializingBean {
    private static final Logger LOGGER = LoggerFactory.getLogger(OneBean.class);
    private static final String beanName = "oneBean";
    public static int order = 0;

    private String desc;

    public void setDesc(String h) {
        this.desc = h;
    }

    public OneBean() {
        LOGGER.info(order + "--Constructor::instantiating...");
        order++;
    }

    @PostConstruct
    public void init() {
        LOGGER.info(order + "--@PostConstruct");
        order++;
    }

    @Override
    public void setBeanName(String name) {
        LOGGER.info(order + "--BeanNameAware::setBeanName");
        order++;
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        LOGGER.info(order + "--BeanClassLoaderAware::setBeanClassLoader");
        order++;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        LOGGER.info(order + "--BeanFactoryAware::setBeanFactory");
        order++;
    }

    @Override
    public void setEnvironment(Environment environment) {
        LOGGER.info(order + "--EnvironmentAware::setEnvironment");
        order++;
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        LOGGER.info(order + "--EmbeddedValueResolverAware::setEmbeddedValueResolver");
        order++;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        LOGGER.info(order + "--ResourceLoaderAware::setResourceLoader");
        order++;
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        LOGGER.info(order + "--ApplicationEventPublisherAware::setApplicationEventPublisher");
        order++;
    }

    @Override
    public void setMessageSource(MessageSource messageSource) {
        LOGGER.info(order + "--MessageSourceAware::setMessageSource");
        order++;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        LOGGER.info(order + "--ApplicationContextAware::setApplicationContext");
        order++;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        LOGGER.info(order + "--InitializingBean::afterPropertiesSet");
        order++;
    }

    @Component
    public static class TestProcessor implements InstantiationAwareBeanPostProcessor {
        @Override
        public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
            if (beanName.equals(OneBean.beanName)) {
                LOGGER.info(order + "--InstantiationAwareBeanPostProcessor::postProcessBeforeInstantiation");
                order++;
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInstantiation(beanClass, beanName);
        }

        @Override
        public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
            if (beanName.equals(OneBean.beanName)) {
                LOGGER.info(order + "--InstantiationAwareBeanPostProcessor::postProcessAfterInstantiation");
                order++;
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessAfterInstantiation(bean, beanName);
        }

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if (beanName.equals(OneBean.beanName)) {
                LOGGER.info(order + "--BeanPostProcessor::postProcessBeforeInitialization");
                order++;
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
        }

        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if (beanName.equals(OneBean.beanName)) {
                LOGGER.info(order + "--BeanPostProcessor::postProcessAfterInitialization");
                order++;
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
        }

        @Override
        public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
            if (beanName.equals(OneBean.beanName)) {
                LOGGER.info(order + "--InstantiationAwareBeanPostProcessor::populating...");
                order++;
            }
            return InstantiationAwareBeanPostProcessor.super.postProcessProperties(pvs, bean, beanName);
        }
    }

    @Component
    public static class DefinitionProcessor implements BeanFactoryPostProcessor {
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            if (registry.containsBeanDefinition(OneBean.beanName)) {
                LOGGER.info(order + "--BeanFactoryPostProcessor::postProcessBeanFactory");
                order++;
                BeanDefinition beanDefinition = registry.getBeanDefinition(OneBean.beanName);
                beanDefinition.getPropertyValues().addPropertyValue("desc", "hello...");
            }
        }
    }
}

测试结果 测试代码实现接口来自BeanFactory提示

阶段归纳

根据文章中讲述，bean创建的三大阶段：实例化(instantiateBean)、赋值(populateBean)、初始化(initializeBean)

Spring bean创建时遇到几个BeanPostProcessor