public static void main(String[] args){
         ClassPathResource resource = new ClassPathResource("SpringContextConfig.xml");
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(resource);
        MyFactoryBean beanA = (MyFactoryBean)factory.getBean("&fb");
        TestFb beanB = (TestFb)factory.getBean("fb");
        TestFb beanC =beanA.getObject();
        System.out.print(beanB==beanC);
        System.out.print(beanA);
    }

/**专门缓存从FactoryBeans中生成的对象的；除了第一次要getObject()，后面直接从这个mao中取就行了 
 Cache of singleton objects created by FactoryBeans: FactoryBean name --> object */
 private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>(16);
protected Object getObjectForBeanInstance(
   Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
  // 如果name 是&开头的，但是beanInstance又不是FactoryBean类型的就抛出异常
  if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
   throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
  }
  //如果不是FactoryBean 例如name=fb；直接返回
  //如果name是&开头并且FactoryBean类型的例如name=&fb,fb也是FactoryBean类型； 直接返回
  if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
   return beanInstance;
  }
 // beanInstance是FactoryBean类型的并且name不是是以&开头的;例如name=fb 就要走下面的流程
 //beanInstance不是FactoryBean类型并且name
  Object object = null;
  if (mbd == null) {
  //检查之前是否已经生成放入缓存了，如果有 直接返回
   object = getCachedObjectForFactoryBean(beanName);
  }
  if (object == null) {
   // Return bean instance from factory.
   FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
   // 获取合并之后的BeanDefinition
   if (mbd == null && containsBeanDefinition(beanName)) {
    mbd = getMergedLocalBeanDefinition(beanName);
   }
   //TODO....暂时不知道这里是怎么设置的，回头分析
   boolean synthetic = (mbd != null && mbd.isSynthetic());
   /**
   *1.返回FactoryBean.getObject()对象
   *2.执行后置处理器接口的方法BeanPostProcessor中的
   *postProcessAfterInitialization(result, beanName);方法；
   */
   object = getObjectFromFactoryBean(factory, beanName, !synthetic);
  }
  return object;
 }

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry{
 /**
  * 从FactoryBean中获取Bean
  * @param factory the FactoryBean instance
  * @param beanName the name of the bean
  * @param shouldPostProcess whether the bean is subject to post-processing
  * @return the object obtained from the FactoryBean
  * @throws BeanCreationException if FactoryBean object creation failed
  * @see org.springframework.beans.factory.FactoryBean#getObject()
  */
 protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
 //判断factory是单例的并且beanName已经被创建
  if (factory.isSingleton() && containsSingleton(beanName)) {
   synchronized (getSingletonMutex()) {
   //如果已经创建过直接返回
    Object object = this.factoryBeanObjectCache.get(beanName);
    if (object == null) {
     object = doGetObjectFromFactoryBean(factory, beanName);
     // Only post-process and store if not put there already during getObject() call above
     // (e.g. because of circular reference processing triggered by custom getBean calls)
     //TODO....这里回头分析...
     Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
     if (alreadyThere != null) {
      object = alreadyThere;
     }
     else {
      if (object != null && shouldPostProcess) {
       try {
       //执行所有后置处理器接口的方法BeanPostProcessor中的postProcessAfterInitialization(result, beanName);方法；
       //这里单独写一篇文章将后置处理器BeanPostProcessor
        object = postProcessObjectFromFactoryBean(object, beanName);
       }
       catch (Throwable ex) {
        throw new BeanCreationException(beanName,
          "Post-processing of FactoryBean's singleton object failed", ex);
       }
      }
 //将通过factoryBean.getObject方法得到的对象存到 factoryBeanObjectCache中   this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
     }
    }
    return (object != NULL_OBJECT ? object : null);
   }
  }
  else {//如果不是单例对象
  //调用FactoryBean的getObject方法返回实例，也就是从水球里面取出水；
   Object object = doGetObjectFromFactoryBean(factory, beanName);
   if (object != null && shouldPostProcess) {
    try {
    //执行后置处理器
     object = postProcessObjectFromFactoryBean(object, beanName);
    }
    catch (Throwable ex) {
     throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
    }
   }
   return object;
  }
 }
 //调用FactoryBean的getObject放法
 private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
   throws BeanCreationException {
  Object object;
  try {
   if (System.getSecurityManager() != null) {
    AccessControlContext acc = getAccessControlContext();
    try {
     object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
      @Override
      public Object run() throws Exception {
        return factory.getObject();
       }
      }, acc);
    }
    catch (PrivilegedActionException pae) {
     throw pae.getException();
    }
   }
   else {
    //可以看到最终调用了getObject方法；这是需要实现类自己实现
    object = factory.getObject();
   }
  }
  catch (FactoryBeanNotInitializedException ex) {
   throw new BeanCurrentlyInCreationException(beanName, ex.toString());
  }
  catch (Throwable ex) {
   throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
  }
  // Do not accept a null value for a FactoryBean that's not fully
  // initialized yet: Many FactoryBeans just return null then.
  if (object == null && isSingletonCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(
     beanName, "FactoryBean which is currently in creation returned null from getObject");
  }
  return object;
 }