Java Field类代码示例

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
@Override
protected Field reField(Field field) {
    String name = field.getName();
    String newType;
    boolean isBasic = false;
    boolean isArray = false;
    if (field.getType().startsWith("[")) {
        isArray = true;
    }
    if (basicType.containsKey(field.getType())) {
        newType = field.getType();
        isBasic = true;
    } else {

        newType = DefineUtils.getDalvikClassName(field.getType());
    }
    String defineClass = DefineUtils.getDalvikClassName(field.getDefiningClass());
    return new ImmutableField(
            reType,
            classProcessor.filedProcess(defineClass, isBasic ? basicType.get(newType) : newType + (isArray ? "[]" : ""), name).fieldName,
            isBasic ? newType :
                    DefineUtils.getDefineClassName(classProcessor.classProcess(isBasic ? basicType.get(newType) : newType).className, isArray),
            field.getAccessFlags(),
            field.getInitialValue(),
            getAnnotation(field.getAnnotations()));
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
public ImmutableClassDef(@Nonnull String type,
                         int accessFlags,
                         @Nullable String superclass,
                         @Nullable Collection<String> interfaces,
                         @Nullable String sourceFile,
                         @Nullable Collection<? extends Annotation> annotations,
                         @Nullable Iterable<? extends Field> fields,
                         @Nullable Iterable<? extends Method> methods) {
    if (fields == null) {
        fields = ImmutableList.of();
    }
    if (methods == null) {
        methods = ImmutableList.of();
    }

    this.type = type;
    this.accessFlags = accessFlags;
    this.superclass = superclass;
    this.interfaces = interfaces==null ? ImmutableSet.<String>of() : ImmutableSet.copyOf(interfaces);
    this.sourceFile = sourceFile;
    this.annotations = ImmutableAnnotation.immutableSetOf(annotations);
    this.staticFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_STATIC));
    this.instanceFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_INSTANCE));
    this.directMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_DIRECT));
    this.virtualMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_VIRTUAL));
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
@Nonnull @Override public Set<? extends Field> getFields() {
    return new AbstractSet<Field>() {
        @Nonnull @Override public Iterator<Field> iterator() {
            return Iterators.transform(Iterators.forArray(cls.getDeclaredFields()),
                    new Function<java.lang.reflect.Field, Field>() {
                        @Nullable @Override public Field apply(@Nullable java.lang.reflect.Field input) {
                            return new ReflectionField(input);
                        }
                    });
        }

        @Override public int size() {
            return cls.getDeclaredFields().length;
        }
    };
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
public ImmutableClassDef( String type,
                         int accessFlags,
                          String superclass,
                          Collection<String> interfaces,
                          String sourceFile,
                          Collection<? extends Annotation> annotations,
                          Iterable<? extends Field> fields,
                          Iterable<? extends Method> methods) {
    if (fields == null) {
        fields = ImmutableList.of();
    }
    if (methods == null) {
        methods = ImmutableList.of();
    }

    this.type = type;
    this.accessFlags = accessFlags;
    this.superclass = superclass;
    this.interfaces = interfaces==null ? ImmutableList.<String>of() : ImmutableList.copyOf(interfaces);
    this.sourceFile = sourceFile;
    this.annotations = ImmutableAnnotation.immutableSetOf(annotations);
    this.staticFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_STATIC));
    this.instanceFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_INSTANCE));
    this.directMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_DIRECT));
    this.virtualMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_VIRTUAL));
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
@Override public Set<? extends Field> getFields() {
    return new AbstractSet<Field>() {
         @Override public Iterator<Field> iterator() {
            return Iterators.transform(Iterators.forArray(cls.getDeclaredFields()),
                    new Function<java.lang.reflect.Field, Field>() {
                         @Override public Field apply( java.lang.reflect.Field input) {
                            return new ReflectionField(input);
                        }
                    });
        }

        @Override public int size() {
            return cls.getDeclaredFields().length;
        }
    };
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
public ImmutableClassDef(@Nonnull String type,
                         int accessFlags,
                         @Nullable String superclass,
                         @Nullable Collection<String> interfaces,
                         @Nullable String sourceFile,
                         @Nullable Collection<? extends Annotation> annotations,
                         @Nullable Iterable<? extends Field> fields,
                         @Nullable Iterable<? extends Method> methods) {
    if (fields == null) {
        fields = ImmutableList.of();
    }
    if (methods == null) {
        methods = ImmutableList.of();
    }

    this.type = type;
    this.accessFlags = accessFlags;
    this.superclass = superclass;
    this.interfaces = interfaces==null ? ImmutableList.<String>of() : ImmutableList.copyOf(interfaces);
    this.sourceFile = sourceFile;
    this.annotations = ImmutableAnnotation.immutableSetOf(annotations);
    this.staticFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_STATIC));
    this.instanceFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_INSTANCE));
    this.directMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_DIRECT));
    this.virtualMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_VIRTUAL));
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
@Override
protected Field onSimpleEdit(Field patch, PatcherAnnotation annotation, Field target, boolean inPlace) {

	// Use the static field initializer value in source only
	// if not renaming, given that the static constructor in
	// source would only initialize it if not renamed.
	// This makes behavior predictable across compilers.
	EncodedValue value = inPlace ? target.getInitialValue() : null;
	value = filterInitialValue(patch, value);

	onSimpleRemove(patch, annotation, target);

	Field patched = new BasicField(
			patch.getDefiningClass(),
			patch.getName(),
			patch.getType(),
			patch.getAccessFlags(),
			value,
			annotation.getFilteredAnnotations());

	return super.onSimpleEdit(patched, annotation, target, inPlace);

}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
public BasicClassDef(
		String type,
		int accessFlags,
		String superclass,
		List<String> interfaces,
		String sourceFile,
		Set<? extends Annotation> annotations,
		Iterable<? extends Field> fields,
		Iterable<? extends Method> methods
) {
	this.type = type;
	this.accessFlags = accessFlags;
	this.superclass = superclass;
	this.interfaces = interfaces;
	this.sourceFile = sourceFile;
	this.annotations = annotations;
	this.fields = fields;
	this.staticFields = Iterables.filter(fields, FieldUtil.FIELD_IS_STATIC);
	this.instanceFields = Iterables.filter(fields, FieldUtil.FIELD_IS_INSTANCE);
	this.methods = methods;
	this.directMethods = Iterables.filter(methods, MethodUtil.METHOD_IS_DIRECT);
	this.virtualMethods = Iterables.filter(methods, MethodUtil.METHOD_IS_VIRTUAL);
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
public ImmutableClassDef(@Nonnull String type,
                         int accessFlags,
                         @Nullable String superclass,
                         @Nullable Collection<String> interfaces,
                         @Nullable String sourceFile,
                         @Nullable Collection<? extends Annotation> annotations,
                         @Nullable Iterable<? extends Field> fields,
                         @Nullable Iterable<? extends Method> methods) {
    if (fields == null) {
        fields = ImmutableList.of();
    }
    if (methods == null) {
        methods = ImmutableList.of();
    }

    this.type = type;
    this.accessFlags = accessFlags;
    this.superclass = superclass;
    this.interfaces = interfaces == null ? ImmutableSet.<String>of() : ImmutableSet.copyOf(interfaces);
    this.sourceFile = sourceFile;
    this.annotations = ImmutableAnnotation.immutableSetOf(annotations);
    this.staticFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_STATIC));
    this.instanceFields = ImmutableField.immutableSetOf(Iterables.filter(fields, FieldUtil.FIELD_IS_INSTANCE));
    this.directMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_DIRECT));
    this.virtualMethods = ImmutableMethod.immutableSetOf(Iterables.filter(methods, MethodUtil.METHOD_IS_VIRTUAL));
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
@Override
public FieldInfo[] getDeclaredFields() {
    List<FieldInfo> result = new ArrayList<>();
    Iterable<? extends Field> implFields = classDef.getFields();

    for (Field field : implFields) {
        FieldInfo fi = new FieldInfo();
        fi.typeName = DexlibAdapter.getTypeName(field.getType());
        fi.modifiers = field.getAccessFlags();
        fi.annotations = convertAnnotations(field.getAnnotations());
        fi.name = field.getName();

        result.add(fi);
    }

    FieldInfo[] array = new FieldInfo[result.size()];
    return result.toArray(array);
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
@Nonnull
@Override
public Set<? extends Field> getFields() {
    return new AbstractSet<Field>() {
        @Nonnull
        @Override
        public Iterator<Field> iterator() {
            return Iterators.transform(Iterators.forArray(cls.getDeclaredFields()),
                    new Function<java.lang.reflect.Field, Field>() {
                        @Nullable
                        @Override
                        public Field apply(@Nullable java.lang.reflect.Field input) {
                            return new ReflectionField(input);
                        }
                    });
        }

        @Override
        public int size() {
            return cls.getDeclaredFields().length;
        }
    };
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
public Field read(String className,String member) throws Exception {
    if (reader == null){
        return null;
    }
    classDef = (ClassDef) reader.read(className,null);
    Iterable<? extends Field> fields = classDef.getFields();
    for (Field field:fields){
        if (field.getName().equals(member)){
            return field;
        }
    }
return null;
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
private Set<String> writeStaticFields(IndentingWriter writer) throws IOException {
    if (!fullMethod && !DexDiffInfo.addedClasses.contains(classDef)) {
        return null;
    }
    boolean wroteHeader = false;
    Set<String> writtenFields = new HashSet<String>();

    Iterable<? extends Field> staticFields;
    if (classDef instanceof DexBackedClassDef) {
        staticFields = ((DexBackedClassDef) classDef).getStaticFields(false);
    } else {
        staticFields = classDef.getStaticFields();
    }

    for (Field field : staticFields) {
        if (!wroteHeader) {
            writer.write("\n\n");
            writer.write("# static fields");
            wroteHeader = true;
        }
        writer.write('\n');

        boolean setInStaticConstructor;
        IndentingWriter fieldWriter = writer;
        String fieldString = ReferenceUtil.getShortFieldDescriptor(field);
        if (!writtenFields.add(fieldString)) {
            writer.write("# duplicate field ignored\n");
            fieldWriter = new CommentingIndentingWriter(writer);
            System.err.println(String.format("Ignoring duplicate field: %s->%s", classDef.getType(), fieldString));
            setInStaticConstructor = false;
        } else {
            setInStaticConstructor = fieldsSetInStaticConstructor.contains(fieldString);
        }
        FieldDefinition.writeTo(options, fieldWriter, field, setInStaticConstructor);
    }
    return writtenFields;
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
private void writeInstanceFields(IndentingWriter writer, Set<String> staticFields) throws IOException {
    if (!fullMethod&& !DexDiffInfo.addedClasses.contains(classDef)) {
        return;
    }
    boolean wroteHeader = false;
    Set<String> writtenFields = new HashSet<String>();

    Iterable<? extends Field> instanceFields;
    if (classDef instanceof DexBackedClassDef) {
        instanceFields = ((DexBackedClassDef) classDef).getInstanceFields(false);
    } else {
        instanceFields = classDef.getInstanceFields();
    }

    for (Field field : instanceFields) {
        if (!wroteHeader) {
            writer.write("\n\n");
            writer.write("# instance fields");
            wroteHeader = true;
        }
        writer.write('\n');

        IndentingWriter fieldWriter = writer;
        String fieldString = ReferenceUtil.getShortFieldDescriptor(field);
        if (!writtenFields.add(fieldString)) {
            writer.write("# duplicate field ignored\n");
            fieldWriter = new CommentingIndentingWriter(writer);
            System.err.println(String.format("Ignoring duplicate field: %s->%s", classDef.getType(), fieldString));
        } else if (staticFields.contains(fieldString)) {
            System.err.println(String.format("Duplicate static+instance field found: %s->%s",
                    classDef.getType(), fieldString));
            System.err.println("You will need to rename one of these fields, including all references.");

            writer.write("# There is both a static and instance field with this signature.\n" +
                    "# You will need to rename one of these fields, including all references.\n");
        }
        FieldDefinition.writeTo(options, fieldWriter, field, false);
    }
}
 

import org.jf.dexlib2.iface.Field; //导入依赖的package包/类
public static ImmutableField of(Field field) {
    if (field instanceof  ImmutableField) {
        return (ImmutableField)field;
    }
    return new ImmutableField(
            field.getDefiningClass(),
            field.getName(),
            field.getType(),
            field.getAccessFlags(),
            field.getInitialValue(),
            field.getAnnotations());
}