BeanPostProcessor是spring的bean后置处理器，这个接口定义了两个方法分别在bean的初始化前、初始化后执行。

InstantiationAwareBeanPostProcessor继承自BeanPostProcessor，添加了两个方法，这两个方法分别在bean的实例化前、实例化后执行。

SmartInstantiationAwareBeanPostProcessor又继承自InstantiationAwareBeanPostProcessor，添加了几个方法，其中有个方法是：

default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {return bean;}

在AbstractAutowireCapableBeanFactory的doCreateBean()方法中，在对bean实例化以后填充属性之前（一般称为早起对象），会将其放入第三级缓存

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException {BeanWrapper instanceWrapper = null;//省略其他代码……//从beanWrapper中获取我们的早期对象（实例化后的对象）final Object bean = instanceWrapper.getWrappedInstance();//省略其他代码……//缓存单例到三级缓存中，以防循环依赖		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));//上述条件满足，允许中期暴露对象if (earlySingletonExposure) {//把我们的早期对象包装成一个singletonFactory对象 该对象提供了一个getObject方法,该方法内部调用getEarlyBeanReference方法addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}//省略其他代码……}

由上边代码可见，早起对象放入缓存时，是包装成ObjectFactory然后放入其中：

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

 addSingletonFactory()方法：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");//同步加锁synchronized (this.singletonObjects) {//单例缓存池中没有包含当前的beanif (!this.singletonObjects.containsKey(beanName)) {//加入到三级缓存中，，，，，暴露早期对象用于解决循环依赖this.singletonFactories.put(beanName, singletonFactory);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}}

 getEarlyBeanReference()方法：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {Object exposedObject = bean;//判读我们容器中是否有InstantiationAwareBeanPostProcessors类型的后置处理器if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {//获取我们所有的后置处理器for (BeanPostProcessor bp : getBeanPostProcessors()) {//判断我们的后置处理器是不是实现了SmartInstantiationAwareBeanPostProcessor接口if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {//进行强制转换SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;//挨个调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReferenceexposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);}}}return exposedObject;}

可见该方法被调用时，会调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference()方法。

 AbstractAutoProxyCreator是SmartInstantiationAwareBeanPostProcessor的实现类之一，其重写了getEarlyBeanReference方法：

@Overridepublic Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {Object cacheKey = getCacheKey(bean.getClass(), beanName);this.earlyProxyReferences.put(cacheKey, bean);return wrapIfNecessary(bean, beanName, cacheKey);}

wrapIfNecessary()方法：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {//已经被处理过（解析切面时targetSourcedBeans出现过） 就是自己实现创建动态代理逻辑if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {return bean;}//不需要增强的if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {return bean;}//是不是基础的bean 是不是需要跳过的 重复判断 （ 因为循环依赖是可以改变bean的，如果把bean改成了advisor呢）if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {this.advisedBeans.put(cacheKey, Boolean.FALSE);return bean;}// 根据当前bean找到匹配的advisorObject[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);// 当前bean匹配到了advisorif (specificInterceptors != DO_NOT_PROXY) {// 标记为已处理this.advisedBeans.put(cacheKey, Boolean.TRUE);//创建我们的真正的代理对象Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));//加入到缓存this.proxyTypes.put(cacheKey, proxy.getClass());return proxy;}this.advisedBeans.put(cacheKey, Boolean.FALSE);return bean;}

可见，其和动态代理有关。