本篇文章主要介绍Spring IoC 中的FactoryBean,BeanPostProcessor,BeanFactoryProcessor这几个重要扩展点

未来的你一定会感谢拼命的自己

FactoryBean

属于创建Bean的一种方式，同时也是Spring IoC的一个扩展点，实现FactoryBean可以在初始化Bean方面更加灵活，如果我们有复杂的创建对象逻辑，比如创建动态代理对象。那么FactoryBean你值得拥有。
FactoryBean定义

public interface FactoryBean<T> {
    //实际返回Bean对象,此处我们可以实现动态代理对象
    T getObject() throws Exception;
    //对象类型
    Class<?> getObjectType();
    //是否是单例
    default boolean isSingleton() {
        return true;
    }
}

定义一个自己的FactoryBean

public class PersonFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        Person person = new Person();
        person.setName("create by factory bean "+System.currentTimeMillis());
        return person;
    }

    @Override
    public Class<?> getObjectType() {
        return Person.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

注册自己的FactoryBean

<bean id="personByFactoryBean" class="com.lykos.factory.PersonFactoryBean"></bean>

注意: 在Spring IoC容器预初始化对象过程中，如果没有其它对象依赖personByFactoryBean，此时容器是不会执行FactoryBean.getObject()创建对象的，只会初始化FactoryBean本身。获取实际返回对象使用applicationContext..getBean("personByFactoryBean"),而如果需要获取FactoryBean自身对象，需要加&，如applicationContext.getBean("&personByFactoryBean")

BeanPostProcessor

Spring IoC 后置处理器，初始化Bean之后会调用该接口两个方法，我们一般可以利用此接口来统计,检查甚至改变Bean的实例对象

public interface BeanPostProcessor {
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
       //如果返回null,ioc容器还是会用原来的bean，如果不为null ioc就会注册返回的bean对象
        return bean;
    }
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
       //如果返回null,ioc容器还是会用原来的bean，如果不为null ioc就会注册返回的bean对象
        return bean;
    }
}

postProcessBeforeInitialization执行在调用InitializingBean.afterPropertiesSet,bean.initMethod之前而postProcessAfterInitialization执行在之后。

BeanPostProcessor

当然我们也可以注册多个BeanPostProcessor实例,当我们自己实现BeanPostProcessor接口时，建议还实现Ordered接口支持排序，如果未实现Ordered接口的对象将会添加到集合最后，也就是说会最后执行。

BeanFactoryProcessor

BeanFactoryProcessor 是在初始化Bean之前执行其定义的接口，实现此接口后可以对Bean配置元数据进行操作。

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

同样我们也可以注册多个BeanFactoryPostProcessor实例,当我们自己实现BeanFactoryPostProcessor接口时，建议还实现Ordered接口支持排序，如果未实现Ordered接口的对象将会添加到集合最后，也就是说会最后执行。
接下来我们来利用BeanFactoryProcessor来实现可以动态注入代理bean的功能。
定义一个我们需要代理的接口

public interface ITransportation {
    void transport();
}

创建一个代理类并实现FactoryBean

@Data
public class CustomerFactoryBean implements FactoryBean {
    private Class interfaceClass;
    @Override
    public Object getObject() throws Exception {
        return Proxy.newProxyInstance(CustomerFactoryBean.class.getClassLoader(),new Class[]{interfaceClass},
                (object,method,args)->{
                    System.out.println("this is "+interfaceClass.getName()+"."+method.getName() + "() proxy method");
            return null;
        });
    }
    @Override
    public Class<?> getObjectType() {
        return interfaceClass;
    }
}

在创建一个自定义的BeanFactoryProcessor使他可以帮我注册代理bean

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)beanFactory;
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(ITransportation.class);
        GenericBeanDefinition genericBeanDefinition = (GenericBeanDefinition)beanDefinitionBuilder.getRawBeanDefinition();
        genericBeanDefinition.getPropertyValues().addPropertyValue("interfaceClass",ITransportation.class);
        genericBeanDefinition.setBeanClass(CustomerFactoryBean.class);
        defaultListableBeanFactory.registerBeanDefinition("transportationImpl",genericBeanDefinition);
        System.out.println("postProcessBeanFactory init");
    }
}

最后将MyBeanFactoryPostProcessor注册到容器中

<bean id="myBeanFactoryPostProcessor" class="com.lykos.ioc.chapter3.MyBeanFactoryPostProcessor"></bean>

这样可以向spring IoC中注册我们为接口ITransportation创建的代理对象。

当然容器还特意对外提供了专为注册BeanDefinition的接口BeanDefinitionRegistryPostProcessor

PropertyPlaceholderConfigurer

PropertyPlaceholderConfigurer是spring 自带的 BeanFactoryProcessor其功能就是可以替换我们定义Bean 元数据时的占位符${xxx}，适用于ParentName,BeanClassName,FactoryBeanName,FactoryMethodName,Scope,Properties,ConstructorArgument

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <!-- 指定配置文件地址-->
        <property name="locations">
            <value>classpath:property/capter3.yml</value>
        </property>
<!--        0 从不判断system属性-->
<!--        1 如果提供的属性没有，取system属性-->
<!--        2 优先取system属性，如果没有则取提供的属性-->
        <property name="systemPropertiesMode" value="2"></property>
    </bean>

从Spring 3.1开始,推荐使用PropertySourcesPlaceholderConfigurer替代PropertyPlaceholderConfigurer,前者可针对当前的Spring Environment及其PropertySources来做解析

    <bean class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
        <!-- 指定配置文件地址-->
        <property name="locations">
            <value>classpath:property/chapter3.properties</value>
        </property>
        <!--本地配置优先，默认是false-->
        <property name="localOverride" value="true"></property>
    </bean>

PropertyOverrideConfigurer

spring ioc替换属性值的另一种实现方式，与PropertyPlaceholderConfigurer不同的是PropertyPlaceholderConfigurer是遍历BeanDefinition集合替换占位符属性值,而PropertyOverrideConfigurer是遍历配置文件属性值去匹配并替换Bean中定义的属性值。
使用PropertyOverrideConfigurer时需要注意第一个.之前的是bean名称，如果未定义会抛NoSuchBeanDefinitionException异常

感谢

感谢各位老铁花时间观看!
欢迎留言指正！
内容持续更新！