public class SimCircular3Ctx {

    private Map<String, BeanDefinition> beanDefinitionMap = new LinkedHashMap<>();

    // 一级缓存，最终完整 bean 对象
    private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    private Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();

    private Map<String, ObjectFactory> factoriesObjects = new ConcurrentHashMap<>();

    public SimCircular3Ctx() throws Exception {
        // 加载 ioc 容器
        refresh();
    }

    private void refresh() throws Exception {
        // 读取 BeanDefinition
        loadBeanDefinitions();

        // 创建 bean
        finishBeanFactoryInitialization();
    }

    private void loadBeanDefinitions() {
        RootBeanDefinition beanDefinition1 = new RootBeanDefinition(AService.class);
        RootBeanDefinition beanDefinition2 = new RootBeanDefinition(BService.class);
        beanDefinitionMap.put("aService", beanDefinition1);
        beanDefinitionMap.put("bService", beanDefinition2);
    }

    private void finishBeanFactoryInitialization() throws Exception {
        for(String beanName : beanDefinitionMap.keySet()){
            getBean(beanName);
        }
    }

    // 方法如果加 synchronized 会有性能问题，因此有了二级缓存
    public Object getBean(String beanName) throws Exception {
        // 1 获取
        Object bean = getSingleton(beanName);
        if(Objects.nonNull(bean)){
            return bean;
        }
        synchronized (singletonObjects){
            bean = getSingleton(beanName);
            if(Objects.nonNull(bean)){
                return bean;
            }
        }
        // 2 创建
        // 2.1 实例化
        RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
        Class<?> beanClass = beanDefinition.getBeanClass();
        Object beanInstance = beanClass.getConstructor().newInstance();

        // put 到三级缓存
        // 预期只有循环依赖的 bean 才进行动态代理，普通的 bean 依然在初始化后才去创建动态代理
        factoriesObjects.put(beanName, () -> new JdkProxyBeanPostProcessor().getEarlyBeanReference(beanInstance, beanName));

        // 2.2 依赖注入 @Autowired
        for(Field declaredField : beanClass.getDeclaredFields()){
            if(declaredField.getAnnotation(Autowired.class) != null){
                String name = declaredField.getName();

                // bytype byname
                Object dependBean = getBean(name);

                declaredField.setAccessible(true);
                declaredField.set(beanInstance, dependBean);
            }
        }

        // 2.3 初始化 aop

        // 3 put 到一级缓存
        singletonObjects.put(beanName, beanInstance);
        earlySingletonObjects.remove(beanName);
        return beanInstance;
    }

    private Object getSingleton(String beanName) {
        if(singletonObjects.containsKey(beanName)){
            return singletonObjects.get(beanName);
        }
        // spring 源码锁的都是 singletonObjects
        synchronized (singletonObjects){
            if(earlySingletonObjects.containsKey(beanName)){
                return earlySingletonObjects.get(beanName);
            }
            if(factoriesObjects.containsKey(beanName)){
                ObjectFactory objectFactory = factoriesObjects.get(beanName);
                Object aopObject = objectFactory.getObject();
                // 存二级缓存，防止循环依赖多次执行 ObjectFactory
                earlySingletonObjects.put(beanName, aopObject);
                return aopObject;
            }
        }
        return null;
    }

}

// AbstractPlatformTransactionManager
public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
  private TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled) throws TransactionException {
    SuspendedResourcesHolder suspendedResources = this.suspend(transaction);

    try {
        return this.startTransaction(definition, transaction, debugEnabled, suspendedResources);
    } catch (Error | RuntimeException beginEx) {
        this.resumeAfterBeginException(transaction, suspendedResources, beginEx);
        throw beginEx;
    }
  }

  protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        List<TransactionSynchronization> suspendedSynchronizations = this.doSuspendSynchronization();

        try {
            Object suspendedResources = null;
            if (transaction != null) {
              // ThreadLocal 解绑 
              suspendedResources = this.doSuspend(transaction);
            }

            String name = TransactionSynchronizationManager.getCurrentTransactionName();
            TransactionSynchronizationManager.setCurrentTransactionName((String)null);
            boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
            TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
            Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
            TransactionSynchronizationManager.setCurrentTransactionIsolationLevel((Integer)null);
            boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
            TransactionSynchronizationManager.setActualTransactionActive(false);
            return new SuspendedResourcesHolder(suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
        } catch (Error | RuntimeException ex) {
            this.doResumeSynchronization(suspendedSynchronizations);
            throw ex;
        }
    } else if (transaction != null) {
        Object suspendedResources = this.doSuspend(transaction);
        return new SuspendedResourcesHolder(suspendedResources);
    } else {
        return null;
    }
  }

  private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
      boolean newSynchronization = this.getTransactionSynchronization() != 2;
      // suspendedResources 保存下来，当前事务提交后，会重置使用它
      DefaultTransactionStatus status = this.newTransactionStatus(definition, transaction, true,
       newSynchronization, debugEnabled, suspendedResources);
      this.doBegin(transaction, definition);
      this.prepareSynchronization(status, definition);
      return status;
  }
}

// DataSourceTransactionManager
public class DataSourceTransactionManager extends AbstractPlatformTransactionManager implements ResourceTransactionManager, InitializingBean {
  protected Object doSuspend(Object transaction) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject)transaction;
      txObject.setConnectionHolder((ConnectionHolder)null);
      return TransactionSynchronizationManager.unbindResource(this.obtainDataSource());
  }
}

// TransactionSynchronizationManager
public abstract class TransactionSynchronizationManager {
  public static Object unbindResource(Object key) throws IllegalStateException {
      Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
      Object value = doUnbindResource(actualKey);
      if (value == null) {
          throw new IllegalStateException("No value for key [" + actualKey + "] bound to thread");
      } else {
          return value;
      }
  }
}

// AbstractPlatformTransactionManager,执行后，挂起点设置回来
public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
  private void processCommit(DefaultTransactionStatus status) throws TransactionException {
    try {

    } finally {
        this.cleanupAfterCompletion(status);
    }
  }

  private void cleanupAfterCompletion(DefaultTransactionStatus status) {
      status.setCompleted();
      if (status.isNewSynchronization()) {
          TransactionSynchronizationManager.clear();
      }

      if (status.isNewTransaction()) {
          this.doCleanupAfterCompletion(status.getTransaction());
      }

      if (status.getSuspendedResources() != null) {
          if (status.isDebug()) {
              this.logger.debug("Resuming suspended transaction after completion of inner transaction");
          }

          // 挂起点恢复
          Object transaction = status.hasTransaction() ? status.getTransaction() : null;
          this.resume(transaction, (SuspendedResourcesHolder)status.getSuspendedResources());
      }
    }
}

public abstract class TransactionSynchronizationManager {
    // key 为 datasource,value 为 ConnectionHolder
    // Why Map? 如一个线程同时连 Mysql、Oracle 等场景。
    private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal("Transactional resources");
}

@Service
public class CityServiceImpl implements CityService {

    @Autowired
    private CityMapper cityMapper;

    @Transactional
    @Override
    public void insertCity() {
        City city = new City();
        city.setName("长沙1");
        city.setAge(200);

        cityMapper.insertCity(city);

        SpringUtil.getBean(CityService.class).insertCity2();

        // 此时测试，insertCity2 执行未回滚，但是事务1回滚了
        throw new RuntimeException("xxx");
    }

    /**
     * 模拟单线程有2个不同的事务
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insertCity2() {
        City city = new City();
        city.setName("长沙2");
        city.setAge(200);

        cityMapper.insertCity(city);
    }

}