/**
 * 实现此接口的类应能够定位类型。它们可以使用自定义的 {@link ClassLoader}，
 * 和/或以任何方式处理常见的包前缀（例如 {@code java.lang}）。
 *
 * <p>参见 {@link org.springframework.expression.spel.support.StandardTypeLocator}
 * 以获取示例实现。
 *
 * @author Andy Clement
 * @since 3.0
 */
@FunctionalInterface
public interface TypeLocator {

	/**
	 * 根据名称查找类型。名称可以是完全限定的，也可以不是（例如 {@code String} 或 {@code java.lang.String}）。
	 * @param typeName 要定位的类型
	 * @return 表示该类型的 {@code Class} 对象
	 * @throws EvaluationException 如果查找类型时出现问题
	 */
	Class<?> findType(String typeName) throws EvaluationException;

}

/**
 * 一个简单的 {@link TypeLocator} 实现，它使用上下文 ClassLoader（或设置在其上的任何 ClassLoader）。
 * 它支持'well-known'包：如果找不到类型，则会尝试注册的导入来定位它。
 * 
 * @author Andy Clement
 * @author Juergen Hoeller
 * @since 3.0
 */
public class StandardTypeLocator implements TypeLocator {

    @Nullable
    private final ClassLoader classLoader;

    private final List<String> knownPackagePrefixes = new ArrayList<>(1);

    /**
     * 为默认的 ClassLoader（通常是线程上下文 ClassLoader）创建一个 StandardTypeLocator。
     */
    public StandardTypeLocator() {
        this(ClassUtils.getDefaultClassLoader());
    }

    /**
     * 为给定的 ClassLoader 创建一个 StandardTypeLocator。
     * @param classLoader 要委托的 ClassLoader
     */
    public StandardTypeLocator(@Nullable ClassLoader classLoader) {
        this.classLoader = classLoader;
        // 类似于编写常规的 Java 代码，默认只知道 java.lang
        registerImport("java.lang");
    }

    /**
     * 注册一个新的导入前缀，用于搜索未限定类型时使用。
     * 期望的格式类似于 "java.lang"。
     * @param prefix 要注册的前缀
     */
    public void registerImport(String prefix) {
        this.knownPackagePrefixes.add(prefix);
    }

    /**
     * 从此定位器的导入列表中删除指定的前缀。
     * @param prefix 要移除的前缀
     */
    public void removeImport(String prefix) {
        this.knownPackagePrefixes.remove(prefix);
    }

    /**
     * 返回此 StandardTypeLocator 注册的所有导入前缀的列表。
     * @return 注册的导入前缀列表
     */
    public List<String> getImportPrefixes() {
        return Collections.unmodifiableList(this.knownPackagePrefixes);
    }

    /**
     * 查找（可能是未限定的）类型引用 - 首先使用原始类型名称，然后如果找不到类型名称，则尝试任何注册的前缀。
     * @param typeName 要定位的类型
     * @return 类型的 Class 对象
     * @throws EvaluationException 如果找不到类型
     */
    @Override
    public Class<?> findType(String typeName) throws EvaluationException {
        String nameToLookup = typeName;
        try {
            return ClassUtils.forName(nameToLookup, this.classLoader);
        }
        catch (ClassNotFoundException ey) {
            // 在放弃之前尝试任何已注册的前缀
        }
        for (String prefix : this.knownPackagePrefixes) {
            try {
                nameToLookup = prefix + '.' + typeName;
                return ClassUtils.forName(nameToLookup, this.classLoader);
            }
            catch (ClassNotFoundException ex) {
                // 可能是另一个前缀
            }
        }
        throw new SpelEvaluationException(SpelMessage.TYPE_NOT_FOUND, typeName);
    }
}

public class TypeLocatorDemo {
    public static void main(String[] args) {
        // 创建一个SpEL表达式解析器
        ExpressionParser parser = new SpelExpressionParser();

        // 解析表达式获取 Date 类的 Class 对象
        Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class);
        System.out.println("dateClass = " + dateClass);

        // 解析表达式获取 String 类的 Class 对象
        Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);
        System.out.println("stringClass = " + stringClass);

        // 解析表达式比较两个 RoundingMode 枚举值的大小
        boolean trueValue = parser.parseExpression("T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR").getValue(Boolean.class);
        System.out.println("trueValue = " + trueValue);
    }
}

dateClass = class java.util.Date
stringClass = class java.lang.String
trueValue = true