从源码理解Spring后置处理器

最新推荐文章于 2024-07-23 21:37:49 发布
最新推荐文章于 2024-07-23 21:37:49 发布
阅读量60 收藏
点赞数 1
分类专栏： java源码系列 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Darlight/article/details/132575826
版权

从源码理解Spring后置处理器

什么是Bean的生命周期拓展点

Spring为每个开发者提供了开箱即用的方便属性，更是将对象的创建和管理全都交给了spring容器，对于降低开发难度和代码维护难度有着不小的贡献，但是傻瓜式的使用同时也伴有这一定缺点，比如说如果我想在Bean创建的过程中改变一下这个Bean,该怎么办呢?Bean是spring创建的呀。
Spring当然考虑到这一点（毕竟spring自己也有这个需求○ω○）,它给开发者提供了Bean和Bean Factory创建过程中的多个后置处理器（postProcess）。开发者可以通过这些拓展点干涉Bean的创建，在任意一个Bean的实例化或初始化之前以及实例化或初始化之后去额外的做一些用户自定义的逻辑

有哪些拓展点可以使用

  • BeanFactory的后置处理器

    • BeanFacctoryPostProcessor

      • BeanFactoryPostProcessor为BeanFactory的后置处理器，可以通过实现此接口拿到BeanFactory,拿到BeanFactory就可以做很多事情了,例如获取BeanDefinition,并且修改BeanDefinition的属性
      • 作用在Spring容器初始化的时候,也就是创建Bean之前
      • 自己实现一个例子:
        @Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 // 匹配到自己的这个Bean,拿到BeanDefinition
  BeanDefinition beanDefinition = beanFactory.getBeanDefinition("myService");
  // 给Bean换一个名字
  definition.setBeanClassName("yourService");
 }
}
      • 官方实现类
        • EventListenerMethodProcessor
        • 作用: 用来处理@EventListener注解的
        • 我们来看看它是如何实现接口的方法的:
          	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		this.beanFactory = beanFactory;
		// 从BeanFactory中拿出所有EventListenerFactory类型的FactoryBean
		// 默认会拿出DefaultEventListenerFactory
		Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
		List<EventListenerFactory> factories = new ArrayList<>(beans.values());
		// 获取配置的@Order注解,将所有EventListenerFactory的Bean进行排序
		AnnotationAwareOrderComparator.sort(factories);
		this.eventListenerFactories = factories;
	}

    • BeanDefinitionRegistryPostProcessor

      • 上面的后置处理器只给我们提供了获取BeanDefinition的接口,但是没办法干涉BeanDefinition的注册,所以Spring提供了BeanDefinitionRegistryPostProcessor拓展点，通过实现该拓展点就能实现自定义注册BeanDefinition
      • BeanDefinitionRegistryPostProcessor也是BeanFactoryPostProcessor的子类,也能够修改BeanDefinition
      • 例如：
        @Component
public class ZhouyuBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		//创建一个空的BeanDefinition
		AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
		// 给空的BeanDefinition设置类对象
		beanDefinition.setBeanClass(MyBean.class);
		// 注册BeanDefinition
		registry.registerBeanDefinition("myBean", beanDefinition);
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		// do something
	}
}
      • 官方实现类
        • ConfigurationClassPostProcessor
        • 作用:用于处理@Configuration配置类,并且实现了排序功能
        • 来看看实现的接口方法是怎样的
        	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		// 获取注册id
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);

		// 在这个方法里面解析配置类
		processConfigBeanDefinitions(registry);
	}

    • BeanDefinition的后置处理器

      为了方便大家看清楚脉络,标题只列出了方法名,从方法名称可以很清楚的看到Bean的生命周期

      • postProcessBeforeInstantiation()

        • 接口: InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
        • 作用时期: 顾名思义, Bean在实例化前会调用这个拓展点
        • 示例:
          		@Component
		public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
		
		 @Override
		 public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		  if ("myService".equals(beanName)) {
		   System.out.println("===实例化前===");
		  }
		  return null;
		 }
		}
	```
        实现了这个拓展点那么在实例化 myService这个bean之前就会打印这句话,我们在这里的返回值返回了null,如果没有返回null,那么Spring将直接使用你的返回值而不继续创建bean

    • postProcessMergedBeanDefinition()

      • 接口: MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
      • 作用时期: 创建对象之后,给属性赋值之前
      • 示例:
        @Component
public class MyMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

 @Override
 public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
  if ("myService".equals(beanName)) {
   beanDefinition.getPropertyValues().add("token","testToken" );
  }
 }
}

    • postProcessAfterInstantiation()

      • 接口: InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
      • 作用时期: 实例化结束之后
      • 示例:
        @Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

 @Override
 public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {

  if ("myService".equals(beanName)) {
   Myservice myservice = (UserService) bean;
	  myservice.test();
  }

  return true;
 }
}

    • postProcessProperties()

      • 接口: InstantiationAwareBeanPostProcessor.postProcessProperties()
      • 作用时期: 属性赋值时,可以实现此拓展点实现自己的自动注入
      • 示例:
        @Component
public class MyProcessorProperties implements InstantiationAwareBeanPostProcessor {

 @Override
 public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
	 if ("myService".equals(beanName)) {
	 	// 获取所有的属性
		 for (Field field : bean.getClass().getFields()) {
		 	// 遇到我们自己定义的注解类执行自定义逻辑
			 if (field.isAnnotationPresent(MyImport.class)) {
				 field.setAccessible(true);
				 try {
					 field.set(bean, "test");
				 } catch (IllegalAccessException e) {
					 e.printStackTrace();
				 }
			 }
		 }
	 }
  return pvs;
 }
}

    • postProcessBeforeInitialization()

      • 接口: BeanPostProcessor.postProcessBeforeInitialization()
      • 作用时期: bean初始化前
      • 示例:
        @Component
public class MyBeanPostProcessor implements BeanPostProcessor {

 @Override
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  if ("myService".equals(beanName)) {
   System.out.println("初始化前");
  }

  return bean;
 }
}

    • postProcessAfterInitialization()

      • 接口: BeanPostProcessor.postProcessAfterInitialization()
      • 作用时期: bean初始化后
      • 示例:
        	@Component
	public class MyBeanPostProcessor implements BeanPostProcessor {
	
	 @Override
	 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	  if ("myService".equals(beanName)) {
	   System.out.println("初始化后");
	  }
	
	  return bean;
	 }
	}
	```

这些拓展点在源码的哪里被加载

  • BeanFactory的后置处理器

    • BeanFacctoryPostProcessor

      • Spring加载容器有非常重要的三个步骤

        	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
			// 父类的GenericApplicationContext在构造方法中初始化了一个构造DefaultListableBeanFactory
			this();
			register(componentClasses);
			refresh();
		}
        1. this()构造方法主要创建DefaultListableBeanFactory和AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner
        2. register()主要处理@Lazy@Scope等注解以及注册配置类的BeanDefinition
        3. refresh(), refresh方法做的事情非常多,整个Bean的生命周期都是在这个方法中完成,也就是我们所有的拓展点加载过程都可以在这个方法及其分支中找到,同样BeanFacctoryPostProcessor的postProcessBeanFactory()方法也是在这个过程中加载

      • 源码加载处
        AbstractApplicationContext的refresh()方法

        	@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		.....
		try {
			.....
			// 前面的方法都在准备容器环境
			// 为BeanFactory配置类加载器,添加BeanPostprocessor等准备工作
			// BeanFactory准备就绪后开始执行BeanFactoryPostProcessor,开始对BeanFactory进行处理
			invokeBeanFactoryPostProcessors(beanFactory);
			.....
			}
	}

        invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory)方法

        		protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

			// 执行工厂的后置处理器就是在这个方法中了
			PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
			....
		}

        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法

        public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {   // BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor

	....
	// 先执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
	.....
	// 再执行BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
	invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
	//  再执行手动添加的普通BeanFactoryPostProcessor的postProcessBeanFactory()方法
	invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	....
}

        这个方法中做了很多事情,如果想要了解Spring的启动过程非常建议自己去看看源码

    • BeanDefinitionRegistryPostProcessor

      • 也是在上面的PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法中执行
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 执行扫描出来的BeanDefinitionRegistryPostProcessor
// 先执行实现了PriorityOrdered的BeanDefinitionRegistryPostProcessors
String[] postProcessorNames =
		beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
	if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
		currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
		processedBeans.add(ppName);
	}
}
// 升序排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 执行postProcessBeanDefinitionRegistry()方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();

// 然后执行实现了Ordered的BeanDefinitionRegistryPostProcessor
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
	// processedBeans表示该beanFactoryPostProcessor的postProcessBeanDefinitionRegistry()方法已经执行过了，不再重复执行
	if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
		currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
		processedBeans.add(ppName);
	}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();

// 最后执行没有实现PriorityOrdered和Ordere接口的BeanDefinitionRegistryPostProcessor
// 在这个过程中可能会向BeanFactory中注册另外的BeanDefinitionRegistryPostProcessor，所以需要while，直到确定所有的BeanDefinitionRegistryPostProcessor都执行完
// 在这个过程中注册的BeanDefinitionRegistryPostProcessor，所实现的PriorityOrdered或Ordered接口可能会不按顺序执行
boolean reiterate = true;
while (reiterate) {
	reiterate = false;
	postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
	for (String ppName : postProcessorNames) {
		if (!processedBeans.contains(ppName)) {
			currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
			processedBeans.add(ppName);
			reiterate = true;
		}
	}
	sortPostProcessors(currentRegistryProcessors, beanFactory);
	registryProcessors.addAll(currentRegistryProcessors);
	invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
	currentRegistryProcessors.clear();
}

  • BeanDefinition的后置处理器

    • postProcessBeforeInstantiation()

      • 前面BeanFactory加载执行后就到了Bean的后置处理器加载执行,还是在refresh()方法中
      • 首先是注册这些PostProcessors
        	@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		.....
		try {
			.....
			// 前面的方法都在准备容器环境
			// 为BeanFactory配置类加载器,添加BeanPostprocessor等准备工作
			// BeanFactory准备就绪后开始执行BeanFactoryPostProcessor,开始对BeanFactory进行处理
			invokeBeanFactoryPostProcessors(beanFactory);
			// Register bean processors that intercept bean creation.
			// 将扫描到的BeanPostProcessor排序后添加到BeanFactory的beanPostProcessors属性中去
			registerBeanPostProcessors(beanFactory);
			.....
			}
	}
        看看这个registerBeanPostProcessors()方法, 调用到PostProcessorRegistrationDelegate.registerBeanPostProcessors()方法
        		public static void registerBeanPostProcessors(
				ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	
			String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
			// beanProcessorTargetCount表示BeanFactory中所有的BeanPostProcessor数量,+1包含下面的BeanPostProcessorChecker
			int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
			beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
	
			// 先添加实现PriorityOrdered接口的PostProcessor
			// 再添加实现ordered接口的PostProcessor
			List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
			List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
			List<String> orderedPostProcessorNames = new ArrayList<>();
			List<String> nonOrderedPostProcessorNames = new ArrayList<>();
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
					priorityOrderedPostProcessors.add(pp);
					// 所有MergedBeanDefinitionPostProcessor最后单独注册
					if (pp instanceof MergedBeanDefinitionPostProcessor) {
						internalPostProcessors.add(pp);
					}
				}
				else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
					orderedPostProcessorNames.add(ppName);
				}
				else {
					nonOrderedPostProcessorNames.add(ppName);
				}
			}
	
			// 首先注册实现了PriorityOrdered.
			// 升序排序
			sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
			registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
	
			// 其次注册实现了Ordered.
			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);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
	
			// 注册所有MergedBeanDefinitionPostProcessors
			sortPostProcessors(internalPostProcessors, beanFactory);
			registerBeanPostProcessors(beanFactory, internalPostProcessors);
	
			// Re-register post-processor for detecting inner beans as ApplicationListeners,
			// moving it to the end of the processor chain (for picking up proxies etc).
			// ApplicationListenerDetector放在所有BeanPostProcessor之后
			beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
		}
      • 其次执行postProcessBeforeInstantiation()
        这里经历的过程比较复杂,注册完所有的PostProcessors后,Spring又
        • 初始化了MessageSource
        • 设置了ApplicationContext的applicationEventMulticaster
        • 将实现了ApplicationListener类注册到ApplicationContext中去，添加事件监听器并执行在此之前所发布的事件
        • 最后实例化所有非懒加载的Bean,我们的Bean扩展点就是在这里调用
          来看看源码,还是refresh方法()
        	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
		....
		invokeBeanFactoryPostProcessors(beanFactory);  // scanner.scan()

		// 将扫描到的BeanPostProcessors实例化并排序，并添加到BeanFactory的beanPostProcessors属性中去
		registerBeanPostProcessors(beanFactory);
		....
		//  初始化了MessageSource
		initMessageSource();
		// 设置了ApplicationContext的applicationEventMulticaster
		initApplicationEventMulticaster();
		// 给子类的模板方法
		onRefresh();

		// 扫描并添加事件监听器
		registerListeners();

		// 实例化所有非懒加载的Bean
		finishBeanFactoryInitialization(beanFactory);
		....
	}
        真正实例化Bean的代码在finishBeanFactoryInitialization()这个方法中,我们来看下
        protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// 看源码,先不看if分支,会干扰对整个脉络的理解,我们往下捋一捋
	// 实例化的所有非懒加载的Bean的方法在最后
	....
	// 实例化所有非懒加载的Bean
	beanFactory.preInstantiateSingletons();
}
        这个方法是个门面方法,由DefaultListableBeanFactory实现,这个方法其中没有什么,核心是调用AbstractBeanFactory的getBean()方法获取Bean对象,getBean()方法又调用自身的 doGetBean() 方法,这个方法才是创建Bean的核心方法,这里如果你感兴趣可以自己去看看逻辑实现,这里只展示调用拓展点的代码
        	protected <T> T doGetBean(
	String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
	throws BeansException {
		// 前面是各种Bean类型的判断和处理
					....
		// 这里开始实例化Bean,包括单例Bean原型Bean等
		if (mbd.isSingleton()) {
			sharedInstance = getSingleton(beanName, () -> {
				try {
				 	// 核心方法,在这里创建Bean,也是在这里执行的beanPostProcessors
					return createBean(beanName, mbd, args);
				}
				catch (BeansException ex) {
					// 销毁Bean
					destroySingleton(beanName);
					throw ex;
				}
			});
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
		}
		// 原型Bean
		else if (mbd.isPrototype()) {
			// It's a prototype -> create a new instance.
			Object prototypeInstance = null;
			try {
				beforePrototypeCreation(beanName);
				// 核心方法也是在这里
				prototypeInstance = createBean(beanName, mbd, args);
			}
			finally {
				afterPrototypeCreation(beanName);
			}
			beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
		}
		....
		// 下面还有对于Scope的判断,核心和上面一样也是createBean()
}
        不管是创建哪种类型的bean,其核心方法都是createBean(), 这也是个门面方法,是由子类AbstractAutowireCapableBeanFactory实现的,也是在这里开始了Bean的生命周期
        	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
			....
			try {
				// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
				// 在这里执行实例化前后置处理器
				Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
				if (bean != null) {
					return bean;
				}
			}
			....
			try {
				// 创建Bean
				Object beanInstance = doCreateBean(beanName, mbdToUse, args);
				if (logger.isTraceEnabled()) {
					logger.trace("Finished creating instance of bean '" + beanName + "'");
				}
			return beanInstance;
		}
	}
        很明显resolveBeforeInstantiation()方法就是调用了我们的InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
        	@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// Make sure bean class is actually resolved at this point.
		// 如果是合成bean则不会经过BeanPostProcessor的处理
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			Class<?> targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
			// 这个方法中调用实例化前后置处理器
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				// 如果bean已经被创建了调用实例化后后置处理器
				if (bean != null) {
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

    • postProcessMergedBeanDefinition()

      • 上面的createBean方法处理完实例化前后置处理器后,紧接着就是调用AbstractAutowireCapableBeanFactory.doCreateBean()方法开始实例化bean对象
        	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {

		// 先实例化bean
		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// 有可能在本Bean创建之前，就有其他Bean把当前Bean给创建出来了（比如依赖注入过程中）
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 创建Bean实例
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		....

		// 后置处理合并后的BeanDefinition
		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					// 在这里处理MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
        看看applyMergedBeanDefinitionPostProcessors()方法中是如何实现的,和前面的实现差不多
        	protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
	for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
		processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
	}
}

    • postProcessAfterInstantiation()

      • 这个后置处理器是在实例化后,属性赋值前,所以很容易猜到在源码中的位置
        我们回到刚才那个创建Bean的方法:AbstractAutowireCapableBeanFactory.doCreateBean()
        	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
			// 实例化bean
			...
			//处理MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
			...
			// 解决循环依赖,添加Bean到三级缓存
			...
			// 属性填充
			populateBean(beanName, mbd, instanceWrapper);
			...
}
        这里Spring没有单独写方法处理实例化后后置处理器,而是直接融合到属性填充中,这是非常巧妙的一个做法,在Bean的生命周期中,只要属性开始注入了,那么实例化一定完成了,不管我们怎么拓展实例化期间的代码,总能保证Spring处理实例化后后置处理器的时候一定是实例化完成之后。
        处理后置处理器的代码依旧是大同小异
        		@SuppressWarnings("deprecation")  // for postProcessPropertyValues
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	....
	// 实例化之后，属性设置之前
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
				return;
			}
		}
	}
	....
}

    • postProcessProperties()

      • 属性注入后后置处理器,当然和上面一样也是在populateBean()方法中
        protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	....
	// 实例化之后，属性设置之前,处理实例化后后置处理器
	....
	// 处理Autowired注解,属性自动注入
	....
	//  判断是否有实现InstantiationAwareBeanPostProcessors接口的类
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

	PropertyDescriptor[] filteredPds = null;
	if (hasInstAwareBpps) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			// 调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，直接给对象中的属性赋值
			PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
			// 这里不会处理pvs,直接返回
			if (pvsToUse == null) {
				if (filteredPds == null) {
					filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
				}
				pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					return;
				}
			}
			pvs = pvsToUse;
		}
	}
	...
}

    • postProcessBeforeInitialization()

      • 属性注入后就到初始化了,当然在初始化之前Spring要处理初始化前后置处理器。
        还是回到doGetBean()方法：
        		protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
			// 实例化bean
			...
			//处理MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
			...
			// 解决循环依赖,添加Bean到三级缓存
			...
			try {
				// 属性填充
				populateBean(beanName, mbd, instanceWrapper);
				// 初始化
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}catch (Throwable ex) {
			....
			}
			...
}
        spring的脉络是非常清晰的,还是那句话,看主脉络,熟悉整体框架再来看细节,initializeBean()这个方法中处理了初始化前和初始化后后置处理器
        protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	// 初始化前
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	// 初始化
	try {
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		...
	}

	// 初始化后 AOP
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	....
}
        具体的处理方法就不用看了,和之前一样,循环获取所有的processors,调用postProcessBeforeInitialization()方法

    • postProcessAfterInitialization()

      • 源码调用处见上

该怎么用这些拓展点

  • 该怎么用这些拓展点见仁见智,每个项目都有不同的需求,但是Spring的做法可能会给你一些参考
    • 比如Spring事务,主要是通过AutoProxyRegistrar向Spring容器中注册了一个InfrastructureAdvisorAutoProxyCreator的Bean。
      InfrastructureAdvisorAutoProxyCreator继承了AbstractAdvisorAutoProxyCreator，AbstractAdvisorAutoProxyCreator继承了AbstractAutoProxyCreator，AbstractAutoProxyCreator实现了InstantiationAwareBeanPostProcessor的子类，重写了postProcessBeforeInstantiation()、postProcessAfterInitialization()方法,会在实例化前步骤处理targetSource（SpringAop的核心内容），在初始化后创建代理对象,从而实现事务管理
    • 比如mybatis-Spring新版实现了BeanDefinitionRegistryPostProcessor接口,容器启动时调用postProcessBeanDefinitionRegistry()方法,创建一个ClassPathMapperScanner扫描mapper对象
    • 再比如官方提供的@PostConstruct注解,可以让你在属性注入后,初始化前做一些个性化定制,比如获取自己的session连接或者socket连接等

Spring源码还有很多精彩的地方需要自己去阅读探究,此篇文章仅是抛砖引玉,希望能帮助你理解部分Spring的思路,如果觉得文章还不错或者帮助到你了,帮忙点个赞吧

夏の在りか
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring后置处理器（BeanPostProcessor）
洛卡JAVA架构师每日分享Java架构师知识
05-18 714
本节主要介绍在《[Spring Bean生命周期]》一节提到的 BeanPostProcessor 接口。BeanPostProcessor 接口也被称为后置处理器，通过该接口可以自定义调用初始化前后执行的操作方法。 BeanPostProcessor 接口源码如下： 1. public interface BeanPostProcessor { 2. Object postProcessBeforeInitialization(Object bean, String beanNam
spring源码：九大后置处理器
小小少年的博客
05-31 5484
目的： spring在完成一个bean的初始化、实例化的过程中，会用到九个后置处理器；本文梳理出这九个后置处理器 九大后置处理器 spring在初始化的过程中，会在九个地方分别调用了五个后置处理的九个方法 第一次调用后置处理器org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation InstantiationAwareBeanPostProcessor --&
聚焦Spring后置处理器分析对比
张彦峰的博客
05-02 9023
Spring Framework 中的后置处理器允许在容器实例化 Bean 或者在 Bean 的生命周期中进行操作。从源码上来看的话，其实其扩展机制下的后置处理器其实很多。我们重点放到我们常用的几个上BeanPostProcessor、BeanFactoryPostProcessor来聚焦分析一下。
spring源码-bean的后置处理器
路漫漫其修远兮，吾将上下而求索。
12-12 699
bean的后置处理器
Spring源码解析手册
02-21
在创建过程中，`populateBean()`填充Bean的属性，`postProcessProperties()`则处理属性后置处理器，最后`doResolveDependency()`处理Bean的依赖解析，确保所有依赖被正确地注入到`louzai1`中。 通过这样的详细解析...
Spring源码
07-26
本压缩包包含的Spring源码，是用于深入理解其内部工作原理和设计模式的宝贵资源。使用Eclipse IDE可以直接导入，无需进行额外的编译步骤，方便开发者快速学习和调试。 首先，Spring的核心是IoC容器，它负责管理对象...
spring源码15: 属性填充
01-20
本篇我们将介绍前三种，@Autowire应该是百分之99的开发者选择的的注入方式，它通过属性填充中的后置处理器完成，因此本篇有涉及后置处理器的不用太纠结，将单独一片详解：spring源码16: @Autowired实现原理 ...
spring简单前置通知、后置处理。
03-15
NULL 博文链接：https://java-frog.iteye.com/blog/325364
Spring源码解读.pptx
08-08
通过自定义ApplicationContext的子类，可以扩展Spring的功能，例如添加自定义的Bean后置处理器。 Spring Framework的源码解读是一个复杂而深邃的主题，涵盖了诸如Bean的生命周期管理、AOP的实现、IoC容器的工作原理...
Spring纯注解开发
Admans的专栏
07-18 859
Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦注解开发前，配置Bean时是在xml里将class分别写在Bean标签里，然后起id，就像这样注解开发后，配置Bean时首先将xml里的标签删掉，然后在类上添加@Component注解即可在xml文件中来写一个扫描包的注解标签，对象就装进IOC容器里了component-scan:component意为组件，scan意为扫描。
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 400
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 211
zookeeper安装并成功运行。
SpringMVC 控制层框架-下
woai3364的博客
07-20 1023
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
Springboo3中使用虚线程
java scala
07-19 373
Java中的虚线程类似Go中的协程，简单来说可以通过同步编程的方式来达到异步编程模式的效果，
Java面试八股之Spring容器的启动流程
u012151345的博客
07-23 619
在整个过程中，Spring遵循了IoC（控制反转）和DI（依赖注入）原则，确保Bean的创建、配置、组装和管理都在容器的统一控制之下，实现了松耦合和可扩展的软件架构。创建BeanDefinition：解析配置信息的过程中，Spring会为每个Bean生成对应的BeanDefinition对象，它包含了Bean的类型、构造方法参数、属性值、初始化方法、依赖关系、作用域、生命周期回调方法等所有相关信息。Spring容器的启动流程涉及一系列有序的操作，以确保容器正确初始化并准备好管理应用程序中的Bean。
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 588
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
springboot之自动装配
最新发布
weixin_50153914的博客
07-23 212
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
【OAuth2系列】集成微信小程序登录到 Spring Security OAuth 2.0
c18213590220的博客
07-21 1641
本文将详细介绍如何在 Spring Security OAuth 2.0 中扩展支持微信小程序登录，通过自定义授权方式实现无缝登录。
Bean的后置处理器
07-29
Bean的后置处理器是一种特殊的接口，即BeanPostProcessor接口。它定义了两个方法：postProcessBeforeInitialization和postProcessAfterInitialization。\[1\]这两个方法分别在Bean的初始化之前和之后被调用，可以在这两个方法中对Bean进行一些额外的处理操作。在Spring容器中，BeanFactory和ApplicationContext对待Bean的后置处理器有一些不同。ApplicationContext容器会自动检测配置文件中实现了BeanPostProcessor接口的类，并将其注册为后置处理器，而BeanFactory容器需要通过代码显式注册后置处理器。\[2\]后置处理器可以用来修改Bean的属性或行为，例如在postProcessAfterInitialization方法中根据条件修改Bean的属性值。\[3\]通过实现BeanPostProcessor接口并重写相应的方法，我们可以自定义后置处理器来对Bean进行额外的处理。 #### 引用[.reference_title] - *1* [spring源码-bean的后置处理器](https://blog.csdn.net/sunqingzhong44/article/details/128284663)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Spring之BeanPostProcessor(后置处理器)介绍](https://blog.csdn.net/qq_38526573/article/details/88086752)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [[spring学习]5、bean的后置处理器(BeanPostProcessor)](https://blog.csdn.net/m0_51545690/article/details/125189749)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值