All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.esotericsoftware.kryo.serializers.CompatibleFieldSerializer Maven / Gradle / Ivy

Go to download

Fast, efficient Java serialization. This is the "main" kryo artifact, with a regular dependency on reflectasm.

There is a newer version: 5.6.2
Show newest version
/* Copyright (c) 2008-2018, Nathan Sweet
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
 * conditions are met:
 * 
 * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided with the distribution.
 * - Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

package com.esotericsoftware.kryo.serializers;

import static com.esotericsoftware.kryo.util.Util.*;
import static com.esotericsoftware.minlog.Log.*;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.KryoException;
import com.esotericsoftware.kryo.Registration;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.InputChunked;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.io.OutputChunked;
import com.esotericsoftware.kryo.util.ObjectMap;

/** Serializes objects using direct field assignment, providing both forward and backward compatibility. This means fields can be
 * added or removed without invalidating previously serialized bytes. Renaming or changing the type of a field is not supported.
 * Like {@link FieldSerializer}, it can serialize most classes without needing annotations.
 * 

* The forward and backward compatibility and serialization performance depend on * {@link CompatibleFieldSerializerConfig#setReadUnknownFieldData(boolean)} and * {@link CompatibleFieldSerializerConfig#setChunkedEncoding(boolean)}. Additionally, the first time the class is encountered in * the serialized bytes, a simple schema is written containing the field name strings. *

* Note that the field data is identified by name. If a super class has a field with the same name as a subclass, * {@link CompatibleFieldSerializerConfig#setExtendedFieldNames(boolean)} must be true. * @author Nathan Sweet */ public class CompatibleFieldSerializer extends FieldSerializer { static private final int binarySearchThreshold = 32; private CompatibleFieldSerializerConfig config; public CompatibleFieldSerializer (Kryo kryo, Class type) { this(kryo, type, new CompatibleFieldSerializerConfig()); } public CompatibleFieldSerializer (Kryo kryo, Class type, CompatibleFieldSerializerConfig config) { super(kryo, type, config); this.config = config; } public void write (Kryo kryo, Output output, T object) { int pop = pushTypeVariables(); CachedField[] fields = cachedFields.fields; ObjectMap context = kryo.getGraphContext(); if (!context.containsKey(this)) { if (TRACE) trace("kryo", "Write fields for class: " + type.getName()); context.put(this, null); output.writeVarInt(fields.length, true); for (int i = 0, n = fields.length; i < n; i++) { if (TRACE) trace("kryo", "Write field name: " + fields[i].name + pos(output.position())); output.writeString(fields[i].name); } } boolean chunked = config.chunked, readUnknownTagData = config.readUnknownFieldData; Output fieldOutput; OutputChunked outputChunked = null; if (chunked) fieldOutput = outputChunked = new OutputChunked(output, config.chunkSize); else fieldOutput = output; for (int i = 0, n = fields.length; i < n; i++) { CachedField cachedField = fields[i]; if (TRACE) log("Write", cachedField, output.position()); // Write the value class so the field data can be read even if the field is removed. if (readUnknownTagData) { Class valueClass = null; try { if (object != null) { Object value = cachedField.field.get(object); if (value != null) valueClass = value.getClass(); } } catch (IllegalAccessException ex) { } kryo.writeClass(fieldOutput, valueClass); if (valueClass == null) { if (chunked) outputChunked.endChunk(); continue; } cachedField.setCanBeNull(false); cachedField.setValueClass(valueClass); } cachedField.write(fieldOutput, object); if (chunked) outputChunked.endChunk(); } if (pop > 0) popTypeVariables(pop); } public T read (Kryo kryo, Input input, Class type) { int pop = pushTypeVariables(); T object = create(kryo, input, type); kryo.reference(object); CachedField[] fields = (CachedField[])kryo.getGraphContext().get(this); if (fields == null) fields = readFields(kryo, input); boolean chunked = config.chunked, readUnknownTagData = config.readUnknownFieldData; Input fieldInput; InputChunked inputChunked = null; if (chunked) fieldInput = inputChunked = new InputChunked(input, config.chunkSize); else fieldInput = input; for (int i = 0, n = fields.length; i < n; i++) { CachedField cachedField = fields[i]; if (readUnknownTagData) { Registration registration; try { registration = kryo.readClass(fieldInput); } catch (KryoException ex) { if (!chunked) throw new KryoException("Unable to read unknown data (unknown type). (" + getType().getName() + ")", ex); if (DEBUG) debug("kryo", "Unable to read unknown data (unknown type).", ex); inputChunked.nextChunk(); continue; } if (registration == null) { if (chunked) inputChunked.nextChunk(); continue; } Class valueClass = registration.getType(); if (cachedField == null) { // Read unknown data in case it is a reference. if (TRACE) trace("kryo", "Read unknown data, type: " + className(valueClass) + pos(input.position())); try { kryo.readObject(fieldInput, valueClass); } catch (KryoException ex) { if (!chunked) throw new KryoException( "Unable to read unknown data, type: " + className(valueClass) + " (" + getType().getName() + ")", ex); if (DEBUG) debug("kryo", "Unable to read unknown data, type: " + className(valueClass), ex); } if (chunked) inputChunked.nextChunk(); continue; } cachedField.setCanBeNull(false); cachedField.setValueClass(valueClass); } else if (cachedField == null) { if (!chunked) throw new KryoException("Unknown field. (" + getType().getName() + ")"); if (TRACE) trace("kryo", "Skip unknown field."); inputChunked.nextChunk(); continue; } if (TRACE) log("Read", cachedField, input.position()); cachedField.read(fieldInput, object); if (chunked) inputChunked.nextChunk(); } if (pop > 0) popTypeVariables(pop); return object; } private CachedField[] readFields (Kryo kryo, Input input) { if (TRACE) trace("kryo", "Read fields for class: " + type.getName()); int length = input.readVarInt(true); String[] names = new String[length]; for (int i = 0; i < length; i++) { names[i] = input.readString(); if (TRACE) trace("kryo", "Read field name: " + names[i]); } CachedField[] fields = new CachedField[length]; CachedField[] allFields = cachedFields.fields; if (length < binarySearchThreshold) { outer: for (int i = 0; i < length; i++) { String schemaName = names[i]; for (int ii = 0, nn = allFields.length; ii < nn; ii++) { if (allFields[ii].name.equals(schemaName)) { fields[i] = allFields[ii]; continue outer; } } if (TRACE) trace("kryo", "Unknown field will be skipped: " + schemaName); } } else { int low, mid, high, compare; int lastFieldIndex = allFields.length; outer: for (int i = 0; i < length; i++) { String schemaName = names[i]; low = 0; high = lastFieldIndex; while (low <= high) { mid = (low + high) >>> 1; compare = schemaName.compareTo(allFields[mid].name); if (compare < 0) high = mid - 1; else if (compare > 0) low = mid + 1; else { fields[i] = allFields[mid]; continue outer; } } if (TRACE) trace("kryo", "Unknown field will be skipped: " + schemaName); } } kryo.getGraphContext().put(this, fields); return fields; } public CompatibleFieldSerializerConfig getCompatibleFieldSerializerConfig () { return config; } /** Configuration for CompatibleFieldSerializer instances. */ static public class CompatibleFieldSerializerConfig extends FieldSerializerConfig { boolean readUnknownFieldData = true, chunked; int chunkSize = 1024; public CompatibleFieldSerializerConfig clone () { return (CompatibleFieldSerializerConfig)super.clone(); // Clone is ok as we have only primitive fields. } /** When false and encountering an unknown field, an exception is thrown or, if {@link #setChunkedEncoding(boolean) chunked * encoding} is enabled, the data is skipped. *

* When true, the type of each field value is written before the value. When an unknown field is encountered, an attempt to * read the data is made so if it is a reference then any other values in the object graph referencing that data can be * deserialized. If reading the data fails (eg the class is unknown or has been removed) then an exception is thrown or, if * {@link #setChunkedEncoding(boolean) chunked encoding} is enabled, the data is skipped. *

* In either case, if the data is skipped and {@link Kryo#setReferences(boolean) references} are enabled, then any * references in the skipped data are not read and further deserialization receive the wrong references and fail. *

* Default is true. */ public void setReadUnknownFieldData (boolean readUnknownTagData) { this.readUnknownFieldData = readUnknownTagData; } public boolean getReadUnknownTagData () { return readUnknownFieldData; } /** When true, fields are written with chunked encoding to allow unknown field data to be skipped. Default is false. * @see #setReadUnknownFieldData(boolean) */ public void setChunkedEncoding (boolean chunked) { this.chunked = chunked; if (TRACE) trace("kryo", "CompatibleFieldSerializerConfig setChunked: " + chunked); } public boolean getChunkedEncoding () { return chunked; } /** The maximum size of each chunk for chunked encoding. Default is 1024. */ public void setChunkSize (int chunkSize) { this.chunkSize = chunkSize; if (TRACE) trace("kryo", "CompatibleFieldSerializerConfig setChunkSize: " + chunkSize); } public int getChunkSize () { return chunkSize; } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy