精华内容
下载资源
问答
  • 后置处理器是什么
    2022-05-05 13:19:45

    解释什么是jmeter后置处理器?

    要在发出请求后执行任何操作,则使用后处理器。例如,如果JMeter向Web服务器发送HTTP请求,并且如果你希望JMeter在Web服务器显示错误时停止发送请求,那么你将使用后处理器执行此操作。


    个人简介


    我是一名测试兼开发工程师,目前25K,目前做的是无人驾驶,欢迎和大家一起交流测试技术,
    起高薪就业,我们还有一起打妖怪的群哦,还有面试题小程序哦

    更多相关内容
  • 主要介绍了Jmeter后置处理器实现过程及方法应用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Spring 详解Bean的后置处理器

    千次阅读 2021-07-02 14:59:35
    Bean的后置处理器详解: Spring当中的后置处理器是Spring体用的一个扩展点,开发者只要去实现,Spring当中的BeanPostProcessor接口,那么就能插手SpringBean实例化的一个过程,怎么插手呢? 它是在我们bean被放到...

    Bean的后置处理器详解:

    Spring当中的后置处理器是Spring体用的一个扩展点,开发者只要去实现,Spring当中的BeanPostProcessor接口,那么就能插手SpringBean实例化的一个过程,怎么插手呢?

    它是在我们bean被放到Spring Bean容器之前去做一个插手,也就是说可以对我们的bean做一个改变。

     Spring 在实例化单例Bean的过程中,会在9个地方执行5个后置处理器。       

    第一个后置处理器:

    BeanPostProcessor

    bean工厂的bean属性处理容器,就是可以管理我们的bean工厂内所有的beandefinition(未实例化)数据,可以随心所欲的修改属性。它有下面两个方法:

    方法说明
    postProcessBeforeInitialization初始化之前完成一些定制的业务逻辑
    postProcessAfterInitialization初始化完毕时执行的业务逻辑

     第二个后置处理器:

    InstantiationAwareBeanPostProcessor

    InstantiationAwareBeanPostProcessor接口继承BeanPostProcessor接口,它内部提供了3个方法,再加上BeanPostProcessor接口内部提供的2个方法,所以实现这个接口需要实现5个方法。InstantiationAwareBeanPostProcessor接口的主要作用在于目标对象的实例化过程中需要处理的事情,包括实例化对象的前后过程以及实例的属性设置。
    

    方法说明
    postProcessBeforeInstantiation()在目标对象实例化之前调用,方法的返回值类型是Object,我们可以返回任何类型的值。由于这个时候目标对象还未被实例化,所以这个返回值可以用来代替原本该生成的目标对象的实例(一般是代理对象)。如果该方法的返回值代替原本该生成的目标对象,后续只有postProcessorAfterIniaialization方法会调用,其他方法不再调用,否则按照正常流程走。
    postProcessAfterInstantiation()方法在目标对象实例化之后调用,这个时候对象已经被实例化,但是该实例的属性还未被设置,都是null。如果该方法的返回值是false,会忽略属性值的设置;如果返回true,会按照正常流程设置属性值。方法不管postProcessBeforeInstantiation()返回什么都会执行
    postProcessPropertyValues()方法对属性值进行修改(这个时候属性值还未被设置,但是我们可以修改原本该设置进去的属性值)如果postProcessAfterInstantiation()返回false,该方法不会被调用

    第三个后置处理器:

    SmartInstantiationAwareBeanPostProcessor

    智能实例化Bean后置处理器(继承InstantiationAwareBeanPostProcessor),内部提供了3个方法

    方法说明
    determineCandidateConstructors()监测Bean的构造器
    predictBeanType()预测bean的类型
    getEarlyBeanReference()循环引用的后置处理器,这个比较复杂,获取提前暴露的bean引用。主要用于解决循环引用的问题。只有单例对象才会调用此方法。

    第四个后置处理器:

    MergedBeanDefinitionPostProcessor

    合并bean信息,或者说合并属性的后置处理器

    方法说明
    postProcessMergedBeanDefinition()缓存bean注入信息的后置处理器,仅仅是缓存或者说是查询,没有完成注入,注入是另外一个后置处理器的作用

    展开全文
  • spring是如何获取后置处理器的,又是按照什么顺序来执行这些后置处理器的,看完这篇文章你进全懂了

    spring的后置处理器是spring中很重要的一块,可以说你的项目能启动后置处理器有一大半的功劳,今天不会具体讲某个后置处理(先把坑挖好,日后再说),只会讲到spring是如果获取这些后置处理的,又是按照什么顺序来执行这些后置处理器的。

    1、bean的后置处理器都有哪些

    a.实现了BeanFactoryPostProcessor接口的类,这个接口还有个子类BeanDefinitionRegistryPostProcessor,他们从代码上的区别是BeanDefinitionRegistryPostProcessor比他的父类多一个方法postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry),在执行上的区别是在相同的情况下实现了BeanDefinitionRegistryPostProcessor会比只实现了BeanFactoryPostProcessor更早执行。这两个接口你不管执行那个你都可以参与到容器的初始化当中。

    b.实现了BeanPostProcessor接口的类

    a和b的主要区别是a的发力点在BeanDefinition而a的发力点在于bean,你可以发现在spring当中有好多实现了这几个接口的,那么spring是怎么觉得到底是谁先来执行的呢?除了上面的接口还有Ordered和PriorityOrdered接口,你可以实现这两个接口来调整后置处理器在执行过程中的先后顺序。

    2、spring是怎么找到你这些后置处理器的

    想要参与bean的创建,你首先的让spring能找到你的后置处理器,包括程序员自己的和spring自己的后置处理器,spring是怎么获取到的呢?下面从代码中一探究竟

    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    	this(); //在构造ApplicationContext时调用了无参的构造方法
    	register(componentClasses);
    	refresh(); //这个方法很关键很重要这个方法弄明白了你spring就通透了
    }
    
    //无参的构造方法
    public AnnotationConfigApplicationContext() {
    	StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
    	//read赋值了BeanDefinitionReader
    	this.reader = new AnnotatedBeanDefinitionReader(this);
    	createAnnotatedBeanDefReader.end();
    	this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    
    //这个方法产生了一个reader
    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    	this.registry = registry;
    	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    	//他既然叫注册配置处理,那么不难感觉到这一步和注解的处理程序有关,那我们在启动类的注解上添加了扫描的路径,大概率和他有关系没跑了(不用想确实是他,我们往下看)
    	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); 
    }
    
    
    //AnnotationConfigUtils.registerAnnotationConfigProcessors() 有删减
    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    		BeanDefinitionRegistry registry, @Nullable Object source) {
    
    	/*
    	这里获取到了beanFactory,但是beanFactory的创建其实是这样的,
    	AnnotationConfigApplicationContext继承了GenericApplicationContext
    	在GenericApplicationContext的构造方法里new了一个DefaultListableBeanFactory,这里获取到的就是他
    	*/
    	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    
    	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    
    	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    		/*
    		这里放了ConfigurationClassPostProcessor的bd到beanFactory中
    		这个ConfigurationClassPostProcessor很重要通过他可以扫描到很多东西,当然还有其他的功能
    		*/
    		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    		def.setSource(source);
    		/*
    		registerPostProcessor把这个bd注册到beanFactory厂里了,
    		也就是在registerAnnotationConfigProcessors()这个方法里最基本的几个bd被放到了beanFactory中,
    		在registerAnnotationConfigProcessors()放进去的这几个bd可以说是梦开始的地方
    		*/
    		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    	}
    	//...省略了还有其他的bd放到beanFactory中了
    	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    		//... jpa是亲儿子啊,Mybatis就没这待遇 代码省略le
    	}
    	return beanDefs; //这个地方虽然返回了但是没有用到,registerPostProcessor是重点
    }
    

    所以spring自己的后置处理器是通过以上的形式被手动注册到beanFactory中的。

    刚我们讲到了ConfigurationClassPostProcessor的bd被放到了beanFactory中,我们自己的后置处理器是怎么被发现的答案就在这个类里面,我们来具体看看这个类他实现的接口包括了BeanDefinitionRegistryPostProcessor接口PriorityOrdered接口根据上面讲的,这个类是一个后置处理器,而且是处理beanDefinition的,他相当重要。

    // ConfigurationClassPostProcessor.java postProcessBeanDefinitionRegistry()
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    	//...省略le
    	processConfigBeanDefinitions(registry);
    }
    
    //最后这个方法会一路调用到ConfigurationClassParser.java的doProcessConfigurationClass()方法
    @Nullable
    protected final SourceClass doProcessConfigurationClass(
    		ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    		throws IOException {
    
    	//...省略了
    
    	// 处理 @ComponentScan 注解
    	Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
    			sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    	if (!componentScans.isEmpty() &&
    			!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
    		for (AnnotationAttributes componentScan : componentScans) {
    			// 解析类上的@ComponentScan注解 立即扫描 
    			Set<BeanDefinitionHolder> scannedBeanDefinitions =
    					this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
    			//检查扫描的定义集是否有任何进一步的配置类,并在需要时递归解析
    			for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
    				BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
    				if (bdCand == null) {
    					bdCand = holder.getBeanDefinition();
    				}
    				if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
    					parse(bdCand.getBeanClassName(), holder.getBeanName());
    				}
    			}
    		}
    	}
    
    	//处理所有的@Import 注解
    	processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
    
    	// 处理所有的 @ImportResource 注解
    	AnnotationAttributes importResource =
    			AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    	if (importResource != null) {
    		String[] resources = importResource.getStringArray("locations");
    		Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
    		for (String resource : resources) {
    			String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
    			configClass.addImportedResource(resolvedResource, readerClass);
    		}
    	}
    
    	// 处理 @Bean 方法
    	Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    	for (MethodMetadata methodMetadata : beanMethods) {
    		configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    	}
    
    	//...省略了
    	return null;
    }
    

    由于你的所有的后置处理器都是要交给spring管理的所以,在解析@ComponentScan的时候会把它扫描出来并生成bd注册到beanFactory中,在beanFactory中有一个getBeanNamesForType()方法就可以根据类型拿到bean的名字,这样我们只需要调用这个方法就可以拿到对应的后置处理器了。

    3、后置处理器的执行顺序

    真正那些这些后置处理器干活的是PostProcessorRegistrationDelegate.java的invokeBeanFactoryPostProcessors()方法,这个方法有两个参数beanFactory和beanFactoryPostProcessors,beanFactoryPostProcessors是传进来的BeanFactoryPostProcessor,执行顺序为:

    a. beanFactoryPostProcessors 里面实现了 BeanDefinitionRegistryPostProcessor接口的先执行postProcessBeanDefinitionRegistry 并加入registryProcessor;没有实现的加入regularPostProcessors
    b.beanFactory 里面 实现了BeanDefinitionRegistryPostProcessor接口和PriorityOrdered接口的 排序后加入到registryProcessors 并执行postProcessBeanDefinitionRegistry
    c.beanFactory 里面 实现了BeanDefinitionRegistryPostProcessor接口和Ordered接口的 排序后加入到registryProcessors 并执行postProcessBeanDefinitionRegistry
    d.beanFactory 里面 实现了BeanDefinitionRegistryPostProcessor接口的 排序后加入到registryProcessors 并执行postProcessBeanDefinitionRegistry
    e. 执行registryProcessors里面的postProcessBeanFactory
    f. 执行regularPostProcessors里面的postProcessBeanFactory
    i. beanFactory 里面 实现了BeanFactoryPostProcessor、PriorityOrdered接口的 排序后执行postProcessBeanFactory
    g. beanFactory 里面 实现了BeanFactoryPostProcessor、Ordered接口的 排序后执行postProcessBeanFactory
    k. beanFactory 里面 实现了BeanFactoryPostProcessor接口的 排序后执行postProcessBeanFactory

    口说无凭上代码

    public static void invokeBeanFactoryPostProcessors(
    		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
    	
    	Set<String> processedBeans = new HashSet<>();
    
    	if (beanFactory instanceof BeanDefinitionRegistry) {
    		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    
    		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
    			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
    				BeanDefinitionRegistryPostProcessor registryProcessor =
    						(BeanDefinitionRegistryPostProcessor) postProcessor;
    				/*
    				beanFactoryPostProcessors 里面实现了BeanDefinitionRegistryPostProcessor接口的
    				先执行postProcessBeanDefinitionRegistry 并加入registryProcessor
    				*/
    				registryProcessor.postProcessBeanDefinitionRegistry(registry);
    				registryProcessors.add(registryProcessor);
    			}
    			else {
    				//没有实现的加入regularPostProcessors
    				regularPostProcessors.add(postProcessor);
    			}
    		}
    
    		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    		/*
    		beanFactory 里面 实现了BeanDefinitionRegistryPostProcessor接口和PriorityOrdered接口的 
    		排序后加入到registryProcessors 并执行postProcessBeanDefinitionRegistry
    		 */
    		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);
    		//执行后置处理器 ConfigurationClassPostProcessor里面的方法就是在这被执行的
    		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
    		currentRegistryProcessors.clear();
    
    		/*
    		beanFactory 里面 实现了BeanDefinitionRegistryPostProcessor接口和Ordered接口的 
    		排序后加入到registryProcessors 并执行postProcessBeanDefinitionRegistry 
    		*/
    		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    		for (String ppName : postProcessorNames) {
    			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();
    
    		/*
    		beanFactory 里面 实现了BeanDefinitionRegistryPostProcessor接口的 
    		排序后加入到registryProcessors 并执行postProcessBeanDefinitionRegistry
    		*/
    		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();
    		}
    
    		// 执行registryProcessors里面的postProcessBeanFactory
    		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    		//执行regularPostProcessors里面的postProcessBeanFactory
    		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    	}
    
    	else {
    		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    	}
    
    	//beanFactory 里面 实现了BeanFactoryPostProcessor接口的 排序后执行postProcessBeanFactory
    	String[] postProcessorNames =
    			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
    	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    	List<String> orderedPostProcessorNames = new ArrayList<>();
    	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    	for (String ppName : postProcessorNames) {
    		if (processedBeans.contains(ppName)) {
    		}
    		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    			// 实现了BeanFactoryPostProcessor、PriorityOrdered接口的加入priorityOrderedPostProcessors
    			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    		}
    		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    			// 实现了BeanFactoryPostProcessor、Ordered接口的加入orderedPostProcessorNames
    			orderedPostProcessorNames.add(ppName);
    		}
    		else {
    			//实现了BeanFactoryPostProcessor接口的加入nonOrderedPostProcessorNames
    			nonOrderedPostProcessorNames.add(ppName);
    		}
    	}
    
    	// 先执行priorityOrderedPostProcessors
    	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
    	// 再执行orderedPostProcessorNames
    	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    	for (String postProcessorName : orderedPostProcessorNames) {
    		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    	}
    	sortPostProcessors(orderedPostProcessors, beanFactory);
    	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
    	// 最后执行nonOrderedPostProcessors
    	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    	for (String postProcessorName : nonOrderedPostProcessorNames) {
    		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    	}
    	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    	beanFactory.clearMetadataCache();
    }
    

    这样BeanFactoryPostProcessor的处理就结束了

    BeanPostProcessor的处理是注册制的,他会把所有的BeanPostProcessor注册到beanFactory里的beanPostProcessors(这是个List<BeanPostProcessor>)里面,注册的顺序是实现了PriorityOrdered在前面,实现了Ordered紧随其后,最后是只实现了BeanPostProcessor的
    然后这些后置处理器的执行是在bd生成bean(调用getBean()方法)的时候。
    注册BeanPostProcessor的代码在PostProcessorRegistrationDelegate.java的registerBeanPostProcessors()方法里面
    使用这些后置处理器是在AbstractAutowireCapableBeanFactory.java的initializeBean()方法里面

    if (mbd == null || !mbd.isSynthetic()) {
    	//执行前处理
    	wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    
    //...中间有省略
    if (mbd == null || !mbd.isSynthetic()) {
    	//执行后处理
    	wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    

    至此spring的后置处理器的处理流程你大致已经了解了,欢迎评论区!

    展开全文
  • BeanFactory的后置处理器什么?2. BeanFactory的后置处理器分类3. BeanFactory的后置处理器使用3.1 BeanDefinitionRegistryPostProcessor 带注册功能的3.2 BeanFactoryPostProcessor 不带注册功能的4. ...

    BeanFactory的后置处理器

    1. BeanFactory的后置处理器是什么?

    首先,Spring容器在运行的过程中,第一步肯定是创建一个BeanFactory工厂对象,这个对象来负责bean的注册,bean的创建等一系列工作。一般默认的是org.springframework.beans.factory.support.DefaultListableBeanFactory 这个类。当然这部分工作是Spring来完成的,工厂初始化完之后,为了让用户可以去做一些定制型的事情,所以提供了org.springframework.beans.factory.config.BeanFactoryPostProcessor 函数式接口,使用过程中只需要实现这个接口,然后将当前的类注册进去即可。

    2. BeanFactory的后置处理器分类

    共分为两类:一个是带注册功能的后置处理器,即实现org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor接口。一个是不带注册功能的后置处理器,即实现org.springframework.beans.factory.config.BeanFactoryPostProcessor 接口。
    ps: BeanDefinitionRegistryPostProcessor接口是继承了BeanFactoryPostProcessor 接口

    在这里插入图片描述
    在这里插入图片描述

    3. BeanFactory的后置处理器使用

    3.1 BeanDefinitionRegistryPostProcessor 带注册功能的

    @Component
    public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            // 参数registry 是 BeanDefinitionRegistry 类型的。
            // 其实真正传过来的是DefaultListableBeanFactory对象
            if (registry instanceof DefaultListableBeanFactory){
                System.out.println("true");
            }
            // 在这里,我们调用DefaultListableBeanFactory的任何API,做我们自己想做的事情。
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            // 参数beanFactory 是 ConfigurableListableBeanFactory 类型的。
            // 其实真正传过来的是DefaultListableBeanFactory对象
            if (beanFactory instanceof DefaultListableBeanFactory){
                System.out.println("----");
                System.out.println("true");
            }
            // 在这里,我们调用DefaultListableBeanFactory的任何API,做我们自己想做的事情。
        }
    }
    

    两次传入过来的都是DefaultListableBeanFactory对象,为什么还要搞成两个方法?其实这里涉及一个调用顺序的问题,后面会讲。

    3.2 BeanFactoryPostProcessor 不带注册功能的

    @Component
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            // 参数beanFactory 是 ConfigurableListableBeanFactory 类型的。
            // 其实真正传过来的是DefaultListableBeanFactory对象
            if (beanFactory instanceof DefaultListableBeanFactory){
                System.out.println("----");
                System.out.println("true");
            }
            // 在这里,我们调用DefaultListableBeanFactory的任何API,做我们自己想做的事情。
        }
    }
    

    用起来没什么难的。

    4. BeanFactory的后置处理器IOC加载顺序。

    既然需要去调用我们自己定义的BeanFactory的后置处理器,首先我们的BeanFactory的后置处理器肯定是先注册到Spring容器中,然后创建对应的对象来进行方法的调用。所以我们要搞清楚BeanFactory的后置处理器何时被注册?
    在注解方式下: 首先会去加载Spring自带的BeanFactory的后置处理器,之后在解析配置类即带有@Configuration注解类的时候将自定义的BeanFactory的后置处理器注册进去,然后在调用。

    4.1 Spring自带的BeanFactory的后置处理器。

    在创建AnnotationConfigApplicationContext对象的时候,同时会去创建一个AnnotatedBeanDefinitionReader类,在AnnotatedBeanDefinitionReader类的构造过程中,会去注册Spring自带的BeanFactory的后置处理器。具体代码如下:

    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    			BeanDefinitionRegistry registry, @Nullable Object source) {
    
    		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    		if (beanFactory != null) {
    			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
    				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
    			}
    			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
    				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
    			}
    		}
    
    		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    
    		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    			RootBeanDefinition def = new RootBeanDefinition();
    			try {
    				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
    						AnnotationConfigUtils.class.getClassLoader()));
    			}
    			catch (ClassNotFoundException ex) {
    				throw new IllegalStateException(
    						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
    			}
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
    			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    		}
    
    		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
    			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    		}
    
    		return beanDefs;
    	}
    

    其实只是注册了两个BeanFactory后置处理器。一个是 ConfigurationClassPostProcessor.class,一个是EventListenerMethodProcessor.class。主要关注的是ConfigurationClassPostProcessor.class,此BeanFactory的后置处理器是解析@Configuration来使用的。自定义的后置处理器,也是在解析@Configuration后来实现注册。当然你可以手动强制性注册,野路子。

    4.2 自定义的BeanFactory的后置处理器。

    自定义的BeanFactory的后置处理器,正常情况是,是在解析了@Configuration后来进行注册,也就是Spring自带的ConfigurationClassPostProcessor.class执行完,自定义的就会注册完。当然你可以手动调用register方法进行注册。例如:
    在这里插入图片描述

    5. BeanFactory的后置处理器执行顺序,重点。

    上面讲过了BeanFactory的后置处理器的注册,现在看一下BeanFactory的后置处理器的执行阶段,当然涉及到一个执行的顺序问题。
    BeanFactory的后置处理器执行调用的方法在 refresh 方法中。
    在这里插入图片描述
    点进去看一下
    在这里插入图片描述
    具体代码实现如下:

    // 此方法进行beanFactory的后置处理器调用,参数beanFactory是之前创建好的DefaultListableBeanFactory对象,参数beanFactoryPostProcessors,是beanFactory后置处理器对象的集合,但是这个时候是空的。
    public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
    		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
    		// 创建一个处理器bean的set集合。
    		Set<String> processedBeans = new HashSet<>();
    
    		// 此时BeanDefinitionRegistry的null,所以此方法不会走,考虑的其他的情况,所以有这段代码。
    		if (beanFactory instanceof BeanDefinitionRegistry) {
    			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    
    			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
    				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
    					BeanDefinitionRegistryPostProcessor registryProcessor =
    							(BeanDefinitionRegistryPostProcessor) postProcessor;
    					registryProcessor.postProcessBeanDefinitionRegistry(registry);
    					registryProcessors.add(registryProcessor);
    				}
    				else {
    					regularPostProcessors.add(postProcessor);
    				}
    			}
    
    			// Do not initialize FactoryBeans here: We need to leave all regular beans
    			// uninitialized to let the bean factory post-processors apply to them!
    			// Separate between BeanDefinitionRegistryPostProcessors that implement
    			// PriorityOrdered, Ordered, and the rest.
    			// 创建一个list集合,后续用于存放已经实例化的beanFactory后置处理器。
    			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    
    			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
    			// 首先去调用,实现了BeanDefinitionRegistryPostProcessors接口的后置处理器。并且实现了PriorityOrdered接口的。此处获取对应的对象名称。
    			String[] postProcessorNames =
    					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    			// 循环判断,找出实现PriorityOrdered接口的beanFactory的后置处理器,调用优先级最高。
    			for (String ppName : postProcessorNames) {
    				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    					// 如果已经实现了,调用getBean去创建对象。Spring自己也会去调用getBean对象,不只是我们会去调用。并且放入到马上被调用的beanFactory的后置处理器中。
    					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    					// 放入到所有的后置处理器中。
    					processedBeans.add(ppName);
    				}
    			}
    			// 进行排序,因为实现PriorityOrdered.class接口的也可以有很多个,可以根据值来设置调用的优先顺序。
    			sortPostProcessors(currentRegistryProcessors, beanFactory);
    			// 把将要调用的beanFactory的后置处理去放入到registryProcessors中。
    			registryProcessors.addAll(currentRegistryProcessors);
    			// 这里开始真正的调用beanFactory的后置处理器。
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    			// 已经被调用后清除currentRegistryProcessors集合。
    			currentRegistryProcessors.clear();
    
    			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
    			// 再次获取一次beanFactory的后置处理器名单。
    			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    			// 循环调用
    			for (String ppName : postProcessorNames) {
    				// 先判断是否已经被调用过,然后调用实现Ordered接口的beanFactory的后置处理器
    				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
    					// 依然是去创建实现了Ordered接口的beanFactory的后置处理器对象。
    					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    					// 加入到processedBeans集合中
    					processedBeans.add(ppName);
    				}
    			}
    			// 仍然进行排序
    			sortPostProcessors(currentRegistryProcessors, beanFactory);
    			// 放入到registryProcessors集合中
    			registryProcessors.addAll(currentRegistryProcessors);
    			// 调用实现了Odered接口的beanFactory后置处理器
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    			// 清除currentRegistryProcessors集合。
    			currentRegistryProcessors.clear();
    
    			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    			// 调用剩下的没有实现Ordered 和PriorityOrdered 接口的beanFactory的后置处理器。
    			boolean reiterate = true;
    			while (reiterate) {
    				reiterate = false;
    				// 获取所有的实现了BeanDefinitionRegistryPostProcessor接口的bean的后置处理器。
    				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    				// 循环判断
    				for (String ppName : postProcessorNames) {
    					// 是否已经被调用过,如果没有被调用,就会被调用。
    					if (!processedBeans.contains(ppName)) {
    						// 创建bean对象,添加到这个集合中currentRegistryProcessors
    						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    						processedBeans.add(ppName);
    						reiterate = true;
    					}
    				}
    				// 进行排序
    				sortPostProcessors(currentRegistryProcessors, beanFactory);
    				// 添加到registryProcessors集合中
    				registryProcessors.addAll(currentRegistryProcessors);
    				// 开始调用。具体的可以看下面。
    				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    				// 清除集合。
    				currentRegistryProcessors.clear();
    			}
    
    			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
    			// 因为BeanDefinitionRegistryPostProcessor接口是继承BeanFactoryPostProcessor接口的,所以我们之前只是调用了postProcessBeanDefinitionRegistry方法,还有一个postProcessBeanFactory没有调用。在此处调用。
    			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    			// 这个没什么意义。
    			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    		}
    
    		else {
    			// Invoke factory processors registered with the context instance.
    			// 此处用于其他工程对象进行调用的。
    			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    		}
    
    		// Do not initialize FactoryBeans here: We need to leave all regular beans
    		// uninitialized to let the bean factory post-processors apply to them!
    		// 获取所有实现BeanFactoryPostProcessor接口的beanFactory后置处理器。
    		String[] postProcessorNames =
    				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
    		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    		// Ordered, and the rest.
    		// 创建三个集合,priorityOrderedPostProcessors 存放实现了priorityOrdered接口的,
    		// orderedPostProcessorNames 存放实现了ordered接口的。
    		// nonOrderedPostProcessorNames 没有实现任何排序接口的。
    		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    		List<String> orderedPostProcessorNames = new ArrayList<>();
    		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    		// 循环遍历
    		for (String ppName : postProcessorNames) {
    			// 出去上一个阶段调用过的。
    			if (processedBeans.contains(ppName)) {
    				// skip - already processed in first phase above
    			}
    			// 找出实现了PriorityOrdered接口的。
    			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    				// 并且此时已经创建好bean了。
    				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    			}
    			// 找出实现了Ordered接口的。
    			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    				orderedPostProcessorNames.add(ppName);
    			}
    			else {
    				// 找出没有实现排序接口的。
    				nonOrderedPostProcessorNames.add(ppName);
    			}
    		}
    
    		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    		// 最先调用实现了priorityOrdered接口的,进行排序
    		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    		// 进行调用
    		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
    		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    		// 然后调用实现了ordered接口的。
    		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    		for (String postProcessorName : orderedPostProcessorNames) {
    			// 创建了实现ordered接口的实例。
    			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    		}
    		// 排序
    		sortPostProcessors(orderedPostProcessors, beanFactory);
    		// 调用
    		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
    		// Finally, invoke all other BeanFactoryPostProcessors.
    		// 最后调用没有实现排序接口的
    		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    		for (String postProcessorName : nonOrderedPostProcessorNames) {
    			// 创建实例
    			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    		}
    		// 进行调用。
    		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    
    		// Clear cached merged bean definitions since the post-processors might have
    		// modified the original metadata, e.g. replacing placeholders in values...
    		// 清楚缓存, 因为beanFactory的后置处理器可能已经修改了bean的信息。
    		beanFactory.clearMetadataCache();
    	}
    /**
    	 * Invoke the given BeanDefinitionRegistryPostProcessor beans.
    	 */
    	private static void invokeBeanDefinitionRegistryPostProcessors(
    			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
    		// 调用实现了BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法。
    		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
    			postProcessor.postProcessBeanDefinitionRegistry(registry);
    		}
    	}
    /**
    	 * Invoke the given BeanFactoryPostProcessor beans.
    	 */
    	private static void invokeBeanFactoryPostProcessors(
    			Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
    
    		for (BeanFactoryPostProcessor postProcessor : postProcessors) {
    			postProcessor.postProcessBeanFactory(beanFactory);
    		}
    	}
    
    

    图解:
    在这里插入图片描述

    5. BeanFactory的后置处理器执行顺序扩展点

    5.1 扩展点1 排序接口

    排序接口有两种,一种是 PriorityOrdered接口,一种是Ordered接口。
    在这里插入图片描述
    在这里插入图片描述
    由此可知,PriorityOrdered继承了Ordered类,而且实现PriorityOrdered接口的执行顺序在实现了Ordered接口之前。

    5.2 PriorityOrdered 排序接口 对自定义beanFactory的后置处理器的意义

    1.如果自定义BeanFactory的后置处理器,正常逻辑是在ConigurationClassPostProcessor的执行后才加载,所以一定程度上PriorityOrdered对自定义beanFactory的后置处理器没任何意义。
    2.但是我们可以强行把自定义beanFactory的后置处理器的执行顺序提到ConigurationClassPostProcessor之前。具体操作:

    • 实现 PriorityOrdered接口。并且getOrder(),可以控制顺序,但是ConigurationClassPostProcessor永远是最优先的。
    • 手动注册自定义BeanFactory的后置处理器。
    展开全文
  • 类MyBeanPostProcessor实现了BeanPostProcessor接口。实现方法postProcessBeforeInitialization、... 在所有的前置通知和后置通知方法中,都是如下图所示,for循环遍历所有的bean,为null就返回结果。
  • jmeter 后置处理器

    千次阅读 2022-01-08 21:11:54
    jmeter 后置处理器
  • 目录 一、生命周期介绍 1.1、什么是Bean的生命周期 1.2、Bean生命周期的过程 (1)实例化阶段 (2)依赖注入阶段 (3)初始化阶段 (4)使用阶段 (5)销毁阶段 二、Bean的后置处理器 2.1、如何使用Bean的后置...
  • Spring后置处理器详解

    千次阅读 2020-06-02 10:53:41
    spring-bean创建的生命周期与后置处理器的调用点 1.第一次调用BeanPostProcess , InstantiationAwareBeanPostProcessor中的postProcessBeforeInstantiation()方法. try { // Give BeanPostProcessors a chance to ...
  • 模板方法设计应用场景
  • JMeter之常用后置处理器: 正则表达式提取器 beanshell后置提取器 JSON 提取器 JMeter之常用断言: 响应断言 BeanShell断言 JSON断言
  • Spring后置处理器总结

    2022-05-24 23:05:09
    用来处理BeanFactory中Bean属性的后置处理器,也就是说在Bean初始化之前,Spirng提供了一个钩子可以让你根据自己的实际情况修改Bean的属性,最常见的应用就是我们的Bean中会有一些占位符,那么在Bean实例化之前这些...
  • 后置处理器算是实现AOP的前提,我们在这篇文章中就将会实现后置处理器后置处理器什么我就不介绍了,不清楚可以参考后置处理器,下面直接开始。 自定义接口 执行bean的初始化方法 创建后置...
  • BeanPostProcessor 接口也被称为后置处理器,通过该接口可以自定义调用初始化前后执行的操作方法。 BeanPostProcessor 接口源码如下: 1. public interface BeanPostProcessor { 2. Object ...
  • spring底层的初始化方法,后置处理器,aop的关系。 在创建容器时,目标文件夹的指定注解类的信息都已经在构造器中加载并保存到集合中, 文件夹中每扫描到一个类都会同时加载对应的后置处理器 ...
  • 后置处理 Bean : BeanPostProcessor的使用 在bean对象初始化之前和之后 (bean从容器中返回给我们之前): 来做某些事情 BeanPostProcessor 作用:对 Spring 工厂所创建的对象,进行再加工。(AOP 的底层实现) 后置...
  • 前置处理器用于请求前的准备工作,后置处理器用于请求发送后对响应信息做处理 前置处理器-取样器超时 用于设定sample的超时时间,如果完成时间过长,此预处理器会调度计时器任务以中断样本 对以下取样器生效:AJP、...
  • 基于Python的数控编程后置处理器设计.pdf
  • Bean的后置处理器

    2021-12-02 12:28:38
    Bean的后置处理器 @Component public class LubanBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws ...
  • 在这篇文章中,将会介绍bean的后置处理器,由于这个涉及到AOP的思想,这里不进行过多的深入,也就是不讲原理(后面文章会手写源码),这里只介绍后置处理器如何使用。 在spring中,后置处理器会在bean初始化化之前和...
  • 探究Spring的后置处理器 文章目录探究Spring的后置处理器流程图prepareRefresh剖析obtainFreshBeanFactory刨析prepareBeanFactory刨析invokeBeanFactoryPostProcessors剖析 本次我们主要探究...
  • spring bean后置处理器

    2019-10-08 23:09:45
    1后置处理器什么? 2 后置处理器实现类 3 后置处理器实现类bean配置 4 运行调用 5多后置处理器调用 1后置处理器什么? 一个类,实现了接口BeanPostProcessor 定义的两个方法,这两个方法分别是:...
  • //为Spring添加后置处理器 ApplicationContextAwareProcessor 实现了BeanProcessor接口 //我们主要查看 重写接口的 postProcessBeforeInitialization ()方法 //主要作用:判断当前bean对象实现了里面的那些接口...
  • 在springboot出现之前,spring一般都是通过读取我们编写的xml文件来创建Bean的,在标签中我们需要定义Bean的类型以及属性等有关于描述Bean的信息,BeanFactory就是通过这些...答案是BeanFactoryPostProcessor后置...
  • 在 xml 解析中我们知道了...而在容器实例化 Bean 之前,可以修改Beandefinition的信息,比如是否延迟加载、加入一些新的 Bean 的定义信息等,其具体实现就是 Bean 工厂的后置处理器BeanFactoryPostProcessor,并且通过...
  • Spring Bean后置处理器解析 一、postProcessBeforeInstantiation 二、determineCandidateConstructors 三、postProcessMergedBeanDefinition 四、getEarlyBeanReference 五、postProcessAfterInstantiation 六...
  • jmeter插件OutputProcessor.jar,后置处理器用于将所需测试数据输出到指定文件夹
  • Spring前置后置处理器
  • Spring BeanFactory后置处理器详解之配置类解析过程BeanFactoryPostProcessor实现方式BeanFactory后置处理器源码分析invokeBeanFactoryPostProcessors分析 BeanFactoryPostProcessor BeanFactoryPostProcessor是...
  • 在Sping的整个生命周期中,有9个地方调用后置处理器。这些后置处理器是spring实现自定义功能或者扩展spring的核心所在 一、postProcessBeforeInitialization 该方法属于InstantiationAwareBeanPostProcessor后置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,371
精华内容 15,748
关键字:

后置处理器是什么