Polish [Standard]TypeLocator

spring-expression/src/main/java/org/springframework/expression/TypeLocator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,8 +18,9 @@ package org.springframework.expression;
 
 /**
  * Implementers of this interface are expected to be able to locate types.
- * They may use a custom {@link ClassLoader} and/or deal with common
- * package prefixes (e.g. {@code java.lang}) however they wish.
+ *
+ * <p>They may use a custom {@link ClassLoader} and/or deal with common package
+ * prefixes (for example, {@code java.lang}) however they wish.
  *
  * <p>See {@link org.springframework.expression.spel.support.StandardTypeLocator}
  * for an example implementation.
@@ -31,8 +32,9 @@ package org.springframework.expression;
 public interface TypeLocator {
 
 	/**
-	 * Find a type by name. The name may or may not be fully qualified
-	 * (e.g. {@code String} or {@code java.lang.String}).
+	 * Find a type by name.
+	 * <p>The name may or may not be fully qualified &mdash; for example,
+	 * {@code String} or {@code java.lang.String}.
 	 * @param typeName the type to be located
 	 * @return the {@code Class} object representing that type
 	 * @throws EvaluationException if there is a problem finding the type

spring-expression/src/main/java/org/springframework/expression/spel/support/StandardTypeLocator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2020 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,12 +28,16 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.ClassUtils;
 
 /**
- * A simple implementation of {@link TypeLocator} that uses the context ClassLoader
- * (or any ClassLoader set upon it). It supports 'well-known' packages: So if a
- * type cannot be found, it will try the registered imports to locate it.
+ * A simple implementation of {@link TypeLocator} that uses the default
+ * {@link ClassLoader} or a supplied {@link ClassLoader} to locate types.
+ *
+ * <p>Supports <em>well-known</em> packages, registered as
+ * {@linkplain #registerImport(String) import prefixes}. If a type cannot be found,
+ * this class will attempt to locate it using the registered import prefixes.
  *
  * @author Andy Clement
  * @author Juergen Hoeller
+ * @author Sam Brannen
  * @since 3.0
  */
 public class StandardTypeLocator implements TypeLocator {
@@ -41,20 +45,21 @@ public class StandardTypeLocator implements TypeLocator {
 	@Nullable
 	private final ClassLoader classLoader;
 
-	private final List<String> knownPackagePrefixes = new ArrayList<>(1);
+	private final List<String> importPrefixes = new ArrayList<>(1);
 
 
 	/**
-	 * Create a StandardTypeLocator for the default ClassLoader
-	 * (typically, the thread context ClassLoader).
+	 * Create a {@code StandardTypeLocator} for the default {@link ClassLoader}
+	 * (typically, the thread context {@code ClassLoader}).
+	 * @see ClassUtils#getDefaultClassLoader()
 	 */
 	public StandardTypeLocator() {
 		this(ClassUtils.getDefaultClassLoader());
 	}
 
 	/**
-	 * Create a StandardTypeLocator for the given ClassLoader.
-	 * @param classLoader the ClassLoader to delegate to
+	 * Create a {@code StandardTypeLocator} for the given {@link ClassLoader}.
+	 * @param classLoader the {@code ClassLoader} to delegate to
 	 */
 	public StandardTypeLocator(@Nullable ClassLoader classLoader) {
 		this.classLoader = classLoader;
@@ -65,49 +70,48 @@ public class StandardTypeLocator implements TypeLocator {
 
 	/**
 	 * Register a new import prefix that will be used when searching for unqualified types.
-	 * Expected format is something like "java.lang".
-	 * @param prefix the prefix to register
+	 * <p>Expected format is something like {@code "java.lang"}.
+	 * @param prefix the import prefix to register
 	 */
 	public void registerImport(String prefix) {
-		this.knownPackagePrefixes.add(prefix);
+		this.importPrefixes.add(prefix);
 	}
 
 	/**
-	 * Remove that specified prefix from this locator's list of imports.
-	 * @param prefix the prefix to remove
+	 * Remove the specified prefix from this locator's list of imports.
+	 * @param prefix the import prefix to remove
 	 */
 	public void removeImport(String prefix) {
-		this.knownPackagePrefixes.remove(prefix);
+		this.importPrefixes.remove(prefix);
 	}
 
 	/**
-	 * Return a list of all the import prefixes registered with this StandardTypeLocator.
-	 * @return a list of registered import prefixes
+	 * Get the list of import prefixes registered with this {@code StandardTypeLocator}.
+	 * @return the list of registered import prefixes
 	 */
 	public List<String> getImportPrefixes() {
-		return Collections.unmodifiableList(this.knownPackagePrefixes);
+		return Collections.unmodifiableList(this.importPrefixes);
 	}
 
 
 	/**
-	 * Find a (possibly unqualified) type reference - first using the type name as-is,
-	 * then trying any registered prefixes if the type name cannot be found.
+	 * Find a (possibly unqualified) type reference, first using the type name as-is,
+	 * and then trying any registered import prefixes if the type name cannot be found.
 	 * @param typeName the type to locate
 	 * @return the class object for the type
 	 * @throws EvaluationException if the type cannot be found
 	 */
 	@Override
 	public Class<?> findType(String typeName) throws EvaluationException {
-		String nameToLookup = typeName;
 		try {
-			return ClassUtils.forName(nameToLookup, this.classLoader);
+			return ClassUtils.forName(typeName, this.classLoader);
 		}
-		catch (ClassNotFoundException ey) {
+		catch (ClassNotFoundException ex) {
 			// try any registered prefixes before giving up
 		}
-		for (String prefix : this.knownPackagePrefixes) {
+		for (String prefix : this.importPrefixes) {
 			try {
-				nameToLookup = prefix + '.' + typeName;
+				String nameToLookup = prefix + '.' + typeName;
 				return ClassUtils.forName(nameToLookup, this.classLoader);
 			}
 			catch (ClassNotFoundException ex) {