Java Code Examples for java.lang.reflect.Field#isSynthetic()

The following examples show how to use java.lang.reflect.Field#isSynthetic() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
/**
 * inner recursively dispatch field with reflect access
 *
 * @param clazz      class of two instance
 * @param left       the left object to handle
 * @param right      the right object to handle
 * @param paths      current node paths
 * @param comparator integrated comparator
 */
private void innerCompare(Class<?> clazz, Object left, Object right, List<Path> paths, IntegratedComparator comparator) {
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
        if (field.isSynthetic() || isTransient(field.getModifiers()) || isStatic(field.getModifiers())) {
            continue;
        }
        boolean accessible = field.isAccessible();
        // recursively dispatch with integrated comparator
        try {
            field.setAccessible(true);
            comparator.dispatch(field.get(left), field.get(right), comparator.declarePath(paths, field.getName()));
        } catch (Exception e) {
            // this may not happen
            throw new RuntimeException("illegal access with filed", e);
        } finally {
            field.setAccessible(accessible);
        }
    }
    Class<?> superClazz = clazz.getSuperclass();
    while (superClazz != null && superClazz != Object.class) {
        innerCompare(superClazz, left, right, paths, comparator);
        superClazz = superClazz.getSuperclass();
    }
}
 
Example 2
Source Project: onedev   File: BeanUtils.java    License: MIT License 6 votes vote down vote up
/**
 * Get declared fields in the whole class hierarchy.
 * If there are fields with the same name in super-class and sub-class, 
 * fields in the sub-class with be returned only.
 */
public static List<Field> findFields(Class<?> clazz) {
	Map<String, Field> fields = new LinkedHashMap<>();
	
	Class<?> current = clazz;
	while (current != null) {
		for (Field field: current.getDeclaredFields()) {
			if (!field.isSynthetic() 
					&& !Modifier.isStatic(field.getModifiers()) 
					&& !fields.containsKey(field.getName())) {
				fields.put(field.getName(), field);
			}
		}
		current = current.getSuperclass();
	}
	return new ArrayList<Field>(fields.values());
}
 
Example 3
private static void createTerrainMapping() {
	if(terrainMapping.isEmpty()) {
		for (Field f : Terrain.class.getDeclaredFields()) {
			if (f.isSynthetic()) {
				continue;
			}
			int value;
			try {
				value = f.getInt(null);
			} catch (IllegalAccessException | IllegalArgumentException ignored) {
				continue;
			}
			String name = f.getName();

			terrainMapping.put(name, value);
		}
	}
}
 
Example 4
Source Project: DotCi   File: JenkinsMappedClass.java    License: MIT License 6 votes vote down vote up
@Override
protected void discover() {
    for (final Field field : ReflectionUtils.getDeclaredAndInheritedFields(getClazz(), true)) {
        field.setAccessible(true);
        final int fieldMods = field.getModifiers();
        if (field.isAnnotationPresent(Transient.class)
            || field.isSynthetic() && (fieldMods & Modifier.TRANSIENT) == Modifier.TRANSIENT
            || getMapper().getOptions().isActLikeSerializer() && ((fieldMods & Modifier.TRANSIENT) == Modifier.TRANSIENT)
            || getMapper().getOptions().isIgnoreFinals() && ((fieldMods & Modifier.FINAL) == Modifier.FINAL)) {
            // ignore these
        } else {
            getPersistenceFields().add(mapField(field));
        }

    }
}
 
Example 5
Source Project: katharsis-framework   File: ClassUtils.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Tries to find a class fields. Supports inheritance and doesn't return synthetic fields.
 *
 * @param beanClass class to be searched for
 * @param fieldName field name
 * @return a list of found fields
 */
public static Field findClassField(Class<?> beanClass, String fieldName) {
	Class<?> currentClass = beanClass;
	while (currentClass != null && currentClass != Object.class) {
		for (Field field : currentClass.getDeclaredFields()) {
			if (field.isSynthetic()) {
				continue;
			}

			if (field.getName().equals(fieldName)) {
				return field;
			}
		}
		currentClass = currentClass.getSuperclass();
	}

	return null;
}
 
Example 6
Source Project: sofa-acts   File: VirtualTable.java    License: Apache License 2.0 5 votes vote down vote up
private List<Field> filterSyntheticFields(List<Field> tmpFields) {
    // 过滤 synthetic 属性
    List<Field> fieldsList = new ArrayList<Field>();
    for (Field field : tmpFields) {
        if (!field.isSynthetic()) {
            fieldsList.add(field);
        }
    }
    return fieldsList;
}
 
Example 7
private void addOuterClassFields(Class<?> type, Collection<String> fields) {
    for (Field field : type.getDeclaredFields()) {
        if (field.isSynthetic()) {
            fields.add(field.getName());
        }
    }
    if (type.getSuperclass() != null) {
        addOuterClassFields(type.getSuperclass(), fields);
    }
}
 
Example 8
@SneakyThrows
private static void addMappingForClass(Class<?> clazz) {
	for (Field f : clazz.getDeclaredFields()) {
		if (f.isSynthetic()) {
			continue;
		}
		int key = f.getInt(null);
		String name = f.getName();

		keyToInt.put(name, key);
	}
}
 
Example 9
Source Project: core-ng-project   File: ClassValidator.java    License: Apache License 2.0 5 votes vote down vote up
private void visitObject(Class<?> objectClass, Field owner, String path) {
    if (visitedClasses.contains(objectClass))
        throw new Error("class must not have circular reference, field=" + Fields.path(owner));

    visitedClasses.add(objectClass);

    validateClass(objectClass);
    if (visitor != null) visitor.visitClass(objectClass, path);

    Field[] fields = objectClass.getDeclaredFields();
    for (Field field : fields) {
        if (field.isSynthetic()) continue;  // ignore dynamic/generated field, e.g. jacoco
        if (Modifier.isStatic(field.getModifiers()) && Modifier.isFinal(field.getModifiers())) continue;  // ignore all static final field

        validateField(field);
        if (visitor != null) visitor.visitField(field, path);

        String fieldPath = path(path, field.getName());
        Type fieldType = field.getGenericType();
        if (GenericTypes.isList(fieldType)) {
            if (!allowChild) throw new Error("list field is not allowed, field=" + Fields.path(field));

            visitList(fieldType, field, fieldPath);
        } else if (GenericTypes.isMap(fieldType)) {
            if (!allowChild) throw new Error("map field is not allowed, field=" + Fields.path(field));

            visitMap(fieldType, field, fieldPath);
        } else {
            visitValue(GenericTypes.rawClass(fieldType), field, fieldPath);
        }
    }

    visitedClasses.remove(objectClass);
}
 
Example 10
Source Project: hbase   File: SplitLogCounters.java    License: Apache License 2.0 5 votes vote down vote up
public static void resetCounters() throws Exception {
  Class<?> cl = SplitLogCounters.class;
  for (Field fld : cl.getDeclaredFields()) {
    /* Guard against source instrumentation. */
    if ((!fld.isSynthetic()) && (LongAdder.class.isAssignableFrom(fld.getType()))) {
      ((LongAdder)fld.get(null)).reset();
    }
  }
}
 
Example 11
@SuppressWarnings("unchecked")
public static <T extends Enum<?>> T addEnum(Class<T> enumType, String enumName, Class<?>[] paramTypes, Object[] paramValues) {
    if (!Enum.class.isAssignableFrom(enumType)) {
        throw new RuntimeException("class " + enumType + " is not an instance of Enum");
    }
    try {
        Field valuesField = null;
        for (Field field : enumType.getDeclaredFields()) {
            if (field.isSynthetic() && field.getType().isArray() && field.getType().getComponentType().equals(enumType)) {
                valuesField = field;
                break;
            }
        }

        valuesField.setAccessible(true);
        T[] previousValues = (T[]) valuesField.get(enumType);
        List<T> values = new ArrayList<T>(Arrays.asList(previousValues));

        T newValue = (T) makeEnum(enumType, enumName, values.size(), paramTypes, paramValues);
        values.add(newValue);

        setField(valuesField, null, values.toArray((Enum[]) Array.newInstance(enumType, 0)));

        cleanEnumCache(enumType);

        return newValue;
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e.getMessage(), e);
    }
}
 
Example 12
Source Project: rest-schemagen   File: ObjectContext.java    License: Apache License 2.0 5 votes vote down vote up
public boolean isApplicable(Field field, SchemaPropertyContext context) {
    return !Modifier.isStatic(field.getModifiers()) && //
            !field.isSynthetic() && //
            !IGNORE_ANNOTATIONS.stream().anyMatch(a -> field.getAnnotation(a) != null) && //
            isApplicableFor(field, context) && //
            isApplicableForPathParam(field);
}
 
Example 13
private static List<String> determineExtensionProps() {
  final List<String> props = new ArrayList<>();
  for (final Field f : CheckForbiddenApisExtension.class.getDeclaredFields()) {
    final int mods = f.getModifiers();
    if (Modifier.isPublic(mods) && !f.isSynthetic() && !Modifier.isStatic(mods)) {
      props.add(f.getName());
    }
  }
  return Collections.unmodifiableList(props);
}
 
Example 14
@SuppressWarnings("unchecked")
public static <T extends Enum<?>> T addEnum(Class<T> enumType, String enumName, Class<?>[] paramTypes, Object[] paramValues) {
    if (!Enum.class.isAssignableFrom(enumType)) {
        throw new RuntimeException("class " + enumType + " is not an instance of Enum");
    }
    try {
        Field valuesField = null;
        for (Field field : enumType.getDeclaredFields()) {
            if (field.isSynthetic() && field.getType().isArray() && field.getType().getComponentType().equals(enumType)) {
                valuesField = field;
                break;
            }
        }

        valuesField.setAccessible(true);
        T[] previousValues = (T[]) valuesField.get(enumType);
        List<T> values = new ArrayList<T>(Arrays.asList(previousValues));

        T newValue = (T) makeEnum(enumType, enumName, values.size(), paramTypes, paramValues);
        values.add(newValue);

        setField(valuesField, null, values.toArray((Enum[]) Array.newInstance(enumType, 0)));

        cleanEnumCache(enumType);

        return newValue;
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e.getMessage(), e);
    }
}
 
Example 15
private void findAnnotation(
        final Collection<Type> values,
        final Map<DocumentField.Type, Field> fields,
        final Field field) {
    final DocumentField annotation = field.getAnnotation(DocumentField.class);
    if (annotation != null && !field.isSynthetic() && !Modifier.isStatic(field.getModifiers())
            && String.class.isAssignableFrom(field.getType())) {
        final Type value = annotation.value();
        if (values.contains(value)) {
            field.setAccessible(true);
            fields.put(value, field);
            values.remove(value);
        }
    }
}
 
Example 16
Source Project: dubbo-2.6.5   File: ReflectUtils.java    License: Apache License 2.0 4 votes vote down vote up
public static boolean isPublicInstanceField(Field field) {
    return Modifier.isPublic(field.getModifiers())
            && !Modifier.isStatic(field.getModifiers())
            && !Modifier.isFinal(field.getModifiers())
            && !field.isSynthetic();
}
 
Example 17
/**
 * Validates that the given class is effectively static and has no instance state.
 *
 * @param source the class the validate
 */
public void validate(Class<?> source) throws InvalidModelRuleDeclarationException {

    // TODO - exceptions thrown here should point to some extensive documentation on the concept of class rule sources

    int modifiers = source.getModifiers();

    if (Modifier.isInterface(modifiers)) {
        throw invalid(source, "must be a class, not an interface");
    }
    if (Modifier.isAbstract(modifiers)) {
        throw invalid(source, "class cannot be abstract");
    }

    if (source.getEnclosingClass() != null) {
        if (Modifier.isStatic(modifiers)) {
            if (Modifier.isPrivate(modifiers)) {
                throw invalid(source, "class cannot be private");
            }
        } else {
            throw invalid(source, "enclosed classes must be static and non private");
        }
    }

    Class<?> superclass = source.getSuperclass();
    if (!superclass.equals(Object.class)) {
        throw invalid(source, "cannot have superclass");
    }

    Constructor<?>[] constructors = source.getDeclaredConstructors();
    if (constructors.length > 1) {
        throw invalid(source, "cannot have more than one constructor");
    }

    Constructor<?> constructor = constructors[0];
    if (constructor.getParameterTypes().length > 0) {
        throw invalid(source, "constructor cannot take any arguments");
    }

    Field[] fields = source.getDeclaredFields();
    for (Field field : fields) {
        int fieldModifiers = field.getModifiers();
        if (!field.isSynthetic() && !(Modifier.isStatic(fieldModifiers) && Modifier.isFinal(fieldModifiers))) {
            throw invalid(source, "field " + field.getName() + " is not static final");
        }
    }

}
 
Example 18
private static boolean matches(Class<?> type, Object left, Object right, Set<Pair> visited) throws Exception {
    if (!visited.add(new Pair(left, right))) {
        return true;
    } else if (mockingDetails(left).isMock() || mockingDetails(left).isSpy() || mockingDetails(right).isMock() || mockingDetails(right).isSpy()) {
        return left == right;
    }
    while (type.getName().startsWith("net.bytebuddy.")) {
        for (Field field : type.getDeclaredFields()) {
            if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic() && !field.getName().equals("this$0")) {
                continue;
            }
            HashCodeAndEqualsPlugin.ValueHandling valueHandling = field.getAnnotation(HashCodeAndEqualsPlugin.ValueHandling.class);
            if (valueHandling != null && valueHandling.value() == HashCodeAndEqualsPlugin.ValueHandling.Sort.IGNORE) {
                continue;
            }
            field.setAccessible(true);
            if (field.getType() == boolean.class) {
                if (field.getBoolean(left) != field.getBoolean(right)) {
                    return false;
                }
            } else if (field.getType() == byte.class) {
                if (field.getBoolean(left) != field.getBoolean(right)) {
                    return false;
                }
            } else if (field.getType() == short.class) {
                if (field.getShort(left) != field.getShort(right)) {
                    return false;
                }
            } else if (field.getType() == char.class) {
                if (field.getChar(left) != field.getChar(right)) {
                    return false;
                }
            } else if (field.getType() == int.class) {
                if (field.getInt(left) != field.getInt(right)) {
                    return false;
                }
            } else if (field.getType() == long.class) {
                if (field.getLong(left) != field.getLong(right)) {
                    return false;
                }
            } else if (field.getType() == float.class) {
                if (field.getFloat(left) != field.getFloat(right)) {
                    return false;
                }
            } else if (field.getType() == double.class) {
                if (field.getDouble(left) != field.getDouble(right)) {
                    return false;
                }
            } else if (field.getType().isEnum()) {
                if (field.get(left) != field.get(right)) {
                    return false;
                }
            } else {
                Object leftObject = field.get(left), rightObject = field.get(right);
                if (mockingDetails(leftObject).isMock() || mockingDetails(rightObject).isSpy() || mockingDetails(rightObject).isMock() || mockingDetails(rightObject).isSpy()) {
                    if (leftObject != rightObject) {
                        return false;
                    }
                } else if (Iterable.class.isAssignableFrom(field.getType())) {
                    if (rightObject == null) {
                        return false;
                    }
                    Iterator<?> rightIterable = ((Iterable<?>) rightObject).iterator();
                    for (Object instance : (Iterable<?>) leftObject) {
                        if (!rightIterable.hasNext() || !matches(instance.getClass(), instance, rightIterable.next(), visited)) {
                            return false;
                        }
                    }
                } else if (field.getType().getName().startsWith("net.bytebuddy.")) {
                    if (leftObject == null ? rightObject != null : !matches(leftObject.getClass(), leftObject, rightObject, visited)) {
                        return false;
                    }
                } else {
                    if (leftObject == null ? rightObject != null : !leftObject.equals(rightObject)) {
                        return false;
                    }
                }
            }
        }
        type = type.getSuperclass();
    }
    return true;
}
 
Example 19
private void processTypes(final Set<Class<?>> types) {
    while (!types.isEmpty()) {
        final Iterator<Class<?>> iter = types.iterator();
        final Class<?> type = iter.next();
        iter.remove();

        synchronized(type) {
            if (annotatedTypes.contains(type)) {
                continue;
            }
            try {
                if (type.isPrimitive()) {
                    continue;
                }

                addParametrizedTypes(type, types);

                processConverterAnnotations(type);
                processAliasAnnotation(type, types);
                processAliasTypeAnnotation(type);

                if (type.isInterface()) {
                    continue;
                }

                processImplicitCollectionAnnotation(type);

                final Field[] fields = type.getDeclaredFields();
                for (int i = 0; i < fields.length; i++ ) {
                    final Field field = fields[i];
                    if (field.isEnumConstant()
                        || (field.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) > 0) {
                        continue;
                    }

                    addParametrizedTypes(field.getGenericType(), types);

                    if (field.isSynthetic()) {
                        continue;
                    }

                    processFieldAliasAnnotation(field);
                    processAsAttributeAnnotation(field);
                    processImplicitAnnotation(field);
                    processOmitFieldAnnotation(field);
                    processLocalConverterAnnotation(field);
                }
            } finally {
                annotatedTypes.add(type);
            }
        }
    }
}
 
Example 20
Source Project: dubbox-hystrix   File: ReflectUtils.java    License: Apache License 2.0 4 votes vote down vote up
public static boolean isPublicInstanceField(Field field) {
    return Modifier.isPublic(field.getModifiers())
        && !Modifier.isStatic(field.getModifiers())
        && !Modifier.isFinal(field.getModifiers())
        && !field.isSynthetic();
}