FieldSerializer

java.lang.Object
- com.esotericsoftware.kryo.Serializer<T>
- - com.esotericsoftware.kryo.serializers.FieldSerializer<T>

All Implemented Interfaces:

java.util.Comparator<FieldSerializer.CachedField>

Direct Known Subclasses:

CompatibleFieldSerializer, TaggedFieldSerializer, VersionFieldSerializer
```
public class FieldSerializer<T>
extends Serializer<T>
implements java.util.Comparator<FieldSerializer.CachedField>
```
Serializes objects using direct field assignment. FieldSerializer is generic and can serialize most classes without any configuration. It is efficient and writes only the field data, without any extra information. It does not support adding, removing, or changing the type of fields without invalidating previously serialized bytes. This can be acceptable in many situations, such as when sending data over a network, but may not be a good choice for long term data storage because the Java classes cannot evolve. Because FieldSerializer attempts to read and write non-public fields by default, it is important to evaluate each class that will be serialized. If fields are public, bytecode generation will be used instead of reflection.

See Also:

Serializer, Kryo.register(Class, Serializer), VersionFieldSerializer, TaggedFieldSerializer, CompatibleFieldSerializer

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`FieldSerializer.Bind` Used to annotate fields with a specific Kryo serializer.
`static class`	`FieldSerializer.CachedField<X>` Controls how a field will be serialized.
`static interface`	`FieldSerializer.CachedFieldFactory`
`static interface`	`FieldSerializer.Optional` Indicates a field should be ignored when its declaring class is registered unless the `context` has a value set for the specified key.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) java.lang.Object`	`access`
`private FieldSerializerAnnotationsUtil`	`annotationsUtil`
`(package private) static FieldSerializer.CachedFieldFactory`	`asmFieldFactory`
`(package private) java.lang.Class`	`componentType`
`private boolean`	`copyTransient` If set, transient fields will be copied
`private FieldSerializer.CachedField[]`	`fields`
`private boolean`	`fieldsCanBeNull`
`private boolean`	`fixedFieldTypes`
`private java.lang.Class[]`	`generics` Concrete classes passed as values for type variables
`private Generics`	`genericsScope`
`private FieldSerializerGenericsUtil`	`genericsUtil`
`private boolean`	`hasObjectFields`
`private boolean`	`ignoreSyntheticFields`
`(package private) Kryo`	`kryo`
`(package private) static FieldSerializer.CachedFieldFactory`	`objectFieldFactory`
`protected java.util.HashSet<FieldSerializer.CachedField>`	`removedFields`
`private boolean`	`serializeTransient` If set, transient fields will be serialized
`private boolean`	`setFieldsAsAccessible`
`(package private) static java.lang.reflect.Method`	`sortFieldsByOffsetMethod`
`private FieldSerializer.CachedField[]`	`transientFields`
`(package private) java.lang.Class`	`type`
`(package private) java.lang.reflect.TypeVariable[]`	`typeParameters` type variables declared for this type
`(package private) static boolean`	`unsafeAvailable`
`(package private) static FieldSerializer.CachedFieldFactory`	`unsafeFieldFactory`
`private FieldSerializerUnsafeUtil`	`unsafeUtil`
`(package private) static java.lang.Class<?>`	`unsafeUtilClass`
`private boolean`	`useAsmEnabled` If set, ASM-backend is used.
`private boolean`	`useMemRegions` If set, adjacent primitive fields are written in bulk This flag may only work with Oracle JVMs, because they layout primitive fields in memory in such a way that primitive fields are grouped together.
`private boolean`	`varIntsEnabled` If set, this serializer tries to use a variable length encoding for int and long fields

Constructor Summary

Constructors
Constructor and Description
`FieldSerializer(Kryo kryo, java.lang.Class type)`
`FieldSerializer(Kryo kryo, java.lang.Class type, java.lang.Class[] generics)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private java.util.List<java.lang.reflect.Field>`	`buildValidFields(boolean transientFields, java.util.List<java.lang.reflect.Field> allFields, ObjectMap context, IntArray useAsm)`
`private java.util.List<java.lang.reflect.Field>`	`buildValidFieldsFromCachedFields(FieldSerializer.CachedField[] cachedFields, IntArray useAsm)`
`int`	`compare(FieldSerializer.CachedField o1, FieldSerializer.CachedField o2)`
`T`	`copy(Kryo kryo, T original)` Returns a copy of the specified object.
`protected T`	`create(Kryo kryo, Input input, java.lang.Class<T> type)` Used by `read(Kryo, Input, Class)` to create the new object.
`private void`	`createCachedFields(IntArray useAsm, java.util.List<java.lang.reflect.Field> validFields, java.util.List<FieldSerializer.CachedField> cachedFields, int baseIndex)`
`protected T`	`createCopy(Kryo kryo, T original)` Used by `copy(Kryo, Object)` to create the new object.
`private FieldSerializer.CachedFieldFactory`	`getAsmFieldFactory()`
`boolean`	`getCopyTransient()`
`FieldSerializer.CachedField`	`getField(java.lang.String fieldName)` Allows specific fields to be optimized.
`FieldSerializer.CachedField[]`	`getFields()` Get all fields controlled by this FieldSerializer
`java.lang.Class[]`	`getGenerics()` Get generic type parameters of the class controlled by this serializer.
`Generics`	`getGenericsScope()`
`Kryo`	`getKryo()`
`private FieldSerializer.CachedFieldFactory`	`getObjectFieldFactory()`
`java.lang.Class`	`getType()`
`private FieldSerializer.CachedFieldFactory`	`getUnsafeFieldFactory()`
`boolean`	`getUseAsmEnabled()`
`boolean`	`getUseMemRegions()`
`protected void`	`initializeCachedFields()`
`(package private) FieldSerializer.CachedField`	`newCachedField(java.lang.reflect.Field field, int fieldIndex, int accessIndex)`
`(package private) FieldSerializer.CachedField`	`newMatchingCachedField(java.lang.reflect.Field field, int accessIndex, java.lang.Class fieldClass, java.lang.reflect.Type fieldGenericType, java.lang.Class[] fieldGenerics)`
`T`	`read(Kryo kryo, Input input, java.lang.Class<T> type)` Reads bytes and returns a new object of the specified concrete type.
`protected void`	`rebuildCachedFields()` Called when the list of cached fields must be rebuilt.
`protected void`	`rebuildCachedFields(boolean minorRebuild)` Rebuilds the list of cached fields.
`void`	`removeField(FieldSerializer.CachedField removeField)` Removes a field so that it won't be serialized.
`void`	`removeField(java.lang.String fieldName)` Removes a field so that it won't be serialized.
`void`	`setCopyTransient(boolean setCopyTransient)`
`void`	`setFieldsAsAccessible(boolean setFieldsAsAccessible)` Controls which fields are serialized.
`void`	`setFieldsCanBeNull(boolean fieldsCanBeNull)` Sets the default value for `FieldSerializer.CachedField.setCanBeNull(boolean)`.
`void`	`setFixedFieldTypes(boolean fixedFieldTypes)` Sets the default value for `FieldSerializer.CachedField.setClass(Class)` to the field's declared type.
`void`	`setGenerics(Kryo kryo, java.lang.Class[] generics)` Sets the generic types of the field or method this serializer will be used for on the next call to read or write.
`void`	`setIgnoreSyntheticFields(boolean ignoreSyntheticFields)` Controls if synthetic fields are serialized.
`void`	`setUseAsm(boolean setUseAsm)` Controls whether ASM should be used.
`void`	`write(Kryo kryo, Output output, T object)` This method can be called for different fields having the same type.

Methods inherited from class com.esotericsoftware.kryo.Serializer
getAcceptsNull, isImmutable, setAcceptsNull, setImmutable

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Comparator
comparing, comparing, comparingDouble, comparingInt, comparingLong, equals, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

- Field Detail
  - kryo
```
final Kryo kryo
```
  - type
```
final java.lang.Class type
```
  - typeParameters
```
final java.lang.reflect.TypeVariable[] typeParameters
```
    type variables declared for this type
  - componentType
```
final java.lang.Class componentType
```
  - fields
```
private FieldSerializer.CachedField[] fields
```
  - transientFields
```
private FieldSerializer.CachedField[] transientFields
```
  - removedFields
```
protected java.util.HashSet<FieldSerializer.CachedField> removedFields
```
  - access
```
java.lang.Object access
```
  - fieldsCanBeNull
```
private boolean fieldsCanBeNull
```
  - setFieldsAsAccessible
```
private boolean setFieldsAsAccessible
```
  - ignoreSyntheticFields
```
private boolean ignoreSyntheticFields
```
  - fixedFieldTypes
```
private boolean fixedFieldTypes
```
  - useAsmEnabled
```
private boolean useAsmEnabled
```
    If set, ASM-backend is used. Otherwise Unsafe-based backend or reflection is used
  - unsafeUtil
```
private FieldSerializerUnsafeUtil unsafeUtil
```
  - genericsUtil
```
private FieldSerializerGenericsUtil genericsUtil
```
  - annotationsUtil
```
private FieldSerializerAnnotationsUtil annotationsUtil
```
  - generics
```
private java.lang.Class[] generics
```
    Concrete classes passed as values for type variables
  - genericsScope
```
private Generics genericsScope
```
  - varIntsEnabled
```
private boolean varIntsEnabled
```
    If set, this serializer tries to use a variable length encoding for int and long fields
  - useMemRegions
```
private boolean useMemRegions
```
    If set, adjacent primitive fields are written in bulk This flag may only work with Oracle JVMs, because they layout primitive fields in memory in such a way that primitive fields are grouped together. This option has effect only when used with Unsafe-based FieldSerializer.
    FIXME: Not all versions of Sun/Oracle JDK properly work with this option. Disable it for now. Later add dynamic checks to see if this feature is supported by a current JDK version.
  - copyTransient
```
private boolean copyTransient
```
    If set, transient fields will be copied
  - serializeTransient
```
private final boolean serializeTransient
```
    If set, transient fields will be serialized
    
    See Also:
    
    Constant Field Values
  - hasObjectFields
```
private boolean hasObjectFields
```
  - asmFieldFactory
```
static FieldSerializer.CachedFieldFactory asmFieldFactory
```
  - objectFieldFactory
```
static FieldSerializer.CachedFieldFactory objectFieldFactory
```
  - unsafeFieldFactory
```
static FieldSerializer.CachedFieldFactory unsafeFieldFactory
```
  - unsafeAvailable
```
static boolean unsafeAvailable
```
  - unsafeUtilClass
```
static java.lang.Class<?> unsafeUtilClass
```
  - sortFieldsByOffsetMethod
```
static java.lang.reflect.Method sortFieldsByOffsetMethod
```
- Constructor Detail
  - FieldSerializer
```
public FieldSerializer(Kryo kryo,
                       java.lang.Class type)
```
  - FieldSerializer
```
public FieldSerializer(Kryo kryo,
                       java.lang.Class type,
                       java.lang.Class[] generics)
```
- Method Detail
  - rebuildCachedFields
```
protected void rebuildCachedFields()
```
    Called when the list of cached fields must be rebuilt. This is done any time settings are changed that affect which fields will be used. It is called from the constructor for FieldSerializer, but not for subclasses. Subclasses must call this from their constructor.
  - rebuildCachedFields
```
protected void rebuildCachedFields(boolean minorRebuild)
```
    Rebuilds the list of cached fields.
    
    Parameters:
    
    minorRebuild - if set, processing due to changes in generic type parameters will be optimized
  - buildValidFieldsFromCachedFields
```
private java.util.List<java.lang.reflect.Field> buildValidFieldsFromCachedFields(FieldSerializer.CachedField[] cachedFields,
                                                                                 IntArray useAsm)
```
  - buildValidFields
```
private java.util.List<java.lang.reflect.Field> buildValidFields(boolean transientFields,
                                                                 java.util.List<java.lang.reflect.Field> allFields,
                                                                 ObjectMap context,
                                                                 IntArray useAsm)
```
  - createCachedFields
```
private void createCachedFields(IntArray useAsm,
                                java.util.List<java.lang.reflect.Field> validFields,
                                java.util.List<FieldSerializer.CachedField> cachedFields,
                                int baseIndex)
```
  - setGenerics
```
public void setGenerics(Kryo kryo,
                        java.lang.Class[] generics)
```
    Description copied from class: Serializer
    
    Sets the generic types of the field or method this serializer will be used for on the next call to read or write. Subsequent calls to read and write must not use this generic type information. The default implementation does nothing. Subclasses may use the information provided to this method for more efficient serialization, eg to use the same type for all items in a list.
    
    Overrides:
    
    setGenerics in class Serializer<T>
    
    generics - Some (but never all) elements may be null if there is no generic type information at that index.
  - getGenerics
```
public java.lang.Class[] getGenerics()
```
    Get generic type parameters of the class controlled by this serializer.
    
    Returns:
    
    generic type parameters or null, if there are none.
  - initializeCachedFields
```
protected void initializeCachedFields()
```
  - newCachedField
```
FieldSerializer.CachedField newCachedField(java.lang.reflect.Field field,
                                           int fieldIndex,
                                           int accessIndex)
```
  - newMatchingCachedField
```
FieldSerializer.CachedField newMatchingCachedField(java.lang.reflect.Field field,
                                                   int accessIndex,
                                                   java.lang.Class fieldClass,
                                                   java.lang.reflect.Type fieldGenericType,
                                                   java.lang.Class[] fieldGenerics)
```
  - getAsmFieldFactory
```
private FieldSerializer.CachedFieldFactory getAsmFieldFactory()
```
  - getObjectFieldFactory
```
private FieldSerializer.CachedFieldFactory getObjectFieldFactory()
```
  - getUnsafeFieldFactory
```
private FieldSerializer.CachedFieldFactory getUnsafeFieldFactory()
```
  - compare
```
public int compare(FieldSerializer.CachedField o1,
                   FieldSerializer.CachedField o2)
```
    Specified by:
    
    compare in interface java.util.Comparator<FieldSerializer.CachedField>
  - setFieldsCanBeNull
```
public void setFieldsCanBeNull(boolean fieldsCanBeNull)
```
    Sets the default value for FieldSerializer.CachedField.setCanBeNull(boolean). Calling this method resets the cached fields.
    
    Parameters:
    
    fieldsCanBeNull - False if none of the fields are null. Saves 0-1 byte per field. True if it is not known (default).
  - setFieldsAsAccessible
```
public void setFieldsAsAccessible(boolean setFieldsAsAccessible)
```
    Controls which fields are serialized. Calling this method resets the cached fields.
    
    Parameters:
    
    setFieldsAsAccessible - If true, all non-transient fields (inlcuding private fields) will be serialized and set as accessible if necessary (default). If false, only fields in the public API will be serialized.
  - setIgnoreSyntheticFields
```
public void setIgnoreSyntheticFields(boolean ignoreSyntheticFields)
```
    Controls if synthetic fields are serialized. Default is true. Calling this method resets the cached fields.
    
    Parameters:
    
    ignoreSyntheticFields - If true, only non-synthetic fields will be serialized.
  - setFixedFieldTypes
```
public void setFixedFieldTypes(boolean fixedFieldTypes)
```
    Sets the default value for FieldSerializer.CachedField.setClass(Class) to the field's declared type. This allows FieldSerializer to be more efficient, since it knows field values will not be a subclass of their declared type. Default is false. Calling this method resets the cached fields.
  - setUseAsm
```
public void setUseAsm(boolean setUseAsm)
```
    Controls whether ASM should be used. Calling this method resets the cached fields.
    
    Parameters:
    
    setUseAsm - If true, ASM will be used for fast serialization. If false, Unsafe will be used (default)
  - setCopyTransient
```
public void setCopyTransient(boolean setCopyTransient)
```
  - write
```
public void write(Kryo kryo,
                  Output output,
                  T object)
```
    This method can be called for different fields having the same type. Even though the raw type is the same, if the type is generic, it could happen that different concrete classes are used to instantiate it. Therefore, in case of different instantiation parameters, the fields analysis should be repeated. TODO: Cache serializer instances generated for a given set of generic parameters. Reuse it later instead of recomputing every time.
    
    Specified by:
    
    write in class Serializer<T>
    
    object - May be null if Serializer.getAcceptsNull() is true.
  - read
```
public T read(Kryo kryo,
              Input input,
              java.lang.Class<T> type)
```
    Description copied from class: Serializer
    
    Reads bytes and returns a new object of the specified concrete type.
    Before Kryo can be used to read child objects, Kryo.reference(Object) must be called with the parent object to ensure it can be referenced by the child objects. Any serializer that uses Kryo to read a child object may need to be reentrant.
    This method should not be called directly, instead this serializer can be passed to Kryo read methods that accept a serialier.
    
    Specified by:
    
    read in class Serializer<T>
    
    Returns:
    
    May be null if Serializer.getAcceptsNull() is true.
  - create
```
protected T create(Kryo kryo,
                   Input input,
                   java.lang.Class<T> type)
```
    Used by read(Kryo, Input, Class) to create the new object. This can be overridden to customize object creation, eg to call a constructor with arguments. The default implementation uses Kryo.newInstance(Class).
  - getField
```
public FieldSerializer.CachedField getField(java.lang.String fieldName)
```
    Allows specific fields to be optimized.
  - removeField
```
public void removeField(java.lang.String fieldName)
```
    Removes a field so that it won't be serialized.
  - removeField
```
public void removeField(FieldSerializer.CachedField removeField)
```
    Removes a field so that it won't be serialized.
  - getFields
```
public FieldSerializer.CachedField[] getFields()
```
    Get all fields controlled by this FieldSerializer
    
    Returns:
    
    all fields controlled by this FieldSerializer
  - getType
```
public java.lang.Class getType()
```
  - getKryo
```
public Kryo getKryo()
```
  - getUseAsmEnabled
```
public boolean getUseAsmEnabled()
```
  - getUseMemRegions
```
public boolean getUseMemRegions()
```
  - getCopyTransient
```
public boolean getCopyTransient()
```
  - createCopy
```
protected T createCopy(Kryo kryo,
                       T original)
```
    Used by copy(Kryo, Object) to create the new object. This can be overridden to customize object creation, eg to call a constructor with arguments. The default implementation uses Kryo.newInstance(Class).
  - copy
```
public T copy(Kryo kryo,
              T original)
```
    Description copied from class: Serializer
    
    Returns a copy of the specified object. The default implementation returns the original if Serializer.isImmutable() is true, else throws KryoException. Subclasses should override this method if needed to support Kryo.copy(Object).
    Before Kryo can be used to copy child objects, Kryo.reference(Object) must be called with the copy to ensure it can be referenced by the child objects. Any serializer that uses Kryo to copy a child object may need to be reentrant.
    This method should not be called directly, instead this serializer can be passed to Kryo copy methods that accept a serialier.
    
    Overrides:
    
    copy in class Serializer<T>
  - getGenericsScope
```
public final Generics getGenericsScope()
```

Class FieldSerializer<T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.esotericsoftware.kryo.Serializer

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Comparator

Field Detail

kryo

type

typeParameters

componentType

fields

transientFields

removedFields

access

fieldsCanBeNull

setFieldsAsAccessible

ignoreSyntheticFields

fixedFieldTypes

useAsmEnabled

unsafeUtil

genericsUtil

annotationsUtil

generics

genericsScope

varIntsEnabled

useMemRegions

copyTransient

serializeTransient

hasObjectFields

asmFieldFactory

objectFieldFactory

unsafeFieldFactory

unsafeAvailable

unsafeUtilClass

sortFieldsByOffsetMethod

Constructor Detail

FieldSerializer

FieldSerializer

Method Detail

rebuildCachedFields

rebuildCachedFields

buildValidFieldsFromCachedFields

buildValidFields

createCachedFields

setGenerics

getGenerics

initializeCachedFields

newCachedField

newMatchingCachedField

getAsmFieldFactory

getObjectFieldFactory

getUnsafeFieldFactory

compare

setFieldsCanBeNull

setFieldsAsAccessible

setIgnoreSyntheticFields

setFixedFieldTypes

setUseAsm

setCopyTransient

write

read

create

getField

removeField

removeField

getFields

getType

getKryo

getUseAsmEnabled

getUseMemRegions

getCopyTransient

createCopy

copy

getGenericsScope