Java Field.isSynthetic方法代码示例

import java.lang.reflect.Field; //导入方法依赖的package包/类
public static Collection<Field> findAnnotatedFields(Class<?> type, Class<? extends Annotation> annotation)
{
    List<Field> result = new ArrayList<>();

    // gather all publicly available fields
    // this returns everything, even if it's declared in a parent
    for (Field field : type.getFields()) {
        if (field.isSynthetic() || isStatic(field.getModifiers())) {
            continue;
        }

        if (field.isAnnotationPresent(annotation)) {
            result.add(field);
        }
    }

    return result;
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
/**
 * Geef alle velden van een klasse (inclusief velden uit super klassen, exclusief
 * java.lang.Object).
 * @param clazz klasse
 * @return lijst van alle velden
 */
public static Field[] getAllFields(final Class<?> clazz) {
    final java.util.List<Field> result = new ArrayList<>();

    Class<?> theClazz = clazz;
    while (theClazz != null && !Object.class.equals(theClazz)) {
        for (final Field field : theClazz.getDeclaredFields()) {
            if (!field.isSynthetic()) {
                result.add(field);
            }
        }
        theClazz = theClazz.getSuperclass();
    }

    return result.toArray(new Field[]{});
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
/**
 * 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;
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
private void validateClass(Class<?> source, RuleSourceValidationProblemCollector problems) {
    int modifiers = source.getModifiers();

    if (Modifier.isInterface(modifiers)) {
        problems.add("Must be a class, not an interface");
    }

    if (source.getEnclosingClass() != null) {
        if (Modifier.isStatic(modifiers)) {
            if (Modifier.isPrivate(modifiers)) {
                problems.add("Class cannot be private");
            }
        } else {
            problems.add("Enclosed classes must be static and non private");
        }
    }

    Constructor<?>[] constructors = source.getDeclaredConstructors();
    for (Constructor<?> constructor : constructors) {
        if (constructor.getParameterTypes().length > 0) {
            problems.add("Cannot declare a constructor that takes arguments");
            break;
        }
    }

    Field[] fields = source.getDeclaredFields();
    for (Field field : fields) {
        int fieldModifiers = field.getModifiers();
        if (!field.isSynthetic() && !(Modifier.isStatic(fieldModifiers) && Modifier.isFinal(fieldModifiers))) {
            problems.add(field, "Fields must be static final.");
        }
    }
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
private static void ensureNoInstanceScopedFields(StructBindingValidationProblemCollector problems, Class<?> typeClass) {
    List<Field> declaredFields = Arrays.asList(typeClass.getDeclaredFields());
    for (Field field : declaredFields) {
        int fieldModifiers = field.getModifiers();
        if (!field.isSynthetic() && !(Modifier.isStatic(fieldModifiers) && Modifier.isFinal(fieldModifiers))) {
            problems.add(field, "Fields must be static final.");
        }
    }
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
private static void filterSynthetics(List<Field> fields) {
    if (fields == null || fields.isEmpty()) return;
    Iterator<Field> iterator = fields.iterator();
    while (iterator.hasNext()) {
        Field f = iterator.next();
        if (f.isSynthetic()) iterator.remove();
    }
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
static ImmutableSet<Field> relevantFields(Class<?> cls) {
  ImmutableSet.Builder<Field> builder = ImmutableSet.builder();
  for (Field field : cls.getDeclaredFields()) {
    /*
     * Coverage mode generates synthetic fields.  If we ever add private
     * fields, they will cause similar problems, and we may want to switch
     * this check to isAccessible().
     */
    if (!field.isSynthetic() && field.getType() == String.class) {
      builder.add(field);
    }
  }
  return builder.build();
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
/**
 * Is this field to be hidden from the graph?
 */
private static boolean isHiddenField(Field field) {
  if (field.isSynthetic() || has(field, Hidden.class) || isStatic(field.getModifiers())) {
    return true;
  }
  return SYSTEM_PROPERTIES.contains(propertyKey(field)) ||
      SYSTEM_CLASSES.contains(field.getDeclaringClass()) ||
      isFunctional(field.getType());
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
private void registerField(Map<String, Getter> getters, Map<String, Setter> setters, Field field) {
    if(Modifier.isTransient(field.getModifiers()) ||
       Modifier.isStatic(field.getModifiers()) ||
       field.isSynthetic() ||
       field.isEnumConstant()) return;

    final String name = serializedName(field);
    final boolean gettable = !getters.containsKey(name);
    final boolean settable = !setters.containsKey(name);

    if(gettable || settable) {
        if(logger.isLoggable(Level.FINE)) {
            String access;
            if(gettable && settable) {
                access = "get/set";
            } else if(gettable) {
                access = "get";
            } else {
                access = "set";
            }
            logger.fine("  " + name + " -- " + access + " --> " + field);
        }

        if(gettable) {
            getters.put(name, new FieldGetter(this, field));
        }

        if(settable) {
            setters.put(name, new FieldSetter(this, field));
        }
    }
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
public boolean excludeField(Field field, boolean serialize) {
    if ((this.modifiers & field.getModifiers()) != 0) {
        return true;
    }
    if (this.version != IGNORE_VERSIONS && !isValidVersion((Since) field.getAnnotation(Since
            .class), (Until) field.getAnnotation(Until.class))) {
        return true;
    }
    if (field.isSynthetic()) {
        return true;
    }
    if (this.requireExpose) {
        Expose annotation = (Expose) field.getAnnotation(Expose.class);
        if (annotation == null || (serialize ? !annotation.serialize() : !annotation
                .deserialize())) {
            return true;
        }
    }
    if (!this.serializeInnerClasses && isInnerClass(field.getType())) {
        return true;
    }
    if (isAnonymousOrLocal(field.getType())) {
        return true;
    }
    List<ExclusionStrategy> list = serialize ? this.serializationStrategies : this
            .deserializationStrategies;
    if (!list.isEmpty()) {
        FieldAttributes fieldAttributes = new FieldAttributes(field);
        for (ExclusionStrategy exclusionStrategy : list) {
            if (exclusionStrategy.shouldSkipField(fieldAttributes)) {
                return true;
            }
        }
    }
    return false;
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
public static void resetCounters() throws Exception {
  Class<?> cl = SplitLogCounters.class;
  for (Field fld : cl.getDeclaredFields()) {
    /* Guard against source instrumentation. */
    if ((!fld.isSynthetic()) && (AtomicLong.class.isAssignableFrom(fld.getType()))) {
      ((AtomicLong)fld.get(null)).set(0);
    }
  }
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
protected static boolean isPublicInstanceField(Field field) {
    return Modifier.isPublic(field.getModifiers())
            && !Modifier.isStatic(field.getModifiers())
            && !Modifier.isFinal(field.getModifiers())
            && !field.isSynthetic();
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
public static boolean isPublicInstanceField(Field field) {
    return Modifier.isPublic(field.getModifiers())
        && !Modifier.isStatic(field.getModifiers())
        && !Modifier.isFinal(field.getModifiers())
        && !field.isSynthetic();
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
static void saveFields( IJsonIO obj, Class cls, Bindings bindings )
{
  Class superclass = cls.getSuperclass();
  if( superclass != null )
  {
    saveFields( obj, superclass, bindings );
  }

  Field[] fields = cls.getDeclaredFields();
  for( Field f : fields )
  {
    if( f.isSynthetic() || Modifier.isStatic( f.getModifiers() ) || Modifier.isTransient( f.getModifiers() ) )
    {
      continue;
    }
    f.setAccessible( true );
    try
    {
      Object value = f.get( obj );
      if( isSimpleType( value ) )
      {
        bindings.put( f.getName(), value );
      }
      else if( value instanceof Enum )
      {
        bindings.put( f.getName(), ((Enum)value).name() );
      }
      else if( value instanceof Boolean )
      {
        bindings.put( f.getName(), (Boolean)value ? 1 : 0 );
      }
      else if( value instanceof List )
      {
        if( !((List)value).isEmpty() )
        {
          if( isSimpleType( ((List)value).get( 0 ) ) )
          {
            bindings.put( f.getName(), value );
          }
          else
          {
            writeList( f.getName(), (List)value, bindings );
          }
        }
        else
        {
          bindings.put( f.getName(), value );
        }
      }
      else if( value instanceof IJsonIO )
      {
        write( f.getName(), (IJsonIO)value, bindings );
      }
      else
      {
        throw new UnsupportedOperationException( "Type: " + value.getClass() + " does not implement " + IJsonIO.class.getName() );
      }
    }
    catch( IllegalAccessException e )
    {
      throw new RuntimeException( e );
    }
  }
}
 

import java.lang.reflect.Field; //导入方法依赖的package包/类
public boolean excludeField(Field field, boolean serialize) {
  if ((modifiers & field.getModifiers()) != 0) {
    return true;
  }

  if (version != Excluder.IGNORE_VERSIONS
      && !isValidVersion(field.getAnnotation(Since.class), field.getAnnotation(Until.class))) {
    return true;
  }

  if (field.isSynthetic()) {
    return true;
  }

  if (requireExpose) {
    Expose annotation = field.getAnnotation(Expose.class);
    if (annotation == null || (serialize ? !annotation.serialize() : !annotation.deserialize())) {
      return true;
    }
  }

  if (!serializeInnerClasses && isInnerClass(field.getType())) {
    return true;
  }

  if (isAnonymousOrLocal(field.getType())) {
    return true;
  }

  List<ExclusionStrategy> list = serialize ? serializationStrategies : deserializationStrategies;
  if (!list.isEmpty()) {
    FieldAttributes fieldAttributes = new FieldAttributes(field);
    for (ExclusionStrategy exclusionStrategy : list) {
      if (exclusionStrategy.shouldSkipField(fieldAttributes)) {
        return true;
      }
    }
  }

  return false;
}