/** * Creates new instance of given type. In the first try, it tries to use * constructor with a {@link PetiteContainer}. If that files, uses default * constructor to builds an instance. */ private <T> T newInternalInstance(final Class<T> type, final PetiteContainer petiteContainer) throws Exception { T t = null; // first try ctor(PetiteContainer) try { Constructor<T> ctor = type.getConstructor(PetiteContainer.class); t = ctor.newInstance(petiteContainer); } catch (NoSuchMethodException nsmex) { // ignore } // if first try failed, try default ctor if (t == null) { return ClassUtil.newInstance(type); } return t; }
/** * Returns <code>true</code> if resource is of provided resource type. */ public boolean isSameTypeAsResource(final Class type) { return ClassUtil.isTypeOf(type, resource.getClass()); }
public MethodDescriptor(final ClassDescriptor classDescriptor, final Method method) { super(classDescriptor, ClassUtil.isPublic(method)); this.method = method; this.returnType = method.getGenericReturnType(); this.rawReturnType = ClassUtil.getRawType(returnType, classDescriptor.getType()); Class[] componentTypes = ClassUtil.getComponentTypes(returnType, classDescriptor.getType()); if (componentTypes != null) { this.rawReturnComponentType = componentTypes[componentTypes.length - 1]; ClassUtil.forceAccess(method); final Class rawParameterType = genericParams.length == 0 ? parameterType : ClassUtil.getRawType(genericParams[i], classDescriptor.getType()); final Class rawParameterComponentType = genericParams.length == 0 ? null : ClassUtil.getComponentType(genericParams[i], classDescriptor.getType(), -1);
public ClassDescriptor(final Class type, final boolean scanAccessible, final boolean extendedProperties, final boolean includeFieldsAsProperties, final String[] propertyFieldPrefix) { this.type = type; this.scanAccessible = scanAccessible; this.extendedProperties = extendedProperties; this.includeFieldsAsProperties = includeFieldsAsProperties; this.propertyFieldPrefix = propertyFieldPrefix; isArray = type.isArray(); isMap = ClassUtil.isTypeOf(type, Map.class); isList = ClassUtil.isTypeOf(type, List.class); isSet = ClassUtil.isTypeOf(type, Set.class); isCollection = ClassUtil.isTypeOf(type, Collection.class); isSupplier = ClassUtil.isTypeOf(type, Supplier.class); interfaces = ClassUtil.resolveAllInterfaces(type); superclasses = ClassUtil.resolveAllSuperclasses(type); }
/** * Creates new instance of given class with given optional arguments. */ @SuppressWarnings("unchecked") public static <T> T newInstance(final Class<T> clazz, final Object... params) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException { if (params.length == 0) { return newInstance(clazz); } final Class<?>[] paramTypes = getClasses(params); final Constructor<?> constructor = findConstructor(clazz, paramTypes); if (constructor == null) { throw new InstantiationException("No constructor matched parameter types."); } return (T) constructor.newInstance(params); }
return getRawType(pType.getRawType(), implClass); return getRawType(lowerTypes[0], implClass); return getRawType(upperTypes[0], implClass); Class<?> rawType = getRawType(genericComponentType, implClass); TypeVariable<?> varType = (TypeVariable<?>) type; if (implClass != null) { Type resolvedType = resolveVariable(varType, implClass); if (resolvedType != null) { return getRawType(resolvedType, null); return Object.class; return getRawType(boundsTypes[0], implClass);
@Test void testAccessibleC() { Method[] ms = ClassUtil.getAccessibleMethods(C.class, null); assertEquals(5 + 11, ms.length); ms = ClassUtil.getAccessibleMethods(C.class); assertEquals(5, ms.length); ms = C.class.getMethods(); assertEquals(2 + 9, ms.length); ms = C.class.getDeclaredMethods(); assertEquals(5, ms.length); ms = ClassUtil.getSupportedMethods(C.class, null); assertEquals(5 + 12, ms.length); ms = ClassUtil.getSupportedMethods(C.class); assertEquals(5, ms.length); Field[] fs = ClassUtil.getAccessibleFields(C.class); assertEquals(5, fs.length); fs = C.class.getFields(); assertEquals(3, fs.length); fs = C.class.getDeclaredFields(); assertEquals(5, fs.length); fs = ClassUtil.getSupportedFields(C.class); assertEquals(5, fs.length); }
if (!ClassUtil.isBeanPropertyGetter(method)) { throw new PathrefException("Not a getter: " + methodName); String getterName = ClassUtil.getBeanPropertyGetterName(method); if (ClassUtil.isTypeOf(target, List.class)) { final Class componentType = ClassUtil.getComponentType(method.getGenericReturnType(), currentClass, 0);
Method[] methods = scanAccessible ? ClassUtil.getAccessibleMethods(type) : ClassUtil.getSupportedMethods(type); propertyName = ClassUtil.getBeanPropertyGetterName(method); if (propertyName != null) { add = true; propertyName = ClassUtil.getBeanPropertySetterName(method); if (propertyName != null) { add = true;
@Test void testMatchInterfaces() { assertTrue(ClassUtil.isTypeOf(HashMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(AbstractMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(Map.class, Map.class)); assertTrue(ClassUtil.isInstanceOf(new HashMap(), Map.class)); assertTrue(ClassUtil.isTypeOf(HashMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(AbstractMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(HashMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(Map.class, Map.class)); assertTrue(ClassUtil.isTypeOf(HashMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(AbstractMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(HashMap.class, Map.class)); assertTrue(ClassUtil.isTypeOf(Map.class, Map.class)); }
assertEquals(List.class, ClassUtil.getRawType(stringList.getType())); assertEquals(String.class, ClassUtil.getComponentType(stringList.getGenericType(), 0)); assertEquals(String[].class, ClassUtil.getRawType(strings.getType())); assertEquals(String.class, ClassUtil.getComponentType(strings.getGenericType(), -1)); assertEquals(String.class, ClassUtil.getRawType(string.getType())); assertNull(ClassUtil.getComponentType(string.getGenericType(), 0)); Method integerList = ClassUtil.findMethod(sooClass, "getIntegerList"); assertEquals(List.class, ClassUtil.getRawType(integerList.getReturnType())); assertEquals(Integer.class, ClassUtil.getComponentType(integerList.getGenericReturnType(), -1)); Method integers = ClassUtil.findMethod(sooClass, "getIntegers"); assertEquals(Integer[].class, ClassUtil.getRawType(integers.getReturnType())); assertEquals(Integer.class, ClassUtil.getComponentType(integers.getGenericReturnType(), 0)); Method integer = ClassUtil.findMethod(sooClass, "getInteger"); assertEquals(Integer.class, ClassUtil.getRawType(integer.getReturnType())); assertNull(ClassUtil.getComponentType(integer.getGenericReturnType(), -1)); Method template = ClassUtil.findMethod(sooClass, "getTemplate"); assertEquals(Object.class, ClassUtil.getRawType(template.getReturnType())); assertNull(ClassUtil.getComponentType(template.getGenericReturnType(), 0)); Method collection = ClassUtil.findMethod(sooClass, "getCollection"); assertEquals(Collection.class, ClassUtil.getRawType(collection.getReturnType())); assertEquals(Number.class, ClassUtil.getComponentType(collection.getGenericReturnType(), -1));
@Test void testGetFieldConcreteType() throws NoSuchFieldException { Field f1 = BaseClass.class.getField("f1"); Field f2 = BaseClass.class.getField("f2"); Field f3 = BaseClass.class.getField("f3"); Field f4 = ConcreteClass.class.getField("f4"); Field f5 = ConcreteClass.class.getField("f5"); Field array1 = BaseClass.class.getField("array1"); Class[] genericSupertypes = ClassUtil.getGenericSupertypes(ConcreteClass.class); assertEquals(String.class, genericSupertypes[0]); assertEquals(Integer.class, genericSupertypes[1]); assertEquals(String.class, ClassUtil.getRawType(f1.getGenericType(), ConcreteClass.class)); assertEquals(Integer.class, ClassUtil.getRawType(f2.getGenericType(), ConcreteClass.class)); assertEquals(String.class, ClassUtil.getRawType(f3.getGenericType(), ConcreteClass.class)); assertEquals(Long.class, ClassUtil.getRawType(f4.getGenericType(), ConcreteClass.class)); assertEquals(List.class, ClassUtil.getRawType(f5.getGenericType(), ConcreteClass.class)); assertEquals(String[].class, ClassUtil.getRawType(array1.getGenericType(), ConcreteClass.class)); assertEquals(Object.class, ClassUtil.getRawType(f1.getGenericType())); assertNull(ClassUtil.getComponentType(f1.getGenericType(), -1)); assertEquals(Long.class, ClassUtil.getComponentType(f5.getGenericType(), 0)); }
/** * @see #getComponentTypes(java.lang.reflect.Type, Class) */ public static Class[] getComponentTypes(final Type type) { return getComponentTypes(type, null); }
/** * Inspects fields and returns map of {@link FieldDescriptor field descriptors}. */ protected HashMap<String, FieldDescriptor> inspectFields() { boolean scanAccessible = classDescriptor.isScanAccessible(); Class type = classDescriptor.getType(); Field[] fields = scanAccessible ? ClassUtil.getAccessibleFields(type) : ClassUtil.getSupportedFields(type); HashMap<String, FieldDescriptor> map = new HashMap<>(fields.length); for (Field field : fields) { String fieldName = field.getName(); if (fieldName.equals("serialVersionUID")) { continue; } map.put(fieldName, createFieldDescriptor(field)); } return map; }
/** * Inspects types methods and return map of {@link MethodDescriptor method descriptors}. */ protected HashMap<String, MethodDescriptor[]> inspectMethods() { boolean scanAccessible = classDescriptor.isScanAccessible(); Class type = classDescriptor.getType(); Method[] methods = scanAccessible ? ClassUtil.getAccessibleMethods(type) : ClassUtil.getSupportedMethods(type); HashMap<String, MethodDescriptor[]> map = new HashMap<>(methods.length); for (Method method : methods) { String methodName = method.getName(); MethodDescriptor[] mds = map.get(methodName); if (mds == null) { mds = new MethodDescriptor[1]; } else { mds = ArraysUtil.resize(mds, mds.length + 1); } map.put(methodName, mds); mds[mds.length - 1] = createMethodDescriptor(method); } return map; }
/** * Returns single component type. Index is used when type consist of many * components. If negative, index will be calculated from the end of the * returned array. Returns <code>null</code> if component type * does not exist or if index is out of bounds. * * @see #getComponentTypes(java.lang.reflect.Type) */ public static Class getComponentType(final Type type, final int index) { return getComponentType(type, null, index); }
@Test void testBeanPropertyNames() { String name = ClassUtil.getBeanPropertyGetterName(ClassUtil.findMethod(JavaBean.class, "getOne")); assertEquals("one", name); name = ClassUtil.getBeanPropertySetterName(ClassUtil.findMethod(JavaBean.class, "setOne")); assertEquals("one", name); name = ClassUtil.getBeanPropertyGetterName(ClassUtil.findMethod(JavaBean.class, "isTwo")); assertEquals("two", name); name = ClassUtil.getBeanPropertySetterName(ClassUtil.findMethod(JavaBean.class, "setTwo")); assertEquals("two", name); name = ClassUtil.getBeanPropertyGetterName(ClassUtil.findMethod(JavaBean.class, "getThree")); assertEquals("three", name); name = ClassUtil.getBeanPropertySetterName(ClassUtil.findMethod(JavaBean.class, "setThree")); assertEquals("three", name); name = ClassUtil.getBeanPropertyGetterName(ClassUtil.findMethod(JavaBean.class, "getF")); assertEquals("f", name); name = ClassUtil.getBeanPropertySetterName(ClassUtil.findMethod(JavaBean.class, "setF")); assertEquals("f", name); name = ClassUtil.getBeanPropertyGetterName(ClassUtil.findMethod(JavaBean.class, "getG")); assertEquals("g", name); name = ClassUtil.getBeanPropertySetterName(ClassUtil.findMethod(JavaBean.class, "setG"));
/** * Returns raw class for given <code>type</code>. Use this method with both * regular and generic types. * * @param type the type to convert * @return the closest class representing the given <code>type</code> * @see #getRawType(java.lang.reflect.Type, Class) */ public static Class getRawType(final Type type) { return getRawType(type, null); }
@Test void testClassGenerics3() { Class[] componentTypes = ClassUtil.getGenericSupertypes(BaseAna.class); assertNull(componentTypes); componentTypes = ClassUtil.getGenericSupertypes(ImplAna.class); assertNull(componentTypes); componentTypes = ClassUtil.getGenericSupertypes(ImplAna2.class); assertNull(componentTypes); componentTypes = ClassUtil.getGenericSupertypes(ImplAna3.class); assertNull(componentTypes); // scan generic interfacase Type[] types = ImplAna3.class.getGenericInterfaces(); assertEquals(1, types.length); assertEquals(ImplAna2.class, types[0]); assertNull(ClassUtil.getComponentType(types[0], 0)); types = ImplAna2.class.getGenericInterfaces(); assertEquals(1, types.length); assertEquals(Integer.class, ClassUtil.getComponentType(types[0], 0)); types = ImplAna.class.getGenericInterfaces(); assertEquals(1, types.length); assertEquals(Long.class, ClassUtil.getComponentType(types[0], 0)); types = BaseAna.class.getGenericInterfaces(); assertEquals(0, types.length); types = ImplAna4.class.getGenericInterfaces(); assertEquals(0, types.length); }
@Test void testGetRawWithImplClass() throws NoSuchFieldException { Method number = ClassUtil.findMethod(Base2.class, "getNumber"); Method kiko = ClassUtil.findMethod(Base2.class, "getKiko"); assertEquals(Number.class, ClassUtil.getRawType(number.getReturnType())); assertEquals(Number.class, ClassUtil.getRawType(number.getGenericReturnType())); assertEquals(Object.class, ClassUtil.getRawType(kiko.getReturnType())); assertEquals(Object.class, ClassUtil.getRawType(kiko.getGenericReturnType())); assertEquals(Number.class, ClassUtil.getRawType(number.getReturnType(), Impl1.class)); assertEquals(Number.class, ClassUtil.getRawType(number.getGenericReturnType(), Impl1.class)); assertEquals(Object.class, ClassUtil.getRawType(kiko.getReturnType(), Impl1.class)); assertEquals(Long.class, ClassUtil.getRawType(kiko.getGenericReturnType(), Impl1.class)); assertEquals(Number.class, ClassUtil.getRawType(number.getReturnType(), Impl2.class)); assertEquals(Integer.class, ClassUtil.getRawType(number.getGenericReturnType(), Impl2.class)); assertEquals(Object.class, ClassUtil.getRawType(kiko.getReturnType(), Impl2.class)); assertEquals(Long.class, ClassUtil.getRawType(kiko.getGenericReturnType(), Impl2.class)); assertEquals(Number.class, ClassUtil.getRawType(number.getReturnType(), Impl3.class)); assertEquals(Integer.class, ClassUtil.getRawType(number.getGenericReturnType(), Impl3.class)); assertEquals(Object.class, ClassUtil.getRawType(kiko.getReturnType(), Impl3.class)); assertEquals(Long.class, ClassUtil.getRawType(kiko.getGenericReturnType(), Impl3.class)); }