/** * Returns all bean property names. */ protected String[] getAllBeanPropertyNames(Class type, boolean declared) { ClassDescriptor classDescriptor = ClassIntrospector.lookup(type); PropertyDescriptor[] propertyDescriptors = classDescriptor.getAllPropertyDescriptors(); ArrayList<String> names = new ArrayList<>(propertyDescriptors.length); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { MethodDescriptor getter = propertyDescriptor.getReadMethodDescriptor(); if (getter != null) { if (getter.matchDeclared(declared)) { names.add(propertyDescriptor.getName()); } } else if (includeFields) { FieldDescriptor field = propertyDescriptor.getFieldDescriptor(); if (field != null) { if (field.matchDeclared(declared)) { names.add(field.getName()); } } } } return names.toArray(new String[names.size()]); }
boolean scanAccessible = classDescriptor.isScanAccessible(); Class type = classDescriptor.getType(); MethodDescriptor methodDescriptor = classDescriptor.getMethodDescriptor(method.getName(), method.getParameterTypes(), true); addProperty(map, propertyName, methodDescriptor, issetter); if (classDescriptor.isIncludeFieldsAsProperties()) { FieldDescriptor[] fieldDescriptors = classDescriptor.getAllFieldDescriptors(); String[] prefix = classDescriptor.getPropertyFieldPrefix();
public DestroyMethodPoint[] resolve(final Class<?> type) { // lookup methods List<DestroyMethodPoint> list = new ArrayList<>(); ClassDescriptor cd = new ClassDescriptor(type, false, false, false, null); MethodDescriptor[] allMethods = cd.getAllMethodDescriptors(); for (MethodDescriptor methodDescriptor : allMethods) { Method method = methodDescriptor.getMethod(); PetiteDestroyMethod petiteDestroyMethod = method.getAnnotation(PetiteDestroyMethod.class); if (petiteDestroyMethod == null) { continue; } if (method.getParameterTypes().length > 0) { throw new PetiteException("Arguments are not allowed for Petite destroy method: " + type.getName() + '#' + method.getName()); } list.add(new DestroyMethodPoint(method)); } DestroyMethodPoint[] methods; if (list.isEmpty()) { methods = DestroyMethodPoint.EMPTY; } else { methods = list.toArray(new DestroyMethodPoint[0]); } return methods; }
/** * Locates property field. Field is being searched also in all * superclasses of current class. */ protected FieldDescriptor findField(String fieldName) { FieldDescriptor fieldDescriptor = classDescriptor.getFieldDescriptor(fieldName, true); if (fieldDescriptor != null) { return fieldDescriptor; } // field descriptor not found in this class // try to locate it in the superclasses Class[] superclasses = classDescriptor.getAllSuperclasses(); for (Class superclass : superclasses) { ClassDescriptor classDescriptor = ClassIntrospector.lookup(superclass); fieldDescriptor = classDescriptor.getFieldDescriptor(fieldName, true); if (fieldDescriptor != null) { return fieldDescriptor; } } // nothing found return null; }
@Test void testPropertiesTwoSubClass() throws InvocationTargetException, IllegalAccessException { ClassDescriptor cd = ClassIntrospector.get().lookup(TwoSub.class); PropertyDescriptor[] propertyDescriptors = cd.getAllPropertyDescriptors(); assertEquals(2, propertyDescriptors.length); assertEquals("fone", propertyDescriptors[0].getName()); assertEquals("ftwo", propertyDescriptors[1].getName()); for (int i = 0; i < 2; i++) { assertNull(propertyDescriptors[i].getWriteMethodDescriptor()); assertNotNull(propertyDescriptors[i].getReadMethodDescriptor()); assertNotNull(propertyDescriptors[i].getFieldDescriptor()); } // change value TwoSub one = new TwoSub(); Setter setter = propertyDescriptors[0].getSetter(true); setter.invokeSetter(one, "one!"); assertEquals("one!", one.getFone()); // fields FieldDescriptor[] fieldDescriptors = cd.getAllFieldDescriptors(); assertEquals(1, fieldDescriptors.length); assertEquals("ftwo", fieldDescriptors[0].getName()); // beanutil BeanUtil.declared.setProperty(one, "fone", "!!!"); assertEquals("!!!", one.getFone()); }
ClassDescriptor cd = ClassIntrospector.get().lookup(Abean.class); assertNotNull(cd); PropertyDescriptor[] properties = cd.getAllPropertyDescriptors(); int c = 0; for (PropertyDescriptor property : properties) { assertNull(pd.getFieldDescriptor()); assertNotNull(cd.getPropertyDescriptor("fooProp", false)); assertNotNull(cd.getPropertyDescriptor("something", false)); assertNull(cd.getPropertyDescriptor("FooProp", false)); assertNull(cd.getPropertyDescriptor("Something", false)); assertNull(cd.getPropertyDescriptor("notExisting", false));
/** * Resolves action method for given action class ane method name. */ public Method resolveActionMethod(final Class<?> actionClass, final String methodName) { MethodDescriptor methodDescriptor = ClassIntrospector.get().lookup(actionClass).getMethodDescriptor(methodName, false); if (methodDescriptor == null) { throw new MadvocException("Public method not found: " + actionClass.getSimpleName() + "#" + methodName); } return methodDescriptor.getMethod(); }
@Test void testStaticFieldsForProperties() { ClassDescriptor cd = ClassIntrospector.get().lookup(Mojo.class); FieldDescriptor[] fieldDescriptors = cd.getAllFieldDescriptors(); assertEquals(3, fieldDescriptors.length); MethodDescriptor[] methodDescriptors = cd.getAllMethodDescriptors(); assertEquals(2, methodDescriptors.length); PropertyDescriptor[] propertyDescriptor = cd.getAllPropertyDescriptors(); assertEquals(3, propertyDescriptor.length); int count = 0; for (PropertyDescriptor pd : propertyDescriptor) { if (pd.isFieldOnly()) { continue; } count++; } assertEquals(1, count); }
/** * Loads property descriptor, if property was updated. */ private void loadPropertyDescriptor() { if (updateProperty) { if (cd == null) { propertyDescriptor = null; } else { propertyDescriptor = cd.getPropertyDescriptor(name, true); } updateProperty = false; } }
assertEquals(MethodParameterType.class, cd.getType()); assertEquals(5, cd.getAllMethodDescriptors().length); MethodDescriptor[] mds = cd.getAllMethodDescriptors(); int mc = 0; for (MethodDescriptor md : mds) { Method m2 = cd.getMethodDescriptor("m", params, true).getMethod(); assertNotNull(m2); assertEquals(m, m2); MethodDescriptor md1 = cd.getMethodDescriptor("m", params, true); assertNotNull(md1); assertEquals(m, md1.getMethod()); MethodDescriptor md2 = cd.getMethodDescriptor("m2", params, true); assertNotNull(md2); assertArrayEquals(params, getRawParameterTypes(md2)); MethodDescriptor md3 = cd.getMethodDescriptor("m3", params, true); assertNotNull(md3); assertArrayEquals(params, getRawParameterTypes(md3)); MethodDescriptor md4 = cd.getMethodDescriptor("m4", new Class[] {List.class}, true); assertNotNull(md4); assertArrayEquals(new Class[] {List.class}, getRawParameterTypes(md4)); MethodDescriptor md5 = cd.getMethodDescriptor("m5", new Class[] {List.class}, true); assertNotNull(md5);
PropertyDescriptor[] propertyDescriptors = cd.getAllPropertyDescriptors(); MethodDescriptor[] mds = cd.getAllMethodDescriptors(); int c = 0; for (MethodDescriptor md : mds) { assertEquals("flag", propertyDescriptors[0].getName()); assertEquals("isFlag", propertyDescriptors[0].getReadMethodDescriptor().getMethod().getName()); mds = cd.getAllMethodDescriptors(); c = 0; for (MethodDescriptor md : mds) {
MethodDescriptor[] methods = cd.getAllMethodDescriptors(methodName); MethodDescriptor md = cd.getMethodDescriptor(methodName, arguments, true); if (md != null) { method = md.getMethod();
@Test void testNormal() { ClassDescriptor cd = ClassIntrospector.get().lookup(Normal.class); FieldDescriptor fd = cd.getFieldDescriptor("input", true); assertEquals(String.class, fd.getField().getType()); assertEquals(String.class, fd.getRawType()); fd = cd.getFieldDescriptor("output", true); assertEquals(Integer.class, fd.getField().getType()); assertEquals(Integer.class, fd.getRawType()); PropertyDescriptor pd = cd.getPropertyDescriptor("input", true); assertEquals(String.class, pd.getType()); pd = cd.getPropertyDescriptor("output", true); assertEquals(Integer.class, pd.getType()); }
@SuppressWarnings("unchecked") public <T> List<Constructor<T>> listConstructors(Class<T> type) { ClassDescriptor classDescriptor = new ClassDescriptor(type, false, false, true, null); List<Constructor<T>> ctors = new ArrayList<>(); for (CtorDescriptor desc : classDescriptor.getAllCtorDescriptors()) { ctors.add(desc.getConstructor()); } Collections.sort(ctors, new ConstructorComparator()); return ctors; }
ClassDescriptor cd = ClassIntrospector.get().lookup(MethodParameterType.class); assertEquals(MethodParameterType.class, cd.getType()); assertEquals(4, cd.getAllFieldDescriptors().length); FieldDescriptor[] fs = cd.getAllFieldDescriptors(); int p = 0; for (FieldDescriptor f : fs) { FieldDescriptor fd = cd.getFieldDescriptor("f", true); FieldDescriptor fd2 = cd.getFieldDescriptor("f2", true); FieldDescriptor fd3 = cd.getFieldDescriptor("f3", true); FieldDescriptor fd4 = cd.getFieldDescriptor("f4", true); fd = cd.getFieldDescriptor("f", true); fd2 = cd.getFieldDescriptor("f2", true); fd3 = cd.getFieldDescriptor("f3", true); assertEquals(String.class, ClassUtil.getComponentTypes(fd3.getField().getGenericType(), cd.getType())[0]);
/** * Describes a class by creating a new instance of {@link ClassDescriptor} * that examines all accessible methods and fields. */ protected ClassDescriptor describeClass(Class type) { return new ClassDescriptor(type, scanAccessible, enhancedProperties, includeFieldsAsProperties, propertyFieldPrefix); }
isTargetRealTypeMap = targetTypeClassDescriptor.isMap(); pd = targetTypeClassDescriptor.getPropertyDescriptor(key, true);
@Test void testCtors() { ClassDescriptor cd = ClassIntrospector.get().lookup(Ac.class); CtorDescriptor[] ctors = cd.getAllCtorDescriptors(); int c = 0; for (CtorDescriptor ctor : ctors) { ctors = cd.getAllCtorDescriptors(); assertEquals(2, ctors.length); assertNotNull(cd.getDefaultCtorDescriptor(true)); assertNull(cd.getDefaultCtorDescriptor(false)); Constructor ctor = cd.getCtorDescriptor(new Class[] {Integer.class}, true).getConstructor(); assertNotNull(ctor); ctors = cd.getAllCtorDescriptors(); c = 0; for (CtorDescriptor ccc : ctors) { ctors = cd.getAllCtorDescriptors(); assertEquals(1, ctors.length); assertNull(cd.getDefaultCtorDescriptor(false)); assertNull(cd.getDefaultCtorDescriptor(true)); CtorDescriptor ctorDescriptor = cd.getCtorDescriptor(new Class[] {Integer.class}, true); assertNull(ctorDescriptor); ctor = cd.getCtorDescriptor(new Class[] {String.class}, true).getConstructor(); assertNotNull(ctor);
if (cd.isArray()) { return lookupSerializer(Arrays.class); Class[] interfaces = cd.getAllInterfaces(); Class[] superclasses = cd.getAllSuperclasses();
CtorDescriptor[] ctors = cd.getAllCtorDescriptors(); if (ctors != null && ctors.length > 0) { if (ctors.length > 1) { CtorDescriptor ctorDescriptor = cd.getCtorDescriptor(paramTypes, true);