Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

move/comment SuppressWarnings(unchecked)/refactor surrounding code 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@983709 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Matthew Jason Benson 2010-08-09 16:20:54 +00:00
parent 2f66e0fdf8
commit e51c8d6cfb
1 changed files with 94 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
View File

@ -24,20 +24,22 @@ import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.ClassUtils;
/**
* <p> Utility reflection methods focussed on constructors, modelled after {@link MethodUtils}. </p>
*
* <h3>Known Limitations</h3>
* <h4>Accessing Public Constructors In A Default Access Superclass</h4>
* <p>There is an issue when invoking public constructors contained in a default access superclass.
* Reflection locates these constructors fine and correctly assigns them as public.
* However, an <code>IllegalAccessException</code> is thrown if the constructors is invoked.</p>
*
* <p><code>ConstructorUtils</code> contains a workaround for this situation.
* It will attempt to call <code>setAccessible</code> on this constructor.
* If this call succeeds, then the method can be invoked as normal.
* This call will only succeed when the application has sufficient security privilages.
* If this call fails then a warning will be logged and the method may fail.</p>
*
* <p> Utility reflection methods focussed on constructors, modelled after
* {@link MethodUtils}. </p>
*
* <h3>Known Limitations</h3> <h4>Accessing Public Constructors In A Default
* Access Superclass</h4> <p>There is an issue when invoking public constructors
* contained in a default access superclass. Reflection locates these
* constructors fine and correctly assigns them as public. However, an
* <code>IllegalAccessException</code> is thrown if the constructors is
* invoked.</p>
*
* <p><code>ConstructorUtils</code> contains a workaround for this situation. It
* will attempt to call <code>setAccessible</code> on this constructor. If this
* call succeeds, then the method can be invoked as normal. This call will only
* succeed when the application has sufficient security privilages. If this call
* fails then a warning will be logged and the method may fail.</p>
*
* @author Apache Software Foundation
* @author Craig R. McClanahan
* @author Ralph Schaer
@ -53,10 +55,10 @@ import org.apache.commons.lang3.ClassUtils;
public class ConstructorUtils {
/**
* <p>ConstructorUtils instances should NOT be constructed in standard programming.
* Instead, the class should be used as
* <p>ConstructorUtils instances should NOT be constructed in standard
* programming. Instead, the class should be used as
* <code>ConstructorUtils.invokeConstructor(cls, args)</code>.</p>
*
*
* <p>This constructor is public to permit tools that require a JavaBean
* instance to operate.</p>
*/
@ -65,26 +67,31 @@ public class ConstructorUtils {
}
/**
* <p>Returns new instance of <code>klazz</code> created using the actual arguments <code>args</code>.
* The formal parameter types are inferred from the actual values of <code>args</code>.
* See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
*
* <p>Returns new instance of <code>klazz</code> created using the actual
* arguments <code>args</code>. The formal parameter types are inferred from
* the actual values of <code>args</code>. See
* {@link #invokeExactConstructor(Class, Object[], Class[])} for more
* details.</p>
*
* <p>The signatures should be assignment compatible.</p>
*
*
* @param cls the class to be constructed.
* @param args actual argument array
* @return new instance of <code>klazz</code>
*
*
* @throws NoSuchMethodException If the constructor cannot be found
* @throws IllegalAccessException If an error occurs accessing the constructor
* @throws InvocationTargetException If an error occurs invoking the constructor
* @throws IllegalAccessException If an error occurs accessing the
* constructor
* @throws InvocationTargetException If an error occurs invoking the
* constructor
* @throws InstantiationException If an error occurs instantiating the class
*
* @see #invokeConstructor(java.lang.Class, java.lang.Object[], java.lang.Class[])
*
* @see #invokeConstructor(java.lang.Class, java.lang.Object[],
* java.lang.Class[])
*/
public static <T> T invokeConstructor(Class<T> cls, Object... args)
throws NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
InstantiationException {
if (null == args) {
args = ArrayUtils.EMPTY_OBJECT_ARRAY;
}
@ -97,24 +104,24 @@ public class ConstructorUtils {
/**
* <p>Returns new instance of <code>klazz</code> created using constructor
* with signature <code>parameterTypes</code> and actual arguments <code>args</code>.</p>
*
* with signature <code>parameterTypes</code> and actual arguments
* <code>args</code>.</p>
*
* <p>The signatures should be assignment compatible.</p>
*
*
* @param cls the class to be constructed.
* @param args actual argument array
* @param parameterTypes parameter types array
* @return new instance of <code>klazz</code>
*
*
* @throws NoSuchMethodException if matching constructor cannot be found
* @throws IllegalAccessException thrown on the constructor's invocation
* @throws InvocationTargetException thrown on the constructor's invocation
* @throws InstantiationException thrown on the constructor's invocation
* @see Constructor#newInstance
*/
public static <T> T invokeConstructor(Class<T> cls, Object[] args,
Class<?>[] parameterTypes) throws NoSuchMethodException,
IllegalAccessException, InvocationTargetException,
public static <T> T invokeConstructor(Class<T> cls, Object[] args, Class<?>[] parameterTypes)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
InstantiationException {
if (parameterTypes == null) {
parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
@ -124,34 +131,38 @@ public class ConstructorUtils {
}
Constructor<T> ctor = getMatchingAccessibleConstructor(cls, parameterTypes);
if (null == ctor) {
throw new NoSuchMethodException(
"No such accessible constructor on object: "
+ cls.getName());
throw new NoSuchMethodException("No such accessible constructor on object: "
+ cls.getName());
}
return ctor.newInstance(args);
}
/**
* <p>Returns new instance of <code>klazz</code> created using the actual arguments <code>args</code>.
* The formal parameter types are inferred from the actual values of <code>args</code>.
* See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
*
* <p>Returns new instance of <code>klazz</code> created using the actual
* arguments <code>args</code>. The formal parameter types are inferred from
* the actual values of <code>args</code>. See
* {@link #invokeExactConstructor(Class, Object[], Class[])} for more
* details.</p>
*
* <p>The signatures should match exactly.</p>
*
*
* @param cls the class to be constructed.
* @param args actual argument array
* @return new instance of <code>klazz</code>
*
*
* @throws NoSuchMethodException If the constructor cannot be found
* @throws IllegalAccessException If an error occurs accessing the constructor
* @throws InvocationTargetException If an error occurs invoking the constructor
* @throws IllegalAccessException If an error occurs accessing the
* constructor
* @throws InvocationTargetException If an error occurs invoking the
* constructor
* @throws InstantiationException If an error occurs instantiating the class
*
* @see #invokeExactConstructor(java.lang.Class, java.lang.Object[], java.lang.Class[])
*
* @see #invokeExactConstructor(java.lang.Class, java.lang.Object[],
* java.lang.Class[])
*/
public static <T> T invokeExactConstructor(Class<T> cls, Object... args)
throws NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
InstantiationException {
if (null == args) {
args = ArrayUtils.EMPTY_OBJECT_ARRAY;
}
@ -167,14 +178,14 @@ public class ConstructorUtils {
* <p>Returns new instance of <code>klazz</code> created using constructor
* with signature <code>parameterTypes</code> and actual arguments
* <code>args</code>.</p>
*
*
* <p>The signatures should match exactly.</p>
*
*
* @param cls the class to be constructed.
* @param args actual argument array
* @param parameterTypes parameter types array
* @return new instance of <code>klazz</code>
*
*
* @throws NoSuchMethodException if matching constructor cannot be found
* @throws IllegalAccessException thrown on the constructor's invocation
* @throws InvocationTargetException thrown on the constructor's invocation
@ -182,9 +193,8 @@ public class ConstructorUtils {
* @see Constructor#newInstance
*/
public static <T> T invokeExactConstructor(Class<T> cls, Object[] args,
Class<?>[] parameterTypes) throws NoSuchMethodException,
IllegalAccessException, InvocationTargetException,
InstantiationException {
Class<?>[] parameterTypes) throws NoSuchMethodException, IllegalAccessException,
InvocationTargetException, InstantiationException {
if (args == null) {
args = ArrayUtils.EMPTY_OBJECT_ARRAY;
}
@ -193,9 +203,8 @@ public class ConstructorUtils {
}
Constructor<T> ctor = getAccessibleConstructor(cls, parameterTypes);
if (null == ctor) {
throw new NoSuchMethodException(
"No such accessible constructor on object: "
+ cls.getName());
throw new NoSuchMethodException("No such accessible constructor on object: "
+ cls.getName());
}
return ctor.newInstance(args);
}
@ -225,24 +234,24 @@ public class ConstructorUtils {
*/
public static <T> Constructor<T> getAccessibleConstructor(Constructor<T> ctor) {
return MemberUtils.isAccessible(ctor)
&& Modifier.isPublic(ctor.getDeclaringClass().getModifiers()) ? ctor
: null;
&& Modifier.isPublic(ctor.getDeclaringClass().getModifiers()) ? ctor : null;
}
/**
* <p>Find an accessible constructor with compatible parameters.
* Compatible parameters mean that every method parameter is assignable from
* the given parameters. In other words, it finds constructor that will take
* the parameters given.</p>
*
* <p>Find an accessible constructor with compatible parameters. Compatible
* parameters mean that every method parameter is assignable from the given
* parameters. In other words, it finds constructor that will take the
* parameters given.</p>
*
* <p>First it checks if there is constructor matching the exact signature.
* If no such, all the constructors of the class are tested if their signatures
* are assignment compatible with the parameter types.
* The first matching constructor is returned.</p>
*
* If no such, all the constructors of the class are tested if their
* signatures are assignment compatible with the parameter types. The first
* matching constructor is returned.</p>
*
* @param cls find constructor for this class
* @param parameterTypes find method with compatible parameters
* @return a valid Constructor object. If there's no matching constructor, returns <code>null</code>.
* @return a valid Constructor object. If there's no matching constructor,
* returns <code>null</code>.
*/
public static <T> Constructor<T> getMatchingAccessibleConstructor(Class<T> cls,
Class<?>... parameterTypes) {
@ -255,20 +264,23 @@ public class ConstructorUtils {
} catch (NoSuchMethodException e) { /* SWALLOW */
}
Constructor<T> result = null;
// search through all constructors
Constructor<?>[] ctors = cls.getConstructors();
for (int i = 0; i < ctors.length; i++) {
/*
* Class.getConstructors() is documented to return Constructor<T> so as
* long as the array is not subsequently modified, everything's fine:
*/
@SuppressWarnings("unchecked")
Constructor<T>[] ctors = (Constructor<T>[]) cls.getConstructors();
// return best match:
for (Constructor<T> ctor : ctors) {
// compare parameters
if (ClassUtils.isAssignable(parameterTypes, ctors[i]
.getParameterTypes(), true)) {
// get accessible version of method
@SuppressWarnings("unchecked") // TODO is this OK? If so, why?
Constructor<T> ctor = getAccessibleConstructor((Constructor<T>) ctors[i]);
if (ClassUtils.isAssignable(parameterTypes, ctor.getParameterTypes(), true)) {
// get accessible version of constructor
ctor = getAccessibleConstructor(ctor);
if (ctor != null) {
MemberUtils.setAccessibleWorkaround(ctor);
if (result == null
|| MemberUtils.compareParameterTypes(ctor
.getParameterTypes(), result
|| MemberUtils.compareParameterTypes(ctor.getParameterTypes(), result
.getParameterTypes(), parameterTypes) < 0) {
result = ctor;
}