亲宝软件园·资讯

展开

Spring BeanPostProcessor源码示例解析

陈汤姆 人气:0

正文

BeanPostProcessor对于Spring开发者来说一定不陌生,平时开发过程中如果涉及对中间件做增强处理或者需要对某个实际Bean做初始化前的处理,一般都可以使用该接口来实现。

对于自己来说自己在对接RocketMQ、RabbitMQ过程中需要实现一个快速接入SpringBoot的中间插件,最快速的就是实现该接口对中间件中的Bean做增强处理,能够快速接入SpringBoot。

1. BeanPostProcessor介绍

BeanPostProcessor是一个接口,该接口提供给开发者使用,开发者可以实现该接口,然后在实现类中对想要处理的类做增强处理。

该接口中提供了两个基础方法:

public interface BeanPostProcessor {
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

下面举一个最简单的例子来看一下BeanPostProcessor的使用。

2. BeanPostProcessor的使用

@Service
public class UserService {
    private String name = "陈tom";
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
@Component
public class MyPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            UserService userService = (UserService) bean;
            userService.setName("陈汤姆");
            userService.setAge(21);
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}
@SpringBootApplication
public class BootApplication {
    @Resource
    private DefaultListableBeanFactory defaultListableBeanFactory;
    public static void main(String[] args) {
        SpringApplication.run(BootApplication.class,args);
    }
    @PostConstruct
    public void init() {
        UserService userService = defaultListableBeanFactory.getBean("userService", UserService.class);
        System.out.println("测试结果:姓名:"+userService.getName()+";年龄:"+userService.getAge());
    }
}

以上的实现中做了最简单的实现,通过MyPostProcessor实现BeanPostProcessor接口,然后在前置增强处理中加入对Bean的修改。

然后通过PostConstruct在Bean初始化后做Bean的查询,得到通过BeanPostProcessor操作的结果。

所以BeanPostProcessor在使用上来说很简单,对于开发者来说它很方便的提供了对于Bean对象的修改操作,提高了Spring的扩展性和灵活性。

3. BeanPostProcessor的作用

说完了最基础的BeanPostProcessor的使用,通过以上的实现来梳理下BeanPostProcessor的作用。

自己对于BeanPostProcessor最大的感受就是太灵活了,开发者只要实现该接口,然后重写其中的方法就可以实现自己的逻辑。这样也保证了Spring容器对于开发者来说并不是一个黑盒,开发者可以通过Spring提供的钥匙让Spring容器暴露在开发者眼中,想要做什么处理都可以根据提供的钥匙实现。(这里其实还有一个配套的BeanFactoryPostProcessor,面试的时候也经常被问到BeanPostProcessor和BeanFactoryPostProcessor的区别,有兴趣的可以自己了解下,区别只是最终服务的对象不一样)

这里不得不说Spring YYDS!!!

4. BeanPostProcessor注册

Q:既然开发者通过自己的实现类实现了BeanPostProcessor,那么Spring又是如何将开发者做的实现类加入到Spring中并且执行开发者重写的前置和后置增强逻辑呢?

这里就要提到Spring对于BeanPostProcessor的设计,在Spring中初始化了一个CopyOnWriteArrayList作为存储所有实现BeanPostProcessor的列表。

从实现上可以看到该列表是一个写复制的列表,通俗点讲就是向该列表中添加元素时,不直接往当前容器添加,而是先将当前容器进行Copy,复制出一个新的容器,然后新的容器里添加元素,添加完元素之后,再将原容器的引用指向新的容器。这里不展开说只要知道就是一个列表就可以。

Spring向该容器中添加的逻辑源码如下:

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
	//存储BeanPostProcessor列表
	private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
	@Override
	public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
		Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
		// Remove from old position, if any
		this.beanPostProcessors.remove(beanPostProcessor);
		// Track whether it is instantiation/destruction aware
		if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
			this.hasInstantiationAwareBeanPostProcessors = true;
		}
		if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
			this.hasDestructionAwareBeanPostProcessors = true;
		}
		// 将BeanPostProcessor加入beanPostProcessors列表中
		this.beanPostProcessors.add(beanPostProcessor);
	}
}

这里展示的只是最终写入的逻辑,那么从源头到写入BeanPostProcessor的逻辑是怎么样呢?

以ClassPatchXmlApplicationContext为例:

时序图如下:

5. BeanPostProcessor调用

说完如何注册BeanPostProcessor,最后来说如何将注册到beanPostProcessors的实现类进行调用。

前一篇聊Spring容器时也提到了Spring在初始化Bean时会执行BeanPostProcessor的增强处理,具体的调用源码如下:

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	//初始化Bean
	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			//调用BeanPostProcesso#postProcessBeforeInitialization:前置处理
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		try {
			//执行初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			//调用调用BeanPostProcesso#postProcessAfterInitialization:后置处理
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}
	//BeanPostProcessor前置逻辑处理
	@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {
		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			//执行实现BeanPostProcessor的实现类的前置增强逻辑
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
	//BeanPostProcessor后置逻辑处理
	@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {
		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			//执行实现BeanPostProcessor的实现类的后置增强逻辑
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
}

从以上源码中可以看到在初始化Bean时调用前置和后置增强,并且这里也做了明确的边界,前置增强处理一定是在invokeInitMethods之前,后置增强一定是在invokeInitMethods之后。这样就保证了BeanPostProcessor的执行顺序,也可以让开发者在使用过程中只要掌握Bean的生命周期,那么就可以自主的对Bean进行增强处理。

6. 总结

以上是对Spring中BeanPostProcessor的源码梳理,对BeanPostProcessor的介绍到使用、作用、注册实现和调用实现,完成了对BeanPostProcessor的源码分析。

对于文中提到的BeanFactoryPostProcessor有兴趣的可以从源码按照这个过程梳理一下,其实跟BeanPostProcessor作用是相同的。

加载全部内容

相关教程
猜你喜欢
用户评论