1、AliasRegistry(别名注册中心[接口])

public interface AliasRegistry {
    /**
	 * 对指定的名称name注册别名alias
	 */
    void registerAlias(String name, String alias);
    
    /**
	 * 从当前容器移除指定别名
	 */
    void removeAlias(String alias);

    /**
	 * 判断指定名称是否为别名
	 */
    boolean isAlias(String beanName);

    /**
	 * 返回指定名称的所有别名
	 */
    String[] getAliases(String name);

}

2、SimpleAliasRegistry(简单的别名注册中心[类])

SimpleAliasRegistry有一个属性aliasMap，是一个ConcurrentHashMap，用来存放bean的别名。

public class SimpleAliasRegistry implements AliasRegistry {

	/** Logger available to subclasses. */
	protected final Log logger = LogFactory.getLog(getClass());

	/** Map from alias to canonical name. */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);


	@Override
	public void registerAlias(String name, String alias) {
        // 断言两个参数必须含有有效字符串
		Assert.hasText(name, "'name' must not be empty");
		Assert.hasText(alias, "'alias' must not be empty");
		synchronized (this.aliasMap) {
            // 如果别名和名称相同，则移除这个别名。
			if (alias.equals(name)) {
				this.aliasMap.remove(alias);
				if (logger.isDebugEnabled()) {
					logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
				}
			}
			else {
				String registeredName = this.aliasMap.get(alias);
				if (registeredName != null) {
                    // 如果该别名对应的已注册的name和传入的name相同，则不需重复注册.直接返回。
					if (registeredName.equals(name)) {
						// An existing alias - no need to re-register
						return;
					}
					if (!allowAliasOverriding()) {
						throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
								name + "': It is already registered for name '" + registeredName + "'.");
					}
					if (logger.isDebugEnabled()) {
						logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
								registeredName + "' with new target name '" + name + "'");
					}
				}
				checkForAliasCircle(name, alias);
				this.aliasMap.put(alias, name);
				if (logger.isTraceEnabled()) {
					logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
				}
			}
		}
	}

	/**
	 * Determine whether alias overriding is allowed.
	 * <p>Default is {@code true}.
	 */
	protected boolean allowAliasOverriding() {
		return true;
	}

	/**
	 * 确定给定bean名称，是否已经注册过给定别名name。
	 * @param name 是bean的别名
	 * @param alias 是bean的名字
	 * @since 4.2.1
	 */
	public boolean hasAlias(String name, String alias) {
        //获取别名
		String registeredName = this.aliasMap.get(alias);
		return ObjectUtils.nullSafeEquals(registeredName, name) || (registeredName != null
				&& hasAlias(name, registeredName));
	}

	@Override
	public void removeAlias(String alias) {
		synchronized (this.aliasMap) {
			String name = this.aliasMap.remove(alias);
			if (name == null) {
				throw new IllegalStateException("No alias '" + alias + "' registered");
			}
		}
	}

	@Override
	public boolean isAlias(String name) {
		return this.aliasMap.containsKey(name);
	}
    
	//获取自定name的所有别名。
	@Override
	public String[] getAliases(String name) {
		List<String> result = new ArrayList<>();
		synchronized (this.aliasMap) {
			retrieveAliases(name, result);
		}
		return StringUtils.toStringArray(result);
	}

	/**
	 * 获取自定name的所有别名。
	 * @param name the target name to find aliases for
	 * @param result the resulting aliases list
	 */
	private void retrieveAliases(String name, List<String> result) {
		this.aliasMap.forEach((alias, registeredName) -> {
			if (registeredName.equals(name)) {
				result.add(alias);
				retrieveAliases(alias, result);
			}
		});
	}

	/**
	 * Resolve all alias target names and aliases registered in this
	 * registry, applying the given {@link StringValueResolver} to them.
	 * <p>The value resolver may for example resolve placeholders
	 * in target bean names and even in alias names.
	 * @param valueResolver the StringValueResolver to apply
	 */
	public void resolveAliases(StringValueResolver valueResolver) {
		Assert.notNull(valueResolver, "StringValueResolver must not be null");
        // 先锁住内部的Map，因为CurrentHashMap只有put和remove是线程安全的
		synchronized (this.aliasMap) {
			Map<String, String> aliasCopy = new HashMap<>(this.aliasMap);
			aliasCopy.forEach((alias, registeredName) -> {
				String resolvedAlias = valueResolver.resolveStringValue(alias);
				String resolvedName = valueResolver.resolveStringValue(registeredName);
                // 如果解析后的别名或者resolvedName为空或者是别名与resolvedName相同，则移除。
				if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) {
					this.aliasMap.remove(alias);
				}
				else if (!resolvedAlias.equals(alias)) {
					String existingName = this.aliasMap.get(resolvedAlias);
					if (existingName != null) {
						if (existingName.equals(resolvedName)) {
							// 再次处理，如果相同则移除
							this.aliasMap.remove(alias);
							return;
						}
						throw new IllegalStateException(
								"Cannot register resolved alias '" + resolvedAlias + "' (original: '" + alias +
								"') for name '" + resolvedName + "': It is already registered for name '" +
								registeredName + "'.");
					}
                    //确定给定bean名称，是否已经注册过给定别名name。如果注册过，抛异常：IllegalStateException
					checkForAliasCircle(resolvedName, resolvedAlias);
                    // 则检查完循环引用后map中删除原始别名。
					this.aliasMap.remove(alias);
                    // 添加解析后的别名
					this.aliasMap.put(resolvedAlias, resolvedName);
				}
				else if (!registeredName.equals(resolvedName)) {
					this.aliasMap.put(alias, resolvedName);
				}
			});
		}
	}

	/**
	 * Check whether the given name points back to the given alias as an alias
	 * in the other direction already, catching a circular reference upfront
	 * and throwing a corresponding IllegalStateException.
	 * @param name the candidate name
	 * @param alias the candidate alias
	 * @see #registerAlias
	 * @see #hasAlias
	 */
	protected void checkForAliasCircle(String name, String alias) {
		if (hasAlias(alias, name)) {
			throw new IllegalStateException("Cannot register alias '" + alias +
					"' for name '" + name + "': Circular reference - '" +
					name + "' is a direct or indirect alias for '" + alias + "' already");
		}
	}

	/**
	 * 根据给定的name获取对应bean的名称。
	 */
	public String canonicalName(String name) {
		String canonicalName = name;
		// Handle aliasing...
		String resolvedName;
		do {
			resolvedName = this.aliasMap.get(canonicalName);
			if (resolvedName != null) {
				canonicalName = resolvedName;
			}
		}
		while (resolvedName != null);
		return canonicalName;
	}

}

3、SingletonBeanRegistry(单例bean注册中心[接口])

public interface SingletonBeanRegistry {
	/**
	 * 在给定的bean名称下，在bean注册中心中将给定的现有对象注册为singleton。
	 */
	void registerSingleton(String beanName, Object singletonObject);

	/**
	 * 返回在给定名称下注册的（原始）单例bean实例。
	 */
	@Nullable
	Object getSingleton(String beanName);

	/**
	 * 检查此注册表是否包含具有给定名称的单例实例。
	 */
	boolean containsSingleton(String beanName);

	/**
	 * 返回在此注册表中注册的单例bean的名称数组。
	 */
	String[] getSingletonNames();

	/**
	 * 返回在此注册表中注册的单例bean的数量。
	 */
	int getSingletonCount();

	/**
	 * 返回此注册表使用的单例互斥锁。
	 * @since 4.2
	 */
	Object getSingletonMutex();
}

4、DefaultSingletonBeanRegistry(默认单例bean注册中心)