jmeter后置处理器
作用
当给一个请求添加后置处理器时，那么可以将前一个请求的响应结果传给后一个请求
使用场景
后一个请求需要前一个请求的响应中的结果作为参数时
实施步骤


新建测试计划，添加线程组等


在加入后置处理器之前先查看前一个请求的响应数据：
提取响应数据，方便后面后置处理器使用



在请求1中添加后置处理器，如正则表达式处理器，配置如下：



在后一个请求中，输入变量作为参数：

到了这一步，就使得前一个请求的响应结果中的某个数据通过后置处理器传给了后一个请求

BeanPostProcessor【interface】：bean的后置处理器；
在bean初始化前后进行一些处理工作；spring底层大量使用；


postProcessBeforeInitialization：在初始化之前工作


postProcessAfterInitialization：在初始化之后工作


可以作为Bean初始化前后的回调方法；
//后置处理器：初始化前后进行处理工作
//将后置处理器加入到容器中
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

	//在初始化之前工作
    //Object bean: 可以对Bean进行再一次封装，也可以直接返回
    //String beanName: Bean的名称
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
		return bean;
	}

	//在初始化之后工作
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
		return bean;
	}
}

BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的

1、BeanFactoryPostProcessor：BeanFactory的后置处理器；

            在BeanFactory标准初始化之后调用；所有的bean定义已经保存加载到BeanFactory，但是bean的实例还没创建；

    BeanFactoryPostProcessor原理：

    1.1 ioc容器创建对象

    1.2 invokeBeanFactoryPostProcessors(BeanFactory); 执行BeanFactoryPostProcessor;

        如何找到所有的BeanFactoryPostProcessor并执行他们的方法；

            1.2.1 直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法

            1.2.2 在初始化创建其他组件前面执行

2、BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor

        postProcessBeanDefinitionRegistry();

        在所有bean定义信息将要被加载，bean实例还未创建的；

        优先于BeanFactoryPostProcessor执行；

        利用BeanDefinitionRegistryPostProcessor给容器中在额外添加一些组件；

    原理：

        2.1、ioc创建对象

        2.2、refresh()->invokeBeanFactoryPostProcessors(beanFactory);

        2.3、从容器中获取到的BeanDefinitionRegistryPostProcessor组件。

            2.3.1 依次触发所有的postProcessBeanDefinitionRegistry()方法

            2.3.2 再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor；

        2.4、再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法

3、ApplicationListener：监听容器中发布的事件。事件驱动模型开发；

    public interface ApplicationListener<E extends ApplicationEvent>

        监听ApplicationEvent 及其下面的子事件；

步骤：

    1、写一个监听器来监听某个事件（ApplicationEvent及其子类）

    2、把监听器加入到容器；

    3、只要容器中有相关事件的发布，我们就能监听到这个事件；

            ContextRefreshedEvent：容器刷新完成（所有bean都完全创建）会发布这个事件；

            ContextClosedEvent：关闭容器会发布这个事件；

    4、发布一个事件；

            applicationContext.publishEvent()；

原理：

    ContextRefreshedEvent、IOCTest_Ext$1[source=自己的事件！！]、ContextClosedEvent；

1、ContextRefreshedEvent事件：

    1.1 容器创建对象：refresh();

    1.2 finishRefresh();容器刷新完成会发布ContextRefreshedEvent

    1.3 publishEvent(new ContextRefreshedEvent(this));【事件发布流程】

                1.3.1 获取事件的多波器（派发器）：getApplicationEventMulticaster()

                1.3.2 MulticasterEvent派发事件：

                1.3.3 获取到所有的ApplicationListener

                        for(final ApplicationListener<?> listener : getApplicationListeners(event, type))

                        1.3.3.1 如果有Executor，可以支持使用Executor进行异步派发；

                                Executor executor = getTaskExecutor();

                        1.3.3.2 否则，同步的方式直接执行listener方法；invokeListener(listener, event);

                                拿到listener回调onApplicationEvent方法；    

2、发布自己的事件；

3、容器关闭会发布ContextClosedEvent

【事件多波器（派发器）】

    1、容器创建对象：refresh();

    2、initApplicationEventMulticaster();初始化ApplicationEventMulticaster；

        2.1 先去容器中找到有没有id="applicationEventMultcaster"的组件；

        2.2 如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);

            并且加入到容器中，我们就可以在其他组件要派发事件，自动注入这个applicationEventMulticaster；

【容器中有哪些监听器】

    1、容器创建对象：refresh();

    2、registerListeners();

    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);

    //将listener注册到ApplicationEventMulticaster中

    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

 

 

package com.spring.ext;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import com.spring.bean.Red;


@ComponentScan("com.spring.ext")
@Configuration
public class ExtConfig {
	
	@Bean
	public Red blue() {
		return new Red();
	}
	
}

package com.spring.ext;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent>{

	public void onApplicationEvent(ApplicationEvent event) {
		System.out.println("event>>>>>>>>"+event);
	}
	
}


package com.spring.ext;

import java.util.Arrays;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("MyBeanFactoryPostProcessor ... postProcessBeanFactory beansize="+beanFactory.getBeanDefinitionCount());
		int count = beanFactory.getBeanDefinitionCount();
		String[] names = beanFactory.getBeanDefinitionNames();
		System.out.println("当前BeanFactory中有"+count+"个Bean");
		System.out.println(Arrays.toString(names));
		
	}

}


package com.spring.ext;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

import com.spring.bean.Red;

@Component
public class MyBenaDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("MyBenaDefinitionRegistryPostProcessor ..beansize ="+beanFactory.getBeanDefinitionCount());
		
	}

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

		System.out.println(">>>>>postProcessBeanDefinitionRegistry>>>beansize="+registry.getBeanDefinitionCount());
		AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Red.class).getBeanDefinition();
		registry.registerBeanDefinition("hello", beanDefinition);
	}
	

}


package com.spring.ext;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Service;

@Service
public class UserService {
	
	@EventListener(classes= {ApplicationEvent.class})
	public void listener(ApplicationEvent event) {
		System.out.println("自己监听><>>>>>>"+event);
	}
	
}

package com.spring.test;

import org.junit.Test;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.spring.ext.ExtConfig;

public class IOCTestOfExt {
	@Test
	public void test01() {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ExtConfig.class);
		
		applicationContext.publishEvent(new ApplicationEvent("自己的事件！！") {
		});
		
		applicationContext.close();
	}

}

 

在idea中搜索了一下Spring的后置处理器（PostProcessor），找出了下图的几个


本文主要来分析红框中标出的两个，也就是在 refresh() 方法的第5步调用的后置处理器
1、后置处理器调用的时机
2、后置处理器调用的顺序
3、一个最重要的后置处理器
这个最重要的后置处理器就是 ConfigurationClassPostProcessor
1、ConfigurationClassPostProcessor的作用？
2、
4、案例读源码
（1）案例1
（2）案例2
（3）案例3
Spring Cloud中的案例一个，大家对Spring Cloud不熟悉没有关系，只需要关注Spring Framework部分就可以了
下面的代码是个 org.springframework.cloud.netflix.feign.ribbon包下的一个配置类（@Configuration），大家忽略Spring Cloud，就把它看做就是一个普通的配置类
@Configuration
class DefaultFeignLoadBalancedConfiguration {
	@Beand
	@ConditionalOnMissingBean
	public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
							  SpringClientFactory clientFactory) {
		return new LoadBalancerFeignClient(new Client.Default(null, null),
				cachingFactory, clientFactory);
	}
}

下面启动时，我们在下面的方法上打上条件断点：org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass


调用栈如下
loadBeanDefinitionsForConfigurationClass:140, ConfigurationClassBeanDefinitionReader (o.s.context.annotation)
loadBeanDefinitions:116, ConfigurationClassBeanDefinitionReader (o.s.context.annotation)
processConfigBeanDefinitions:320, ConfigurationClassPostProcessor (o.s.context.annotation)
postProcessBeanDefinitionRegistry:228, ConfigurationClassPostProcessor (o.s.context.annotation)
invokeBeanDefinitionRegistryPostProcessors:272, PostProcessorRegistrationDelegate (o.s.context.support)
invokeBeanFactoryPostProcessors:92, PostProcessorRegistrationDelegate (o.s.context.support)
invokeBeanFactoryPostProcessors:687, AbstractApplicationContext (o.s.context.support)
refresh:525, AbstractApplicationContext (o.s.context.support)
refresh:122, EmbeddedWebApplicationContext (o.s.boot.context.embedded)
refresh:693, SpringApplication (o.s.boot)
refreshContext:360, SpringApplication (o.s.boot)
run:303, SpringApplication (o.s.boot)
run:1118, SpringApplication (o.s.boot)
run:1107, SpringApplication (o.s.boot)
main:21, AppBMain (com.yh.stu)

几种注册BD的方式
1、硬编码

通过BeanDefinitionRegistry.registerBeanDefinition硬编码的方式进行注册，通常的做法有：

1、Spring 本身在实例化AnnotationConfigApplicationContext时，根据环境情况硬编码注册4~7个BD
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
	...
	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, Object source) {
	...
	// 共注册了6个BD,即使通过
	RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
	def.setSource(source);
	beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	...
}
private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

	definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	registry.registerBeanDefinition(beanName, definition);
	return new BeanDefinitionHolder(definition, beanName);
}

我这里列出几个大家有个印象，后续用到这几个BD的时候知道怎么来的就可以了。
// 实现了两个接口：BeanDefinitionRegistryPostProcessor/BeanFactoryPostProcessor
1：org.springframework.context.annotation.ConfigurationClassPostProcessor 
// 实现了BeanPostProcessor、BeanFactoryAware、PriorityOrdered接口
2：org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor 
// 同2一样，实现了BeanPostProcessor、BeanFactoryAware、PriorityOrdered接口
3：org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor
// 同2一样，实现了BeanPostProcessor、BeanFactoryAware、PriorityOrdered接口
4：org.springframework.context.annotation.CommonAnnotationBeanPostProcessor 
// 实现了SmartInitializingSingleton, ApplicationContextAware 接口
5：org.springframework.context.event.EventListenerMethodProcessor 

6：org.springframework.context.event.DefaultEventListenerFactory 

❓ 1-这些Spring内部的 Bean是什么时候实例化的呢？

❓ 2-自定义的 BeanFacotryPostProcessor 是什么时候实例化的呢？
答1：

（1）、内部BeanFacotryPostProcessor 是在其被调用的时候利用容器（beanFactory.getBean(…)）进行实例化的。

（和普通的Bean不一样，普通的Bean都是在refresh的第11阶段，即在finishBeanFactoryInitialization(beanFactory)方法中进行的）
//org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors){
	...
	// 从容器中找出所有 BeanDefinitionRegistryPostProcessor 类型的BD，后续按照顺序实例化并调用（PriorityOrdered/Ordered）
	String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
	for (String ppName : postProcessorNames) {
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			// 使用getBean来实例化Bean
			currentRegistryProcessors.add(
				beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
			processedBeans.add(ppName);
		}
	}
	...
}

（2）、AutowiredAnnotationBeanPostProcessor 是在 refresh的第 6 阶段，即在registerBeanPostProcessors(beanFactory)方法中实例化的
//org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	// 从容器中找出所有 BeanPostProcessor 类型的BD，后续按照顺序调用（PriorityOrdered/Ordered）
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
	...
	//遍历到 org.springframework.context.annotation.internalAutowiredAnnotationProcessor
	for (String ppName : postProcessorNames) {
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			// 使用getBean来实例化Bean
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		}
		...
	}

（3）同2一样

（4）同2一样

（5）EventListenerMethodProcessor 类的实例化时在refresh() 方法的第 11 阶段，即finishBeanFactoryInitialization(beanFactory) 方法中将其作为普通的Bean进行实例化
2、在容器中配置

Spring中配置Bean，在调用后置处理器 Configuration