diff --git a/spring-expression/src/main/java/org/springframework/expression/TypeLocator.java b/spring-expression/src/main/java/org/springframework/expression/TypeLocator.java index ec1c531bb5..91ef19ed0c 100644 --- a/spring-expression/src/main/java/org/springframework/expression/TypeLocator.java +++ b/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. + * + *

They may use a custom {@link ClassLoader} and/or deal with common package + * prefixes (for example, {@code java.lang}) however they wish. * *

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. + *

The name may or may not be fully qualified — 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 diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/support/StandardTypeLocator.java b/spring-expression/src/main/java/org/springframework/expression/spel/support/StandardTypeLocator.java index dafb615271..aa6ada780b 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/support/StandardTypeLocator.java +++ b/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. + * + *

Supports well-known 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 knownPackagePrefixes = new ArrayList<>(1); + private final List 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 + *

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 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) {