Source code
package com.google.common.reflect;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
/**
* Static utilities relating to Java reflection.
*
* @since 12.0
*/
public final class Reflection {
/**
* Returns the package name of {@code clazz} according to the Java Language Specification (section
* 6.7). Unlike {@link Class#getPackage}, this method only parses the class name, without
* attempting to define the {@link Package} and hence load files.
*/
public static String getPackageName(Class<?> clazz) {
return getPackageName(clazz.getName());
}
/**
* Returns the package name of {@code classFullName} according to the Java Language Specification
* (section 6.7). Unlike {@link Class#getPackage}, this method only parses the class name, without
* attempting to define the {@link Package} and hence load files.
*/
public static String getPackageName(String classFullName) {
int lastDot = classFullName.lastIndexOf('.');
return (lastDot < 0) ? "" : classFullName.substring(0, lastDot);
}
/**
* Ensures that the given classes are initialized, as described in <a
* href="http://java.sun.com/docs/books/jls/third_edition/html/execution.html#12.4.2">JLS Section
* 12.4.2</a>.
*
* <p>WARNING: Normally it's a smell if a class needs to be explicitly initialized, because static
* state hurts system maintainability and testability. In cases when you have no choice while
* interoperating with a legacy framework, this method helps to keep the code less ugly.
*
* @throws ExceptionInInitializerError if an exception is thrown during initialization of a class
*/
public static void initialize(Class<?>... classes) {
for (Class<?> clazz : classes) {
try {
Class.forName(clazz.getName(), true, clazz.getClassLoader());
} catch (ClassNotFoundException e) {
throw new AssertionError(e);
}
}
}
/**
* Returns a proxy instance that implements {@code interfaceType} by dispatching method
* invocations to {@code handler}. The class loader of {@code interfaceType} will be used to
* define the proxy class. To implement multiple interfaces or specify a class loader, use {@link
* Proxy#newProxyInstance}.
*
* @throws IllegalArgumentException if {@code interfaceType} does not specify the type of a Java
* interface
*/
public static <T> T newProxy(Class<T> interfaceType, InvocationHandler handler) {
checkNotNull(handler);
checkArgument(interfaceType.isInterface(), "%s is not an interface", interfaceType);
Object object =
Proxy.newProxyInstance(
interfaceType.getClassLoader(), new Class<?>[] {interfaceType}, handler);
return interfaceType.cast(object);
}
private Reflection() {}
}
Run 1
The code is highly readable. It has clear logical organization with a single utility class and well-separated static methods. Nesting is minimal, with only one level inside loops or conditionals. Each method has a clear purpose, supported by concise Javadoc comments that explain intent and edge cases. Code length is appropriate and avoids unnecessary verbosity. Action granularity is excellent — most lines perform a single operation, and line breaks in method calls improve clarity. The reading flow is natural, progressing from simpler to more complex methods, with private constructor at the end. Minor deductions include the slightly dense ternary in getPackageName and the wrapped Proxy.newProxyInstance call, which, while formatted well, still requires careful reading.
Run 2
This code is highly readable. The structure is logical, with clear public methods and a private constructor preventing instantiation. Javadocs are concise and informative, clearly stating purpose and edge cases. Nesting is minimal, limited to a try-catch inside a loop and a single ternary expression. Each method performs a clear, single action. Line length and formatting are consistent with Java standards. The only minor drawback is the slightly long Javadoc for initialize(), but it provides necessary context and warnings. Overall, the code is easy to understand and maintain.
Run 3
The code is exceptionally readable due to its clean, well-structured organization, clear intent, and concise implementation. Each method has a single, focused responsibility, and the use of Javadoc enhances clarity. Nesting is minimal, and actions are generally one per line, contributing to a natural reading flow. The code length is appropriate—no unnecessary verbosity. Only minor points prevent a perfect score: the ternary in getPackageName and the slightly verbose javadoc comments, but these do not materially impact readability.
Run 1
Code Structure: A well-organized utility class with focused methods, adjacent overloads, and a private constructor. Nesting: Minimal; only initialization uses a loop containing try/catch. Clarity of intent: Descriptive method names and detailed Javadoc make behavior and constraints explicit, though the variable name 'object' is generic. Code length: Implementation is concise; documentation is somewhat lengthy but useful. Action granularity: Each statement performs a distinct action, with validation, proxy creation, and casting clearly separated. Reading flow: Methods follow a natural progression, and consistent formatting supports easy scanning. Minor drawbacks include missing spacing between package and import sections and slightly verbose documentation.
Run 2
Code Structure: Well-organized utility class with focused methods, related overloads grouped together, and a private constructor. Nesting: Minimal; only initialization uses a loop with a straightforward try/catch. Clarity of intent: Descriptive method and parameter names, explicit validation, and informative Javadoc make behavior clear. Code length: Implementations are concise; documentation is somewhat lengthy but explains important reflection semantics. Action granularity: Each statement performs a distinct action, with no crowded multi-statement lines. Reading flow: Methods follow natural sequences, including validation, proxy creation, and casting. Minor readability weaknesses include missing spacing between the package and import sections and the generic local name 'object' rather than 'proxy'.
Run 3
Code Structure: A well-organized utility class with small, focused methods and a private constructor. Nesting: Mostly flat; only initialize uses a modest loop with try/catch. Clarity of intent: Descriptive method and parameter names, explicit validation, and informative Javadoc make behavior clear; the local name object is slightly generic. Code length: Implementations are concise, though documentation is comparatively lengthy and partly repetitive. Action granularity: Each statement performs a distinct operation, with readable wrapping of the proxy creation call. Reading flow: Related overloads appear together, and methods proceed naturally from inputs through processing to results. Minor formatting issues, such as missing separation between the package declaration and imports, slightly reduce polish.