spring--bean后置处理器（BeanPostProcessor）原理解析

最新推荐文章于 2024-06-05 23:45:00 发布
最新推荐文章于 2024-06-05 23:45:00 发布
阅读量1.6k 收藏 13
点赞数
分类专栏： # spring源码 文章标签： spring 后置处理器 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25215821/article/details/106480780
版权

文章目录

功能描述：

  • 实现BeanPostProcessor接口允许我们可以对所有bean在创建之前和之后做一些自己的处理

  • BeanPostProcessor 接口定义：

    public interface BeanPostProcessor {

	/**
	* 前置处理，实例化bean之前对bean进行处理
	*/
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	/**
	* 后置处理，实例化bean之后对bean进行处理
	*/
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

如何使用：

  1. 定义要处理的接口类型

    public interface TestBeanPostProcessorInterface {

    String getPassword();

    void setPassword(String password);
}

  2. 添加实际需要处理的类

    import org.springframework.stereotype.Component;

@Component
public class UserInfoVO implements TestBeanPostProcessorInterface {

    private String password = "password";

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public void setPassword(String password) {
        this.password = password;
    }
}

  3. 定义后置处理器

    import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class BeanPostProcessorConfig implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    	// 这是判断只对我们感兴趣的接口做处理
        if (bean instanceof TestBeanPostProcessorInterface) {
        	// 打印处理前password的值
            String password = ((TestBeanPostProcessorInterface) bean).getPassword();
            System.out.println(String.format("handler beanName: %s, password: %s", beanName, password));
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    	// 这是判断只对我们感兴趣的接口做处理
        if (bean instanceof TestBeanPostProcessorInterface) {
        	// 重新设置password的值
            ((TestBeanPostProcessorInterface) bean).setPassword("********");
        }
        return bean;
    }
}

  4. 编写测试类

    import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class BeanPostProcessorTest {

    @Autowired
    private UserInfoVO userInfoVO;

    @Test
    public void test() {
        System.out.println(userInfoVO.getPassword());
    }
}

  5. 执行日志

    我们看到 userInfoVO类的password 参数被替换成了********

      .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.2.0.RELEASE)

2020-06-01 13:43:24.952  INFO 11432 --- [           main] c.e.d.c.spring.BeanPostProcessorTest     : Starting BeanPostProcessorTest on PC with PID 11432 (started by ASUS in E:\workspace\demo)
2020-06-01 13:43:24.954  INFO 11432 --- [           main] c.e.d.c.spring.BeanPostProcessorTest     : No active profile set, falling back to default profiles: default
2020-06-01 13:43:25.708  INFO 11432 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Multiple Spring Data modules found, entering strict repository configuration mode!
2020-06-01 13:43:25.711  INFO 11432 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Bootstrapping Spring Data repositories in DEFAULT mode.
2020-06-01 13:43:25.783  INFO 11432 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Finished Spring Data repository scanning in 46ms. Found 0 repository interfaces.
handler beanName : userInfoVO, password : password
2020-06-01 13:43:27.063  INFO 11432 --- [           main] c.e.d.c.spring.BeanPostProcessorTest     : Started BeanPostProcessorTest in 2.857 seconds (JVM running for 4.225)

********



Process finished with exit code 0

后置处理器加载解析

  • 这个是在创建applicationContext过程中，从抽象类AbstractApplicationContext的refresh方法开始，去除注释和日志，我们来看看源码
    @Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			
			prepareRefresh();
			
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			
			prepareBeanFactory(beanFactory);

			try {
				postProcessBeanFactory(beanFactory);
				
				invokeBeanFactoryPostProcessors(beanFactory);
				// 注册后置处理器
				registerBeanPostProcessors(beanFactory);
				
				initMessageSource();
				
				initApplicationEventMulticaster();
				
				onRefresh();
				
				registerListeners();
				
				finishBeanFactoryInitialization(beanFactory);
		
				finishRefresh();
			} catch (BeansException ex) {
				
				destroyBeans();
				
				cancelRefresh(ex);
				
				throw ex;
			} finally {
				resetCommonCaches();
			}
		}
	}

    这里我们只关心registerBeanPostProcessors方法

registerBeanPostProcessors注册拦截bean创建的后置处理器

  • 源码

    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	// 获取所有实现了BeanPostProcessor接口的beanName
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// 计算一个bean最终应该会被实现了BeanPostProcessor接口处理的数量
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	// 添加一个后置处理器，放在后面说明
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// 保存实现了优先排序接口（PriorityOrdered）的类
	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	// 保存实现了MergedBeanDefinitionPostProcessor接口的类，可以理解为spring内部类
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	// 保存实现了排序接口（Ordered）的类
	List<String> orderedPostProcessorNames = new ArrayList<>();
	// 保存未实现任何排序接口的类
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();

	for (String ppName : postProcessorNames) {
		// 判断是否实现了PriorityOrdered接口
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			// 获取并实例化bean
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			// 可以理解为判断是否spring框架内部使用的实现类
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		// 判断是否实现了Ordered接口
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		// 未实现排序接口的保存到nonOrderedPostProcessorNames集合
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// 进行排序后优先注册
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// 处理实现了Ordered排序接口的BeanPostProcessors实现类
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		orderedPostProcessors.add(pp);
		// 可以理解为判断是否框架内部使用的实现类
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	// 进行排序后优先注册
	sortPostProcessors(orderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

	// 处理无排序的BeanPostProcessors实现类
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		// 可以理解为判断是否spring框架内部使用的实现类
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	// 无排序直接注册
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	// 对内部类的排序
	sortPostProcessors(internalPostProcessors, beanFactory);
	// 重新注册内部类，作用是将内部类的注册放到最后
	registerBeanPostProcessors(beanFactory, internalPostProcessors);

	// 添加一个后置处理器，放在后面说明
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

    注册过程还是比较简单的，我们看到，在注册过程中还创建了两个后置处理器BeanPostProcessorChecker和ApplicationListenerDetector，这个在后面分析作用
    后置处理器的注册已经完成了，接下来我们看一下他的调用过程

后置处理器的调用

  1. bean实例化前、后的处理调用过程

    跳过bean实例化过程，直接看一下初始化bean

    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	// 判断是否启用了java安全管理器，正常情况下是null的，除非手动设置打开安全管理器
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		// 进行BeanNameAware、BeanClassLoaderAware和BeanFactoryAware感知注入
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	// 判断是否合成bean，默认 synthetic = false，则!mbd.isSynthetic() = true
	if (mbd == null || !mbd.isSynthetic()) {
		// 调用前置处理器
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// 如果实现了InitializingBean接口，则调用afterPropertiesSet方法
		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()) {
		// 调用后置处理器
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

    @Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {

	Object result = existingBean;
	// 遍历处理器
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		// 执行前置处理器
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
		throws BeansException {

	Object result = existingBean;
	// 遍历处理器
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		// 执行后置处理器
		Object current = processor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

举例谈谈spring内部实现了BeanPostProcessor接口的类

  1. BeanPostProcessorChecker用于检查是否存在不会被所有后置处理器处理的bean

    什么情况下会出现这个问题呢,首先我们要知道两件事情,然后看一下注册流程图
    1、单例bean只会实例化一次
    2、bean实例化的前后都会被后置处理器处理
    流程图：在这里插入图片描述
    综上我们可以看到在实例化后置处理器时会去实例化他的依赖bean，实例化依赖bean时又会执行后置处理器，但是此时的后置处理器并没有全部注册完成，所以这个依赖bean不会被还没实例化的后置处理器处理到

    我们看看spring是怎么实现BeanPostProcessorChecker的

    private static final class BeanPostProcessorChecker implements BeanPostProcessor {

	private static final Log logger = LogFactory.getLog(BeanPostProcessorChecker.class);

	private final ConfigurableListableBeanFactory beanFactory;

	private final int beanPostProcessorTargetCount;

	public BeanPostProcessorChecker(ConfigurableListableBeanFactory beanFactory, int beanPostProcessorTargetCount) {
		this.beanFactory = beanFactory;
		this.beanPostProcessorTargetCount = beanPostProcessorTargetCount;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) {
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		// 1、bean不是后置处理器，2、不是内部bean，3、此时注册的后置处理器小于计算的总后置处理器
		if (!(bean instanceof BeanPostProcessor) && !isInfrastructureBean(beanName) && this.beanFactory.getBeanPostProcessorCount() < this.beanPostProcessorTargetCount) {
			// 打印日志
			if (logger.isInfoEnabled()) {
				logger.info("Bean '" + beanName + "' of type [" + bean.getClass().getName() +
						"] is not eligible for getting processed by all BeanPostProcessors " +
						"(for example: not eligible for auto-proxying)");
			}
		}
		return bean;
	}

	private boolean isInfrastructureBean(@Nullable String beanName) {
		if (beanName != null && this.beanFactory.containsBeanDefinition(beanName)) {
			BeanDefinition bd = this.beanFactory.getBeanDefinition(beanName);
			// RootBeanDefinition.ROLE_INFRASTRUCTURE = 2，标记为完全内部使用的bean
			return (bd.getRole() == RootBeanDefinition.ROLE_INFRASTRUCTURE);
		}
		return false;
	}
}

    如果存在这种情况则会打印一行日志
    logger.info(“Bean '” + beanName + “’ of type [” + bean.getClass().getName() +
    "] is not eligible for getting processed by all BeanPostProcessors " +
    “(for example: not eligible for auto-proxying)”);

  2. ApplicationListenerDetector用于管理监听器

    ApplicationListenerDetector主要做两件事
    1、bean实例化时如果这个bean是监听器且是单例模式的则在广播中注册这个监听器
    2、bean销毁时判断如果是监听器则在广播中移除这个监听器

  • 附上源码

    class ApplicationListenerDetector implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {

	private static final Log logger = LogFactory.getLog(ApplicationListenerDetector.class);

	private final transient AbstractApplicationContext applicationContext;

	private final transient Map<String, Boolean> singletonNames = new ConcurrentHashMap<>(256);

	public ApplicationListenerDetector(AbstractApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
	}

	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		this.singletonNames.put(beanName, beanDefinition.isSingleton());
	}
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) {
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (bean instanceof ApplicationListener) {
			// potentially not detected as a listener by getBeanNamesForType retrieval
			Boolean flag = this.singletonNames.get(beanName);
			if (Boolean.TRUE.equals(flag)) {
				// singleton bean (top-level or inner): register on the fly
				this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
			}
			else if (Boolean.FALSE.equals(flag)) {
				if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
					// inner bean with other scope - can't reliably process events
					logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
							"but is not reachable for event multicasting by its containing ApplicationContext " +
							"because it does not have singleton scope. Only top-level listener beans are allowed " +
							"to be of non-singleton scope.");
				}
				this.singletonNames.remove(beanName);
			}
		}
		return bean;
	}

	@Override
	public void postProcessBeforeDestruction(Object bean, String beanName) {
		if (bean instanceof ApplicationListener) {
			try {
				ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
				multicaster.removeApplicationListener((ApplicationListener<?>) bean);
				multicaster.removeApplicationListenerBean(beanName);
			}
			catch (IllegalStateException ex) {
				// ApplicationEventMulticaster not initialized yet - no need to remove a listener
			}
		}
	}

	@Override
	public boolean requiresDestruction(Object bean) {
		return (bean instanceof ApplicationListener);
	}


	@Override
	public boolean equals(@Nullable Object other) {
		return (this == other || (other instanceof ApplicationListenerDetector &&
				this.applicationContext == ((ApplicationListenerDetector) other).applicationContext));
	}

	@Override
	public int hashCode() {
		return ObjectUtils.nullSafeHashCode(this.applicationContext);
	}
}

  • 注意在移除监听器时会清空整个监听器缓存

    @Override
public void removeApplicationListener(ApplicationListener<?> listener) {
	synchronized (this.retrievalMutex) {
		this.defaultRetriever.applicationListeners.remove(listener);
		// 清空监听器缓存
		this.retrieverCache.clear();
	}
}

@Override
public void removeApplicationListenerBean(String listenerBeanName) {
	synchronized (this.retrievalMutex) {
		this.defaultRetriever.applicationListenerBeans.remove(listenerBeanName);
		// 清空监听器缓存
		this.retrieverCache.clear();
	}
}

  1. ApplicationContextAwareProcessor用于实现感知

    该后置处理器会对实现了EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware接口的bean注入对应的实例

  • 源码很简单
    class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;

	private final StringValueResolver embeddedValueResolver;


	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}


	@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// 判断这个bean是否实现了这些接口
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}
	
	// 注入响应的实例
	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

}

  1. AutowiredAnnotationBeanPostProcessor 增加对Autowired注解的支持

  2. CommonAnnotationBeanPostProcessor 负责解析@Resource、@WebServiceRef、@EJB注解

  3. ConfigurationClassPostProcessor 负责解析@Configuration、@PropertySource、@ComponentScan、@Import、@ImportResource、@Bean注解

  4. 还有很多。。。

总结

  1. 可实现PriorityOrdered或Ordered接口定义后置处理器执行顺序
  2. 后置处理器A存在依赖bean的情况下，这个bean将无法被A及优先级低于A的处理器处理
  3. @Bean、@ComponentScan、@Import、@Resource等实用注解是通过后置处理器处理的
  4. bean初始化时先进行BeanNameAware、BeanClassLoaderAware和BeanFactoryAware感知注入，再执行前置处理，然后对实现了InitializingBean接口的方法afterPropertiesSet进行初始化，最后执行后置处理
工与绩不过兴与兴
关注
  • 0
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
BeanPostProcessor后置处理器原理与应用
ChirsPaul3的博客
02-01 1379
BeanPostProcessor后置处理器原理与应用 BeanPostProcessor又叫后置处理器，是spring框架极其重要的概念。本身是个接口，接口里面定义了两个方法。许多扩展功能都是基于这种后置处理器的方式来实现的。spring框架会自动识别所有实现BeanPostProcessor接口的实现类，加载到容器中。当容器实例化完具体的一个bean后，会遍历所有实现接口的类，执行接口的实现方法，对刚刚实例化的bean进行初始化操作。 这只是最简单的应用，BeanPostProcessor还有几个子接口
spring扩展点二：自定义beanPostProcessor原理解析
小小少年的博客
03-22 1761
beanPostProcessor是我在学习spring源码中，目前看到扩展最多的一个接口，比如:aop、spring事务、初始化方法回调，都是对该接口的扩展和实现，除了spring本身的框架，比如dubbo的ReferenceAnnotationBeanPostProcessor，这个扩展类就是一个后置处理器，用来解析@Reference注解的 bean后置处理器呢，spring在初始化bean的流程中，已经定义好了先执行后置处理器的哪个方法，后执行哪个方法，所以，我们在扩展的时候，要熟知这些方法执行位置
全面理解BeanPostProcessor和BeanFactoryPostProcessor：原理、实现与实战
最新发布
学而时习之，不亦说乎？温故而知新，可以为师矣！
06-05 1368
Spring框架中的BeanPostProcessor和BeanFactoryPostProcessor是两种重要的后置处理器，用于在Bean初始化前后和Bean定义加载后执行自定义逻辑。本文将深入解析这两种处理器的源码，详细介绍它们的作用、实现原理和应用场景。我们将通过具体的示例代码，展示如何使用BeanPostProcessor和BeanFactoryPostProcessor进行Bean的自定义处理和扩展。
精华推荐 |【深入浅出Spring原理及实战】「原理分析专题」从源码和架构设计角度深入剖析BeanPostProcessor的原理和运作机制
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
12-09 4869
Spring中BeanPostProcessor的子接口或实现类有很多种，例如。、、DestructionAwareBeanPostProcessor等等。这些接口分别处在Spring Bean生命周期的不同阶段，而他们的功能与BeanPostProcessor都类似，都是为了给Spring Bean各个声明周期提供扩展点。
spring中BeanProcessor接口解析
baidu_38304104的博客
06-20 2347
1. 简单认识BeanProcessor BeanProcessor的理解 BeanProcessor是spring中的一个重要接口，他有两个接口方法一个是postProcessBeforeInitialization前置初始化，另一个是postProcessAfterInitialization后置初始化。从名称上就可以大概清楚这个接口的作用：在一个业务流程的前后加入两个接口方法，当执行这个业务流程时，就会触发这两个接口方法的执行。简单的总结一下有两个要点： 在业务流程中，根据BeanProcess
BeanPostProcessor原理分析
及时当勉励，岁月不待人
03-22 533
BeanPostProcessor原理分析
Spring后置处理器（BeanPostProcessor）
洛卡JAVA架构师每日分享Java架构师知识
05-18 714
本节主要介绍在《[Spring Bean生命周期]》一节提到的 BeanPostProcessor 接口。BeanPostProcessor 接口也被称为后置处理器，通过该接口可以自定义调用初始化前后执行的操作方法。 BeanPostProcessor 接口源码如下： 1. public interface BeanPostProcessor { 2. Object postProcessBeforeInitialization(Object bean, String beanNam
spring注解---BeanPostProcessor后置处理器
lsh15846393847的博客
11-13 279
.BeanPostProcessor ：bean的后置处理器。 postProcessBeforeInitialization：bean实例被创建之后，初始化方法执行之前被执行 postProcessAfterInitialization：初始化方法执行之后被执行 参数：Object bean：当前实例化的bean ...
Spring中的后置处理器BeanPostProcessor详解
08-25
Spring中的后置处理器BeanPostProcessor详解 在 Spring 框架中，BeanPostProcessor 是一个非常重要的组件，它提供了一种方式来在bean实例化、配置和初始化方法前后添加自定义逻辑处理。下面我们将详细介绍 ...
Bean的后置处理器MergedBeanDefinitionPostProcessor.docx
07-04
在Spring框架中，Bean的生命周期管理是其核心功能之一，其中Bean后置处理器（BeanPostProcessor，BPP）扮演着重要角色。MergedBeanDefinitionPostProcessor是特定类型的BPP，它在Bean实例创建并初始化其定义之后但在...
spring中bean的生命周期详解
08-26
Bean后置处理器需要实现接口：org.springframework.beans.factory.config.BeanPostProcessor。在初始化方法被调用前后，Spring将把每个Bean实例分别传递给上述接口的以下两个方法：postProcessBeforeInitialization...
spring BeanPostProcessor 生命周期
12-22
BeanPostProcessor：后置处理器 spring使用模板模式，在bean的创建过程中安插了许多锚点，用户寻找对应的锚点，通过重写方法介入到bean的创建过程当中。本节通过重写这些锚点，学习如何使用BeanPostProcessor、获取...
Java-spring框架面试题
07-25
7. 执行了bean的后置处理器BeanPostProcessor 8. 销毁bean 循环依赖 循环依赖其实就是循环引用，也就是两个或两个以上的bean互相持有对方，形成闭环。Spring框架依据三级缓存已经解决了大部分的循环依赖。三级缓存...
BeanPostProcessor由浅入深
热门推荐
qq_46127735的博客
12-11 1万+
BeanPostProcessor由浅入深： 1、BeanPostProcessor原理： 该接口我们也叫后置处理器，作用是在Bean对象在实例化和依赖注入完毕后，在显示调用初始化方法的前后添加我们自己的逻辑。注意是Bean实例化完毕后及依赖注入完成后触发的。流程图如下（如何使用这里就不附上代码，相信大家已经了解） 首先-初始化bean—>检查容器中是否存在BeanPostProcessor，如果存在就调用postProcessBeforeInitialization方法—>如果返回nu
Spring BeanPostProcessor理解和使用原理分析
白鸽
08-08 294
基础 如果使用过Spring,写过项目，那么一定了解IOC容器，Bean校验，@Autowired依赖注入这些，其实内部很多实现，都是通过BeanPostProcessor来实现 BeanPostProcessor 作用： 初始化Bean前后做一些赋值，解析处理相关操作 BeanPostProcessor接口 public interface BeanPostProcessor { /** * @param bean the new bean instance * @param beanName
Spring注解式开发（三）:BeanPostProcessor的工作原理
wmq930626的博客
01-06 805
BeanPostProcessor的工作原理 本次通过debug的方式追踪BeanPostProcessor的工作原理 容器启动时的方法调用栈 首先进入 AnnotationConfigApplicationContext方法，也就是创建容器的方法，通过方法的注释可知道该方法是使用给定的配置类创建一个新的AnnotationConfigApplicationContext，并自动刷新上下文 /*...
spring生命周期-BeanPostProcessor使用与原理浅析
sinat_17618381的博客
08-18 231
额外
Spring系列（八）：Spring生命周期中BeanPostProcessor接口用法介绍
IT技术分享社区
03-19 1384
今天给大家介绍BeanPostProcessor接口用法，希望对大家能有所帮助！
创建自定义BeanPostProcessor和BeanFactoryPostProcessor
weixin_45594127的博客
10-05 518
创建自定义BeanPostProcessor和BeanFactoryPostProcessor
Spring Bean后置处理器 详细
05-11
Spring Bean后置处理器（BeanPostProcessor）是Spring框架中非常重要的一个功能，它允许我们在Bean实例化、依赖注入、初始化等步骤之前或之后，对Bean进行一些自定义操作。 Bean后置处理器是一个接口，它有两个方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值