定义

代表可被序列化的字段。即指定哪些字段将参与序列化，并封装这些参与序列化的字段信息。所有可被序列化的字段需要封装为一个ObjectStreamField数组，且数组变量名必须为serialPersistentFields。

  1. public class ObjectStreamField implements Comparable<Object> {
  2.     ...
  3. }
  • 实现 Comparable 接口，可比较大小

重写两个方法toString和compareTo

  1.     @Override
  2.     public int compareTo(Object obj) {
  3.         // 强转为ObjectStreamField
  4.         ObjectStreamField other = (ObjectStreamField) obj;
  5.         // 当前字段是否为基本类型
  6.         boolean isPrim = isPrimitive();
  7.         // 两个字段类型不相同的场合
  8.         if(isPrim != other.isPrimitive()) {
  9.             // 基本类型倒序，非基本类型正序
  10.             return isPrim ? -1 : 1;
  11.         }
  12.         // 调用string的比较方法
  13.         return name.compareTo(other.name);
  14.     }
  16.     /**
  17.      * Return a string that describes this field.
  18.      */
  19.     @Override
  20.     public String toString() {
  21.         // 返回字段签名和字段名称
  22.         return getSignature() + ' ' + name;
  23.     }

成员变量

  1.     // 字段名称
  2.     private final String name;
  4.     // 封装的字段(可能为null)
  5.     private final Field field;
  7.     // 字段类型
  8.     private final Class<?> type;
  10.     // 字段类型的JVM规范签名
  11.     private final String signature;
  13.     // JVM规范签名(懒加载生成)
  14.     private String typeSignature;
  16.     // 字段是否非共享(共享字段会共用一段序列化信息)
  17.     private final boolean unshared;
  19.     // 当前字段在所有待序列化字段中的偏移量(以字节为偏移单位)
  20.     private int offset;

构造函数

构造函数（传入字段名和字段数据类型，默认可共享）

  1.     // 构造函数（传入字段名和字段数据类型，默认可共享）
  2.     public ObjectStreamField(String name, Class<?> type) {
  3.         this(name, type, false);
  4.     }
  6.     // 构造函数（传入数据名、数据类型、共享权限）
  7.     public ObjectStreamField(String name, Class<?> type, boolean unshared) {
  8.         if(name == null) {
  9.             throw new NullPointerException();
  10.         }
  11.         this.name = name;
  12.         this.type = type;
  13.         this.unshared = unshared;
  14.         // 字段、签名初始化
  15.         this.field = null;
  16.         this.signature = null;
  17.     }

构造函数（传入数据名、签名、共享权限）

  1.     // 构造函数（传入数据名、签名、共享权限）
  2.     ObjectStreamField(String name, String signature, boolean unshared) {
  3.         if(name == null) {
  4.             throw new NullPointerException();
  5.         }
  6.         this.name = name;
  7.         // 返回字符串的规范形式
  8.         this.signature = signature.intern();
  9.         this.unshared = unshared;
  10.         this.field = null;
  12.         // 根据类型签名获得数据类型
  13.         switch(signature.charAt(0)) {
  14.             case 'Z':
  15.                 type = Boolean.TYPE;
  16.                 break;
  17.             case 'B':
  18.                 type = Byte.TYPE;
  19.                 break;
  20.             case 'C':
  21.                 type = Character.TYPE;
  22.                 break;
  23.             case 'S':
  24.                 type = Short.TYPE;
  25.                 break;
  26.             case 'I':
  27.                 type = Integer.TYPE;
  28.                 break;
  29.             case 'J':
  30.                 type = Long.TYPE;
  31.                 break;
  32.             case 'F':
  33.                 type = Float.TYPE;
  34.                 break;
  35.             case 'D':
  36.                 type = Double.TYPE;
  37.                 break;
  38.             case 'L':
  39.             case '[':
  40.                 type = Object.class;
  41.                 break;
  42.             default:
  43.                 throw new IllegalArgumentException("illegal signature");
  44.         }
  45.     }

构造函数（给予映射的字段，是否共享控制，是否显示实际类型））

  1.     ObjectStreamField(Field field, boolean unshared, boolean showType) {
  2.         this.field = field;
  3.         this.unshared = unshared;
  4.         name = field.getName();
  5.         // 获取字段类型
  6.         Class<?> ftype = field.getType();
  7.         // 显示类型为true的场合，返回字段类型，否则返回Object类型
  8.         type = (showType || ftype.isPrimitive()) ? ftype : Object.class;
  9.         // 获取类型对应的签名
  10.         signature = getClassSignature(ftype).intern();
  11.     }

内部方法

getField()方法

  1. // 获取允许反序列化的字段
  2. Field getField() {
  3.     return field;
  4. }

getName()方法

  1. // 返回字段的名称
  2. public String getName() {
  3.     return name;
  4. }

getType()方法

  1.     // 返回字段的类型
  2.     @CallerSensitive
  3.     public Class<?> getType() {
  4.         // 获得控制台安全管理器
  5.         if(System.getSecurityManager() != null) {
  6.             // 获得调用映像
  7.             Class<?> caller = Reflection.getCallerClass();
  8.             // 判定两个类型的ClassLoader是否相等或者为祖先关系（caller为type的祖先）
  9.             if(ReflectUtil.needsPackageAccessCheck(caller.getClassLoader(), type.getClassLoader())) {
  10.                 // 如果该类型调用不可访问的包则抛出SecurityException
  11.                 ReflectUtil.checkPackageAccess(type);
  12.             }
  13.         }
  14.         return type;
  15.     }

image.png

getSignature()方法

  1.     // 返回字段签名
  2.     String getSignature() {
  3.         if(signature != null) {
  4.             return signature;
  5.         }
  7.         String sig = typeSignature;
  8.         // This lazy calculation is safe since signature can be null iff one
  9.         // of the public constructors are used, in which case type is always
  10.         // initialized to the exact type we want the signature to represent.
  11.         if(sig == null) {
  12.             // 获取类型对应的签名
  13.             typeSignature = sig = getClassSignature(type).intern();
  14.         }
  16.         return sig;
  17.     }
  19.     // 获取类型对应的签名
  20.     static String getClassSignature(Class<?> cl) {
  21.         // 基本类型的场合
  22.         if(cl.isPrimitive()) {
  23.             return getPrimitiveSignature(cl);
  24.         } else {
  25.             // 非基本类型的场合
  26.             return appendClassSignature(new StringBuilder(), cl).toString();
  27.         }
  28.     }
  30.     // 拼接类型签名
  31.     static StringBuilder appendClassSignature(StringBuilder sbuf, Class<?> cl) {
  32.         // 获取数组类型
  33.         while(cl.isArray()) {
  34.             sbuf.append('[');
  35.             cl = cl.getComponentType();
  36.         }
  38.         // 基本类型
  39.         if(cl.isPrimitive()) {
  40.             sbuf.append(getPrimitiveSignature(cl));
  41.         } else {
  42.             // 对象类型
  43.             sbuf.append('L').append(cl.getName().replace('.', '/')).append(';');
  44.         }
  46.         return sbuf;
  47.     }
  49.     // 基本类型的签名
  50.     private static String getPrimitiveSignature(Class<?> cl) {
  51.         if(cl == Integer.TYPE) {
  52.             return "I";
  53.         } else if(cl == Byte.TYPE) {
  54.             return "B";
  55.         } else if(cl == Long.TYPE) {
  56.             return "J";
  57.         } else if(cl == Float.TYPE) {
  58.             return "F";
  59.         } else if(cl == Double.TYPE) {
  60.             return "D";
  61.         } else if(cl == Short.TYPE) {
  62.             return "S";
  63.         } else if(cl == Character.TYPE) {
  64.             return "C";
  65.         } else if(cl == Boolean.TYPE) {
  66.             return "Z";
  67.         } else if(cl == Void.TYPE) {
  68.             return "V";
  69.         } else {
  70.             throw new InternalError();
  71.         }
  72.     }

getTypeCode()方法

  1.     // 返回字段签名
  2.     public char getTypeCode() {
  3.         return getSignature().charAt(0);
  4.     }

getTypeString()方法

  1.     // 返回字段签名，对于基本类型，返回null
  2.     public String getTypeString() {
  3.         return isPrimitive() ? null : getSignature();
  4.     }

getOffset()方法

  1.     // 返回字段的偏移量
  2.     public int getOffset() {
  3.         return offset;
  4.     }

setOffset()方法

  1.     // 设置字段的偏移量
  2.     protected void setOffset(int offset) {
  3.         this.offset = offset;
  4.     }

isPrimitive()方法

  1.     // 当前字段是否为基本类型
  2.     public boolean isPrimitive() {
  3.         // 返回字段签名
  4.         char tcode = getTypeCode();
  5.         return ((tcode != 'L') && (tcode != '['));
  6.     }

isUnshared()方法

  1.     // 判断当前字段是否非共享
  2.     public boolean isUnshared() {
  3.         return unshared;
  4.     }