【小家Spring】注意BeanPostProcessor启动时对依赖Bean的“误伤”陷阱（is not eligible for getting processed by all...）

@EnableAsync
@Configuration
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 这一步千万不能忘了，否则报错： java.lang.IllegalStateException: ThreadPoolTaskExecutor not initialized
        // 而且最好放在最上面  否则下面set方法对Executor都不会生效
        executor.initialize();

        executor.setCorePoolSize(10); //核心线程数
        executor.setMaxPoolSize(20);  //最大线程数
        executor.setQueueCapacity(1000); //队列大小
        executor.setKeepAliveSeconds(300); //线程最大空闲时间
        executor.setThreadNamePrefix("fsx-Executor-"); ////指定用于新创建的线程名称的前缀。
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略（一共四种，此处省略）
        return executor;
    }

    // 异常处理器：当然你也可以自定义的，这里我就这么简单写了~~~
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

@Service
public class HelloServiceImpl implements HelloService {

	@Async
    @Override
    public Object hello() {
        log.info("当前线程：" + Thread.currentThread().getName());
        return "service hello";
    }
}

16:02:58.520 [fsx-Executor-3] INFO  com.fsx.service.HelloServiceImpl - 当前线程：fsx-Executor-3

@Slf4j
@Component
public class MyBeanPostProcessor implements BeanPostProcessor, Ordered {

    @Autowired
    private ApplicationContext applicationContext;

	// 目的：在此BeanPostProcessor初始化的时候，提前把HelloServiceImpl给初始化掉~
	// 通过这种方式来模拟：我们的BeanProcessor需要依赖业务的service、dao等情况~
    @PostConstruct
    public void init() {
        HelloService helloService = applicationContext.getBean(HelloService.class);
        System.out.println(helloService.getClass());
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

@Slf4j
@Component
public class MyBeanPostProcessor implements BeanPostProcessor, Ordered {

    @Autowired
    private ApplicationContext applicationContext;
    @Autowired
    private HelloService helloService;

    @PostConstruct
    public void init() {
        System.out.println(helloService.getClass());
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

启动输出：
...
o.s.c.s.PostProcessorRegistrationDelegate$BeanPostProcessorChecker - Bean 'helloServiceImpl' of type [com.fsx.service.HelloServiceImpl] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
class com.fsx.service.HelloServiceImpl
...

14:34:50.164 [http-nio-8080-exec-3] INFO  com.fsx.service.HelloServiceImpl - 当前线程：http-nio-8080-exec-3

	public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
	
		// 注意：此处只会拿到Bean的定义信息~~~~
		// 已经被实例化的Bean最终都会调用`beanFactory.addBeanPostProcessor`而缓存在AbstractBeanFactory的字段：beanPostProcessors里，它是个CopyOnWriteArrayList
		// 更重要的是：最终最终所有的BeanPostProcessor的执行都会从这个List里面拿出来执行
		// 所以这一步很关键：那就是按照顺序，把`BeanPostProcessor`们都实例化好，然后添加进List里
		// 因此顺序是关键~~~~~如果某些Bean提前被实例化，它就很有可能不能被所有的`BeanPostProcessor`处理到了
		// 这也是我们BeanPostProcessorChecker的作用，它就是检查这个然后输出日志的~
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);


		// 这个beanProcessorTargetCount此处赋值了，后续就都不会变了，BeanPostProcessorChecker就是和这个进行比较的~
		// beanFactory里面的Bean实例总个数+1（自己）+bean定义信息~
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		// 把BeanPostProcessorChecker加进去，它其实就是做了一个检查而已~~~~~~~输出一个info日志~
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
		
		// 1、找到所有实现PriorityOrdered的`BeanPostProcessor`，然后getBean，然后统一排序，然后beanFactory.addBeanPostProcessor()
		// 2、处理实现Ordered的，步骤同上
		// 3、处理没实现排序接口的普通的处理器，不需要sort了，直接add进去~
	
		// 最后注册一个特殊的处理器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

// 和上面唯一区别是 此处实现的是`PriorityOrdered`接口，上面就是普通的Ordered接口
@Slf4j
@Component
public class MyBeanPostProcessor implements BeanPostProcessor, PriorityOrdered{
	@Autowired
    private ApplicationContext applicationContext;
    ...
}

	private static final class BeanPostProcessorChecker implements BeanPostProcessor {

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

		// 从if条件可以看出哪些是不需要检测的Bean
		// 1、BeanPostProcessor类型不检测
		// 2、ROLE_INFRASTRUCTURE这种类型的Bean不检测 （Spring自己的Bean）
		@Override
		public Object postProcessAfterInitialization(Object bean, String beanName) {
			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);
				return (bd.getRole() == RootBeanDefinition.ROLE_INFRASTRUCTURE);
			}
			return false;
		}
	}

Bean 'XXX' of type [XXXX] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)

o.s.c.s.PostProcessorRegistrationDelegate$BeanPostProcessorChecker - Bean 'asyncConfig' of type [com.config.AsyncConfig$$EnhancerBySpringCGLIB$$d4dbccee] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)

// 在对它（AsyncAnnotationBeanPostProcessor）进行实例化的时候（它是个BeanPostProcessor，所以会根据bean定义进行getBean()）
// 所以就必须先实例化它@Bean所在的类：
@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {
	@Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public AsyncAnnotationBeanPostProcessor asyncAdvisor() { ... }
}

// 然后它的父类`AbstractAsyncConfiguration`里有个@Autowired方法：
@Configuration
public abstract class AbstractAsyncConfiguration implements ImportAware {
	@Autowired(required = false)
	void setConfigurers(Collection<AsyncConfigurer> configurers) { ... }
}
// 这个依赖注入就会去容器内找所有的`AsyncConfigurer`的实现，所以就把`AsyncConfig`给提前实例化了
// 所以打印了那么一句日志，不要感觉到惊奇。这也是为何spring这个checker里使用的日志级别是Info，而不是debug，更不是worn。
// 因为它Spring认为这个debug太轻了，但是warn又太重了，因为绝大部分情况下它都不影响程序的正常work~