List of usage examples for java.lang.reflect Constructor getParameterTypes
@Override
public Class<?>[] getParameterTypes()
From source file:org.jvnet.hudson.test.JenkinsRule.java
/** * Works like {@link #assertEqualBeans(Object, Object, String)} but figure out the properties * via {@link org.kohsuke.stapler.DataBoundConstructor} */// w ww . java2 s.c om public void assertEqualDataBoundBeans(Object lhs, Object rhs) throws Exception { if (lhs == null && rhs == null) return; if (lhs == null) fail("lhs is null while rhs=" + rhs); if (rhs == null) fail("rhs is null while lhs=" + lhs); Constructor<?> lc = findDataBoundConstructor(lhs.getClass()); Constructor<?> rc = findDataBoundConstructor(rhs.getClass()); assertThat("Data bound constructor mismatch. Different type?", (Constructor) rc, is((Constructor) lc)); List<String> primitiveProperties = new ArrayList<String>(); String[] names = ClassDescriptor.loadParameterNames(lc); Class<?>[] types = lc.getParameterTypes(); assertThat(types.length, is(names.length)); for (int i = 0; i < types.length; i++) { Object lv = ReflectionUtils.getPublicProperty(lhs, names[i]); Object rv = ReflectionUtils.getPublicProperty(rhs, names[i]); if (lv != null && rv != null && Iterable.class.isAssignableFrom(types[i])) { Iterable lcol = (Iterable) lv; Iterable rcol = (Iterable) rv; Iterator ltr, rtr; for (ltr = lcol.iterator(), rtr = rcol.iterator(); ltr.hasNext() && rtr.hasNext();) { Object litem = ltr.next(); Object ritem = rtr.next(); if (findDataBoundConstructor(litem.getClass()) != null) { assertEqualDataBoundBeans(litem, ritem); } else { assertThat(ritem, is(litem)); } } assertThat("collection size mismatch between " + lhs + " and " + rhs, ltr.hasNext() ^ rtr.hasNext(), is(false)); } else if (findDataBoundConstructor(types[i]) != null || (lv != null && findDataBoundConstructor(lv.getClass()) != null) || (rv != null && findDataBoundConstructor(rv.getClass()) != null)) { // recurse into nested databound objects assertEqualDataBoundBeans(lv, rv); } else { primitiveProperties.add(names[i]); } } // compare shallow primitive properties if (!primitiveProperties.isEmpty()) assertEqualBeans(lhs, rhs, Util.join(primitiveProperties, ",")); }
From source file:org.fornax.cartridges.sculptor.smartclient.server.ScServlet.java
private Object makeNewInstance(Class expectedClass, HashMap<String, Object> jsData) throws ApplicationException { Object val = null; try {// w ww . j a va 2 s . co m Constructor[] constructors = expectedClass.getConstructors(); for (int k = 0; k < constructors.length; k++) { Constructor constructor = constructors[k]; Annotation[][] constrAnnot = constructor.getParameterAnnotations(); String[] paramNames = new String[constrAnnot.length]; int annotCount = 0; for (int i = 0; i < constrAnnot.length; i++) { Annotation[] annotations = constrAnnot[i]; for (int j = 0; j < annotations.length; j++) { Annotation annotation = annotations[j]; if (annotation instanceof Name) { paramNames[i] = ((Name) annotation).value(); paramNames[i] = paramNames[i].startsWith("xxx") ? paramNames[i].substring(3) : paramNames[i]; annotCount++; break; } } } if (annotCount != constrAnnot.length) { continue; } Object[] params = prepareMethodParam(jsData, false, paramNames, constructor.getParameterTypes()); if (params != null) { val = constructor.newInstance(params); break; } } if (val == null) { throw new Exception("Can't create instance of class " + expectedClass.getName()); } } catch (Exception ex) { throw new ApplicationException(ex.getMessage(), "ERR9001", ex); } return val; }
From source file:org.apache.solr.core.SolrCore.java
private UpdateHandler createReloadedUpdateHandler(String className, String msg, UpdateHandler updateHandler) { Class<? extends UpdateHandler> clazz = null; if (msg == null) msg = "SolrCore Object"; try {/*w ww . j a v a 2 s.co m*/ clazz = getResourceLoader().findClass(className, UpdateHandler.class); //most of the classes do not have constructors which takes SolrCore argument. It is recommended to obtain SolrCore by implementing SolrCoreAware. // So invariably always it will cause a NoSuchMethodException. So iterate though the list of available constructors Constructor<?>[] cons = clazz.getConstructors(); for (Constructor<?> con : cons) { Class<?>[] types = con.getParameterTypes(); if (types.length == 2 && types[0] == SolrCore.class && types[1] == UpdateHandler.class) { return UpdateHandler.class.cast(con.newInstance(this, updateHandler)); } } throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Error Instantiating " + msg + ", " + className + " could not find proper constructor for " + UpdateHandler.class.getName()); } catch (SolrException e) { throw e; } catch (Exception e) { // The JVM likes to wrap our helpful SolrExceptions in things like // "InvocationTargetException" that have no useful getMessage if (null != e.getCause() && e.getCause() instanceof SolrException) { SolrException inner = (SolrException) e.getCause(); throw inner; } throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Error Instantiating " + msg + ", " + className + " failed to instantiate " + UpdateHandler.class.getName(), e); } }
From source file:org.apache.hadoop.hive.ql.exec.vector.VectorizationContext.java
private VectorExpression instantiateExpression(Class<?> vclass, TypeInfo returnType, Object... args) throws HiveException { VectorExpression ve = null;//from w w w. jav a2 s.co m Constructor<?> ctor = getConstructor(vclass); int numParams = ctor.getParameterTypes().length; int argsLength = (args == null) ? 0 : args.length; if (numParams == 0) { try { ve = (VectorExpression) ctor.newInstance(); } catch (Exception ex) { throw new HiveException("Could not instantiate " + vclass.getSimpleName() + " with 0 arguments, exception: " + getStackTraceAsSingleLine(ex)); } } else if (numParams == argsLength) { try { ve = (VectorExpression) ctor.newInstance(args); } catch (Exception ex) { throw new HiveException("Could not instantiate " + vclass.getSimpleName() + " with " + getNewInstanceArgumentString(args) + ", exception: " + getStackTraceAsSingleLine(ex)); } } else if (numParams == argsLength + 1) { // Additional argument is needed, which is the outputcolumn. Object[] newArgs = null; try { String returnTypeName; if (returnType == null) { returnTypeName = ((VectorExpression) vclass.newInstance()).getOutputType().toLowerCase(); if (returnTypeName.equals("long")) { returnTypeName = "bigint"; } returnType = TypeInfoUtils.getTypeInfoFromTypeString(returnTypeName); } else { returnTypeName = returnType.getTypeName(); } // Special handling for decimal because decimal types need scale and precision parameter. // This special handling should be avoided by using returnType uniformly for all cases. int outputCol = ocm.allocateOutputColumn(returnType); newArgs = Arrays.copyOf(args, numParams); newArgs[numParams - 1] = outputCol; ve = (VectorExpression) ctor.newInstance(newArgs); ve.setOutputType(returnTypeName); } catch (Exception ex) { throw new HiveException("Could not instantiate " + vclass.getSimpleName() + " with arguments " + getNewInstanceArgumentString(newArgs) + ", exception: " + getStackTraceAsSingleLine(ex)); } } // Add maxLength parameter to UDFs that have CHAR or VARCHAR output. if (ve instanceof TruncStringOutput) { TruncStringOutput truncStringOutput = (TruncStringOutput) ve; if (returnType instanceof BaseCharTypeInfo) { BaseCharTypeInfo baseCharTypeInfo = (BaseCharTypeInfo) returnType; truncStringOutput.setMaxLength(baseCharTypeInfo.getLength()); } } return ve; }
From source file:ca.oson.json.Oson.java
<T> T newInstance(Map<String, Object> map, Class<T> valueType) {
InstanceCreator creator = getTypeAdapter(valueType);
if (creator != null) {
return (T) creator.createInstance(valueType);
}/*w ww. ja v a 2s . c om*/
T obj = null;
if (valueType != null) {
obj = (T) getDefaultValue(valueType);
if (obj != null) {
return obj;
}
}
if (map == null) {
return null;
}
// @JsonTypeInfo(use = JsonTypeInfo.Id.MINIMAL_CLASS, include = As.PROPERTY, property = "@class")
//@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = As.PROPERTY, property = "@class")
String JsonClassType = null;
if (valueType != null) {
if (getAnnotationSupport()) {
for (Annotation annotation : valueType.getAnnotations()) {
if (annotation instanceof JsonTypeInfo) {
JsonTypeInfo jsonTypeInfo = (JsonTypeInfo) annotation;
JsonTypeInfo.Id use = jsonTypeInfo.use();
JsonTypeInfo.As as = jsonTypeInfo.include();
if ((use == JsonTypeInfo.Id.MINIMAL_CLASS || use == JsonTypeInfo.Id.CLASS)
&& as == As.PROPERTY) {
JsonClassType = jsonTypeInfo.property();
}
}
}
}
}
if (JsonClassType == null) {
JsonClassType = getJsonClassType();
}
String className = null;
if (map.containsKey(JsonClassType)) {
className = map.get(JsonClassType).toString();
}
Class<T> classType = getClassType(className);
// && (valueType == null || valueType.isAssignableFrom(classType) || Map.class.isAssignableFrom(valueType))
if (classType != null) {
valueType = classType;
}
if (valueType == null) {
return (T) map; // or null, which is better?
}
Constructor<?>[] constructors = null;
Class implClass = null;
if (valueType.isInterface() || Modifier.isAbstract(valueType.getModifiers())) {
implClass = DeSerializerUtil.implementingClass(valueType.getName());
}
if (implClass != null) {
constructors = implClass.getDeclaredConstructors();
} else {
constructors = valueType.getDeclaredConstructors();//.getConstructors();
}
Object singleMapValue = null;
Class singleMapValueType = null;
if (map.size() == 1) {
singleMapValue = map.get(valueType.getName());
if (singleMapValue != null) {
singleMapValueType = singleMapValue.getClass();
if (singleMapValueType == String.class) {
singleMapValue = StringUtil.unquote(singleMapValue.toString(), isEscapeHtml());
}
try {
if (valueType == Locale.class) {
Constructor constructor = null;
String[] parts = ((String) singleMapValue).split("_");
if (parts.length == 1) {
constructor = valueType.getConstructor(String.class);
constructor.setAccessible(true);
obj = (T) constructor.newInstance(singleMapValue);
} else if (parts.length == 2) {
constructor = valueType.getConstructor(String.class, String.class);
constructor.setAccessible(true);
obj = (T) constructor.newInstance(parts);
} else if (parts.length == 3) {
constructor = valueType.getConstructor(String.class, String.class, String.class);
constructor.setAccessible(true);
obj = (T) constructor.newInstance(parts);
}
if (obj != null) {
return obj;
}
}
} catch (Exception e) {
}
Map<Class, Constructor> cmaps = new HashMap<>();
for (Constructor constructor : constructors) {
//Class[] parameterTypes = constructor.getParameterTypes();
int parameterCount = constructor.getParameterCount();
if (parameterCount == 1) {
Class[] types = constructor.getParameterTypes();
cmaps.put(types[0], constructor);
}
}
if (cmaps.size() > 0) {
Constructor constructor = null;
if ((cmaps.containsKey(Boolean.class) || cmaps.containsKey(boolean.class))
&& BooleanUtil.isBoolean(singleMapValue.toString())) {
constructor = cmaps.get(Boolean.class);
if (constructor == null) {
constructor = cmaps.get(boolean.class);
}
if (constructor != null) {
try {
constructor.setAccessible(true);
obj = (T) constructor
.newInstance(BooleanUtil.string2Boolean(singleMapValue.toString()));
if (obj != null) {
return obj;
}
} catch (Exception e) {
}
}
} else if (StringUtil.isNumeric(singleMapValue.toString())) {
Class[] classes = new Class[] { int.class, Integer.class, long.class, Long.class,
double.class, Double.class, Byte.class, byte.class, Short.class, short.class,
Float.class, float.class, BigDecimal.class, BigInteger.class, AtomicInteger.class,
AtomicLong.class, Number.class };
for (Class cls : classes) {
constructor = cmaps.get(cls);
if (constructor != null) {
try {
obj = (T) constructor.newInstance(NumberUtil.getNumber(singleMapValue, cls));
if (obj != null) {
return obj;
}
} catch (Exception e) {
}
}
}
} else if (StringUtil.isArrayOrList(singleMapValue.toString())
|| singleMapValue.getClass().isArray()
|| Collection.class.isAssignableFrom(singleMapValue.getClass())) {
for (Entry<Class, Constructor> entry : cmaps.entrySet()) {
Class cls = entry.getKey();
constructor = entry.getValue();
if (cls.isArray() || Collection.class.isAssignableFrom(cls)) {
Object listObject = null;
if (singleMapValue instanceof String) {
JSONArray objArray = new JSONArray(singleMapValue.toString());
listObject = (List) fromJsonMap(objArray);
} else {
listObject = singleMapValue;
}
FieldData objectDTO = new FieldData(listObject, cls, true);
listObject = json2Object(objectDTO);
if (listObject != null) {
try {
obj = (T) constructor.newInstance(listObject);
if (obj != null) {
return obj;
}
} catch (Exception e) {
}
}
}
}
}
for (Entry<Class, Constructor> entry : cmaps.entrySet()) {
Class cls = entry.getKey();
constructor = entry.getValue();
try {
obj = (T) constructor.newInstance(singleMapValue);
if (obj != null) {
return obj;
}
} catch (Exception e) {
}
}
}
}
}
if (implClass != null) {
valueType = implClass;
}
try {
obj = valueType.newInstance();
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue, singleMapValueType);
}
} catch (InstantiationException | IllegalAccessException e) {
//e.printStackTrace();
}
///*
for (Constructor constructor : constructors) {
//Class[] parameterTypes = constructor.getParameterTypes();
int parameterCount = constructor.getParameterCount();
if (parameterCount > 0) {
constructor.setAccessible(true);
Annotation[] annotations = constructor.getDeclaredAnnotations(); // getAnnotations();
for (Annotation annotation : annotations) {
boolean isJsonCreator = false;
if (annotation instanceof JsonCreator) {
isJsonCreator = true;
} else if (annotation instanceof ca.oson.json.annotation.FieldMapper) {
ca.oson.json.annotation.FieldMapper fieldMapper = (ca.oson.json.annotation.FieldMapper) annotation;
if (fieldMapper.jsonCreator() == BOOLEAN.TRUE) {
isJsonCreator = true;
}
}
if (isJsonCreator) {
Parameter[] parameters = constructor.getParameters();
String[] parameterNames = ObjectUtil.getParameterNames(parameters);
//parameterCount = parameters.length;
Object[] parameterValues = new Object[parameterCount];
int i = 0;
for (String parameterName : parameterNames) {
parameterValues[i] = getParameterValue(map, valueType, parameterName,
parameters[i].getType());
i++;
}
try {
obj = (T) constructor.newInstance(parameterValues);
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue, singleMapValueType);
}
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
//e.printStackTrace();
}
}
}
} else {
try {
constructor.setAccessible(true);
obj = (T) constructor.newInstance();
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue, singleMapValueType);
}
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
//e.printStackTrace();
}
}
}
//*/
// try again
for (Constructor constructor : constructors) {
int parameterCount = constructor.getParameterCount();
if (parameterCount > 0) {
constructor.setAccessible(true);
try {
List<String> parameterNames = ObjectUtil.getParameterNames(constructor);
if (parameterNames != null && parameterNames.size() > 0) {
Class[] parameterTypes = constructor.getParameterTypes();
int length = parameterTypes.length;
if (length == parameterNames.size()) {
Object[] parameterValues = new Object[length];
Object parameterValue;
for (int i = 0; i < length; i++) {
parameterValues[i] = getParameterValue(map, valueType, parameterNames.get(i),
parameterTypes[i]);
}
try {
obj = (T) constructor.newInstance(parameterValues);
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue, singleMapValueType);
}
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
//e.printStackTrace();
}
}
}
} catch (IOException e1) {
// e1.printStackTrace();
}
}
}
// try more
for (Constructor constructor : constructors) {
int parameterCount = constructor.getParameterCount();
if (parameterCount > 0) {
constructor.setAccessible(true);
Class[] parameterTypes = constructor.getParameterTypes();
List<String> parameterNames;
try {
parameterNames = ObjectUtil.getParameterNames(constructor);
if (parameterNames != null) {
int length = parameterTypes.length;
if (length > parameterNames.size()) {
length = parameterNames.size();
}
Object[] parameterValues = new Object[length];
for (int i = 0; i < length; i++) {
parameterValues[i] = getParameterValue(map, valueType, parameterNames.get(i),
parameterTypes[i]);
}
obj = (T) constructor.newInstance(parameterValues);
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue, singleMapValueType);
}
}
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException | IOException e) {
//e.printStackTrace();
}
}
}
// try more
try {
Method[] methods = valueType.getMethods(); // .getMethod("getInstance", null);
List<Method> methodList = new ArrayList<>();
if (methods != null) {
for (Method method : methods) {
String methodName = method.getName();
if (methodName.equals("getInstance") || methodName.equals("newInstance")
|| methodName.equals("createInstance") || methodName.equals("factory")) {
Class returnType = method.getReturnType();
if (valueType.isAssignableFrom(returnType) && Modifier.isStatic(method.getModifiers())) {
int parameterCount = method.getParameterCount();
if (parameterCount == 0) {
try {
obj = ObjectUtil.getMethodValue(null, method);
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue,
singleMapValueType);
}
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
//e.printStackTrace();
}
} else {
methodList.add(method);
}
}
}
}
for (Method method : methodList) {
try {
int parameterCount = method.getParameterCount();
Object[] parameterValues = new Object[parameterCount];
Object parameterValue;
int i = 0;
Class[] parameterTypes = method.getParameterTypes();
String[] parameterNames = ObjectUtil.getParameterNames(method);
if (parameterCount == 1 && valueType != null && singleMapValue != null
&& singleMapValueType != null) {
if (ObjectUtil.isSameDataType(parameterTypes[0], singleMapValueType)) {
try {
obj = ObjectUtil.getMethodValue(null, method, singleMapValue);
if (obj != null) {
return obj;
}
} catch (IllegalArgumentException ex) {
//ex.printStackTrace();
}
}
} else if (parameterNames != null && parameterNames.length == parameterCount) {
for (String parameterName : ObjectUtil.getParameterNames(method)) {
parameterValues[i] = getParameterValue(map, valueType, parameterName,
parameterTypes[i]);
i++;
}
} else {
// try annotation
Parameter[] parameters = method.getParameters();
parameterNames = ObjectUtil.getParameterNames(parameters);
parameterCount = parameters.length;
parameterValues = new Object[parameterCount];
i = 0;
for (String parameterName : parameterNames) {
parameterValues[i] = getParameterValue(map, valueType, parameterName,
parameterTypes[i]);
i++;
}
}
obj = ObjectUtil.getMethodValue(null, method, parameterValues);
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue, singleMapValueType);
}
} catch (IOException | IllegalArgumentException e) {
//e.printStackTrace();
}
}
}
} catch (SecurityException e) {
// e.printStackTrace();
}
// try all static methods, if the return type is correct, get it as the final object
Method[] methods = valueType.getDeclaredMethods();
for (Method method : methods) {
if (Modifier.isStatic(method.getModifiers())) {
Class returnType = method.getReturnType();
if (valueType.isAssignableFrom(returnType)) {
try {
Object[] parameterValues = null;
int parameterCount = method.getParameterCount();
if (parameterCount > 0) {
if (parameterCount == 1 && map.size() == 1 && singleMapValue != null
&& singleMapValueType != null) {
if (ObjectUtil.isSameDataType(method.getParameterTypes()[0], singleMapValueType)) {
obj = ObjectUtil.getMethodValue(null, method, singleMapValueType);
if (obj != null) {
return obj;
}
}
}
parameterValues = new Object[parameterCount];
Object parameterValue;
int i = 0;
Class[] parameterTypes = method.getParameterTypes();
String[] parameterNames = ObjectUtil.getParameterNames(method);
if (parameterNames != null && parameterNames.length == parameterCount) {
for (String parameterName : ObjectUtil.getParameterNames(method)) {
parameterValues[i] = getParameterValue(map, valueType, parameterName,
parameterTypes[i]);
i++;
}
} else {
// try annotation
Parameter[] parameters = method.getParameters();
parameterNames = ObjectUtil.getParameterNames(parameters);
parameterCount = parameters.length;
parameterValues = new Object[parameterCount];
i = 0;
for (String parameterName : parameterNames) {
parameterValues[i] = getParameterValue(map, valueType, parameterName,
parameterTypes[i]);
i++;
}
}
}
obj = ObjectUtil.getMethodValue(obj, method, parameterValues);
if (obj != null) {
return setSingleMapValue(obj, valueType, singleMapValue, singleMapValueType);
}
} catch (IOException | IllegalArgumentException e) {
//e.printStackTrace();
}
}
}
}
return null;
}
From source file:com.clark.func.Functions.java
/** * <p>/*from w w w. jav a 2 s.co m*/ * 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> * * @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>. */ @SuppressWarnings("unchecked") public static <T> Constructor<T> getMatchingAccessibleConstructor(Class<T> cls, Class<?>... parameterTypes) { // see if we can find the constructor directly // most of the time this works and it's much faster try { Constructor<T> ctor = cls.getConstructor(parameterTypes); setAccessibleWorkaround(ctor); return ctor; } catch (NoSuchMethodException e) { /* SWALLOW */ } Constructor<T> result = null; // search through all constructors Constructor<?>[] ctors = cls.getConstructors(); for (int i = 0; i < ctors.length; i++) { // compare parameters if (isAssignable(parameterTypes, ctors[i].getParameterTypes(), true)) { // get accessible version of method Constructor<T> ctor = getAccessibleConstructor((Constructor<T>) ctors[i]); if (ctor != null) { setAccessibleWorkaround(ctor); if (result == null || compareParameterTypes(ctor.getParameterTypes(), result.getParameterTypes(), parameterTypes) < 0) { result = ctor; } } } } return result; }