1 files changed, 295 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java b/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
new file mode 100644
index 000000000..fda2fa7f7
--- /dev/null
+++ b/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
@@ -0,0 +1,295 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.lang3.reflect;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Objects;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.ClassUtils;
+
+/**
+ *  Utility reflection methods focused on constructors, modeled after
+ * {@link MethodUtils}.
+ *
+ * <h2>Known Limitations</h2>
+ * <h3>Accessing Public Constructors In A Default Access Superclass</h3>
+ * <p>There is an issue when invoking {@code public} constructors
+ * contained in a default access superclass. Reflection correctly locates these
+ * constructors and assigns them as {@code public}. However, an
+ * {@link IllegalAccessException} is thrown if the constructor is
+ * invoked.</p>
+ *
+ * <p>{@link ConstructorUtils} contains a workaround for this situation: it
+ * will attempt to call {@link java.lang.reflect.AccessibleObject#setAccessible(boolean)} 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 privileges. If this call
+ * fails then a warning will be logged and the method may fail.</p>
+ *
+ * @since 2.5
+ */
+public class ConstructorUtils {
+
+    /**
+     * ConstructorUtils instances should NOT be constructed in standard
+     * programming. Instead, the class should be used as
+     * {@code ConstructorUtils.invokeConstructor(cls, args)}.
+     *
+     * <p>This constructor is {@code public} to permit tools that require a JavaBean
+     * instance to operate.</p>
+     */
+    public ConstructorUtils() {
+    }
+
+    /**
+     * Returns a new instance of the specified class inferring the right constructor
+     * from the types of the arguments.
+     *
+     * <p>This locates and calls a constructor.
+     * The constructor signature must match the argument types by assignment compatibility.</p>
+     *
+     * @param <T> the type to be constructed
+     * @param cls  the class to be constructed, not {@code null}
+     * @param args  the array of arguments, {@code null} treated as empty
+     * @return new instance of {@code cls}, not {@code null}
+     *
+     * @throws NullPointerException if {@code cls} is {@code null}
+     * @throws NoSuchMethodException if a matching constructor cannot be found
+     * @throws IllegalAccessException if invocation is not permitted by security
+     * @throws InvocationTargetException if an error occurs on invocation
+     * @throws InstantiationException if an error occurs on instantiation
+     * @see #invokeConstructor(Class, Object[], Class[])
+     */
+    public static <T> T invokeConstructor(final Class<T> cls, Object... args)
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
+            InstantiationException {
+        args = ArrayUtils.nullToEmpty(args);
+        return invokeConstructor(cls, args, ClassUtils.toClass(args));
+    }
+
+    /**
+     * Returns a new instance of the specified class choosing the right constructor
+     * from the list of parameter types.
+     *
+     * <p>This locates and calls a constructor.
+     * The constructor signature must match the parameter types by assignment compatibility.</p>
+     *
+     * @param <T> the type to be constructed
+     * @param cls  the class to be constructed, not {@code null}
+     * @param args  the array of arguments, {@code null} treated as empty
+     * @param parameterTypes  the array of parameter types, {@code null} treated as empty
+     * @return new instance of {@code cls}, not {@code null}
+     *
+     * @throws NullPointerException if {@code cls} is {@code null}
+     * @throws NoSuchMethodException if a matching constructor cannot be found
+     * @throws IllegalAccessException if invocation is not permitted by security
+     * @throws InvocationTargetException if an error occurs on invocation
+     * @throws InstantiationException if an error occurs on instantiation
+     * @see Constructor#newInstance
+     */
+    public static <T> T invokeConstructor(final Class<T> cls, Object[] args, Class<?>[] parameterTypes)
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
+            InstantiationException {
+        args = ArrayUtils.nullToEmpty(args);
+        parameterTypes = ArrayUtils.nullToEmpty(parameterTypes);
+        final Constructor<T> ctor = getMatchingAccessibleConstructor(cls, parameterTypes);
+        if (ctor == null) {
+            throw new NoSuchMethodException(
+                "No such accessible constructor on object: " + cls.getName());
+        }
+        if (ctor.isVarArgs()) {
+            final Class<?>[] methodParameterTypes = ctor.getParameterTypes();
+            args = MethodUtils.getVarArgs(args, methodParameterTypes);
+        }
+        return ctor.newInstance(args);
+    }
+
+    /**
+     * Returns a new instance of the specified class inferring the right constructor
+     * from the types of the arguments.
+     *
+     * <p>This locates and calls a constructor.
+     * The constructor signature must match the argument types exactly.</p>
+     *
+     * @param <T> the type to be constructed
+     * @param cls the class to be constructed, not {@code null}
+     * @param args the array of arguments, {@code null} treated as empty
+     * @return new instance of {@code cls}, not {@code null}
+     *
+     * @throws NullPointerException if {@code cls} is {@code null}
+     * @throws NoSuchMethodException if a matching constructor cannot be found
+     * @throws IllegalAccessException if invocation is not permitted by security
+     * @throws InvocationTargetException if an error occurs on invocation
+     * @throws InstantiationException if an error occurs on instantiation
+     * @see #invokeExactConstructor(Class, Object[], Class[])
+     */
+    public static <T> T invokeExactConstructor(final Class<T> cls, Object... args)
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
+            InstantiationException {
+        args = ArrayUtils.nullToEmpty(args);
+        return invokeExactConstructor(cls, args, ClassUtils.toClass(args));
+    }
+
+    /**
+     * Returns a new instance of the specified class choosing the right constructor
+     * from the list of parameter types.
+     *
+     * <p>This locates and calls a constructor.
+     * The constructor signature must match the parameter types exactly.</p>
+     *
+     * @param <T> the type to be constructed
+     * @param cls the class to be constructed, not {@code null}
+     * @param args the array of arguments, {@code null} treated as empty
+     * @param parameterTypes  the array of parameter types, {@code null} treated as empty
+     * @return new instance of {@code cls}, not {@code null}
+     *
+     * @throws NullPointerException if {@code cls} is {@code null}
+     * @throws NoSuchMethodException if a matching constructor cannot be found
+     * @throws IllegalAccessException if invocation is not permitted by security
+     * @throws InvocationTargetException if an error occurs on invocation
+     * @throws InstantiationException if an error occurs on instantiation
+     * @see Constructor#newInstance
+     */
+    public static <T> T invokeExactConstructor(final Class<T> cls, Object[] args,
+            Class<?>[] parameterTypes) throws NoSuchMethodException, IllegalAccessException,
+            InvocationTargetException, InstantiationException {
+        args = ArrayUtils.nullToEmpty(args);
+        parameterTypes = ArrayUtils.nullToEmpty(parameterTypes);
+        final Constructor<T> ctor = getAccessibleConstructor(cls, parameterTypes);
+        if (ctor == null) {
+            throw new NoSuchMethodException(
+                "No such accessible constructor on object: "+ cls.getName());
+        }
+        return ctor.newInstance(args);
+    }
+
+    /**
+     * Finds a constructor given a class and signature, checking accessibility.
+     *
+     * <p>This finds the constructor and ensures that it is accessible.
+     * The constructor signature must match the parameter types exactly.</p>
+     *
+     * @param <T> the constructor type
+     * @param cls the class to find a constructor for, not {@code null}
+     * @param parameterTypes the array of parameter types, {@code null} treated as empty
+     * @return the constructor, {@code null} if no matching accessible constructor found
+     * @see Class#getConstructor
+     * @see #getAccessibleConstructor(java.lang.reflect.Constructor)
+     * @throws NullPointerException if {@code cls} is {@code null}
+     */
+    public static <T> Constructor<T> getAccessibleConstructor(final Class<T> cls,
+            final Class<?>... parameterTypes) {
+        Objects.requireNonNull(cls, "cls");
+        try {
+            return getAccessibleConstructor(cls.getConstructor(parameterTypes));
+        } catch (final NoSuchMethodException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Checks if the specified constructor is accessible.
+     *
+     * <p>This simply ensures that the constructor is accessible.</p>
+     *
+     * @param <T> the constructor type
+     * @param ctor  the prototype constructor object, not {@code null}
+     * @return the constructor, {@code null} if no matching accessible constructor found
+     * @see SecurityManager
+     * @throws NullPointerException if {@code ctor} is {@code null}
+     */
+    public static <T> Constructor<T> getAccessibleConstructor(final Constructor<T> ctor) {
+        Objects.requireNonNull(ctor, "ctor");
+        return MemberUtils.isAccessible(ctor)
+                && isAccessible(ctor.getDeclaringClass()) ? ctor : null;
+    }
+
+    /**
+     * Finds an accessible constructor with compatible parameters.
+     *
+     * <p>This checks all the constructor and finds one with compatible parameters
+     * This requires that every parameter is assignable from the given parameter types.
+     * This is a more flexible search than the normal exact matching algorithm.</p>
+     *
+     * <p>First it checks if there is a constructor matching the exact signature.
+     * If not then all the constructors of the class are checked to see if their
+     * signatures are assignment-compatible with the parameter types.
+     * The first assignment-compatible matching constructor is returned.</p>
+     *
+     * @param <T> the constructor type
+     * @param cls  the class to find a constructor for, not {@code null}
+     * @param parameterTypes find method with compatible parameters
+     * @return the constructor, null if no matching accessible constructor found
+     * @throws NullPointerException if {@code cls} is {@code null}
+     */
+    public static <T> Constructor<T> getMatchingAccessibleConstructor(final Class<T> cls,
+            final Class<?>... parameterTypes) {
+        Objects.requireNonNull(cls, "cls");
+        // see if we can find the constructor directly
+        // most of the time this works and it's much faster
+        try {
+            return MemberUtils.setAccessibleWorkaround(cls.getConstructor(parameterTypes));
+        } catch (final NoSuchMethodException ignored) {
+            // ignore
+        }
+        Constructor<T> result = null;
+        /*
+         * (1) Class.getConstructors() is documented to return Constructor<T> so as
+         * long as the array is not subsequently modified, everything's fine.
+         */
+        final Constructor<?>[] ctors = cls.getConstructors();
+
+        // return best match:
+        for (Constructor<?> ctor : ctors) {
+            // compare parameters
+            if (MemberUtils.isMatchingConstructor(ctor, parameterTypes)) {
+                // get accessible version of constructor
+                ctor = getAccessibleConstructor(ctor);
+                if (ctor != null) {
+                    MemberUtils.setAccessibleWorkaround(ctor);
+                    if (result == null || MemberUtils.compareConstructorFit(ctor, result, parameterTypes) < 0) {
+                        // temporary variable for annotation, see comment above (1)
+                        @SuppressWarnings("unchecked")
+                        final Constructor<T> constructor = (Constructor<T>) ctor;
+                        result = constructor;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Tests whether the specified class is generally accessible, i.e. is
+     * declared in an entirely {@code public} manner.
+     * @param type to check
+     * @return {@code true} if {@code type} and any enclosing classes are
+     *         {@code public}.
+     */
+    private static boolean isAccessible(final Class<?> type) {
+        Class<?> cls = type;
+        while (cls != null) {
+            if (!ClassUtils.isPublic(cls)) {
+                return false;
+            }
+            cls = cls.getEnclosingClass();
+        }
+        return true;
+    }
+
+}