面试题——spring后置处理器

一：Bean工厂后置处理器

1. BeanFactoryPostProcessor：是对BeanDefinition对象进行修改，补充了一些 bean 定义，在BeanDefinitionMap填充完毕，Bean实例化之前执行；

2. BeanDefinitionRegistryPostProcessor BeanFactoryPostProcessor 的子接口，bean定义注册处理器
   先调用postProcessBeanDefinitionRegistry()，再调用postProcessBeanFactory()

    @Component
    public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
            BeanDefinition beanDefinition =  new RootBeanDefinition();
            beanDefinition.setBeanClassName("com.it.service.impl.UserServiceImpl");
            beanDefinitionRegistry.registerBeanDefinition("userService",beanDefinition);
        }
   
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
   
         }
    }
   

二：替换Spring容器中已经存在的Bean

需求：使用我们自己定义的 BananaProductService替换掉框架自带的AppleProductService并加入到Spring容器中，同时保证全局只有一个ProductService的实现。
思路：我们在系统中根据 @Bean或通过 @Component 定义的Bean对象在Spring中都会转换成一个个的BeanDefinition对象，如果我们在Spring创建这些对象加入到Spring容器之前，将不想要的BeanDefinition对象删除，而加入我们自己想要的BeanDefinition对象是不是就可以实现了？而Spring提供的BeanDefinitionRegistryPostProcessor接口正好可以帮助我们实现这个功能。
BeanDefinitionRegistryPostProcessor 是在系统加载完所有的BeanDefinition对象来进行回调
实现：替换掉jar包默认的实现

三：Spring 如何让你的 bean 在其他 bean 之前加载

Bean初始化有两个时机，从以下两个出发点来思考解决问题方案的话，大概有如下几种方式

1. Spring容器主动去初始化该Bean

2. 其他Bean依赖该Bean，该Bean会先被初始化
   直接依赖某Bean：
   在加载Bean A的时候，一定会先初始化Bean B
   
   DependsOn注解：
   对于应用之外的二方或者三方库来说，因为我们不能修改外部库的代码，如果想要二方库的Bean在初始化之前就初始化我们内部的某个bean，就不能用第一种直接依赖的方式，可以使用@Dependson 注解来完成，如下代码所示：
   
   BeanFactoryPostProcessor：
   前两种方式只能对于特定的Bean生效，如果我们希望某个Bean在其他所有Bean加载之前就初始化，用前面两种方式显然是不合适的，我们这个时候，就需要从Spring容器的生命周期中去找方法。Spring的Bean在初始化之前，会通过BeanFactoryPostprocessor#postProcessBeanFactory 对工厂进行处理，我们可以依赖这个特性，在此刻提前初始化我们需要的bean

    @Component
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
   
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 注册
        BeanDefinition definition = new RootBeanDefinition();
        definition.setBeanClassName("com.blueStarWei.ObjectBeanFactory");
        //必须强制转换为DefaultListableBeanFactory才能注册\删除
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
        defaultListableBeanFactory.registerBeanDefinition("myBeanFactory",definition);
   
        //删除
        defaultListableBeanFactory.removeBeanDefinition("user");
   
        //修改
        BeanDefinition person = beanFactory.getBeanDefinition("person");
        person.setScope(BeanDefinition.SCOPE_PROTOTYPE);
     }
    }
   

四：bean后置处理器

1. BeanPostProcessor：在Bean对象实例化和依赖注入完毕后，在bean初始化之前和之后对bean对象进行修改

    public class UserDao implements InitializingBean {
   
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public UserDao() {
            System.out.println("userDao对象创建");
        }
    
        public void init(){
            System.out.println("init初始化方法执行");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("属性设置之后执行....");
        }
    }
   

MyBeanPostProcessor后置处理器

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName+": postProcessBeforeInitialization");
        return bean;
    }

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    System.out.println(beanName + ": postProcessAfterInitialization");
    return bean;
    }
}

执行结果