bazel-0.11.1.tar_3.gz

 [](https://jenkins.inoio.de/job/kryo/) Kryo is a fast and efficient object graph serialization framework for Java. The goals of the project are speed, efficiency, and an easy to use API. The project is useful any time objects need to be persisted, whether to a file, database, or over the network. Kryo can also perform automatic deep and shallow copying/cloning. This is direct copying from object to object, not object->bytes->object. This documentation is for v2+ of Kryo. See [V1Documentation](https://github.com/EsotericSoftware/kryo/wiki/Documentation-for-Kryo-version-1.x) for v1.x. If you are planning to use Kryo for network communication, the [KryoNet](https://github.com/EsotericSoftware/kryonet) project may prove useful. ## Contents - [New in release 3.0.0](#new-in-release-300) - [Installation](#installation) - [Integration with Maven](#integration-with-maven) - [Using Kryo without Maven](#using-kryo-without-maven) - [Quickstart](#quickstart) - [IO](#io) - [Unsafe-based IO](#unsafe-based-io) - [Serializers](#serializers) - [Registration](#registration) - [Default serializers](#default-serializers) - [FieldSerializer](#fieldserializer) - [KryoSerializable](#kryoserializable) - [Class fields annotations](#class-fields-annotations) - [Java Serialization](#using-standard-java-serialization) - [Reading and writing](#reading-and-writing) - [References](#references) - [Object creation](#object-creation) - [Copying/cloning](#copyingcloning) - [Context](#context) - [Compression and encryption](#compression-and-encryption) - [Chunked encoding](#chunked-encoding) - [Compatibility](#compatibility) - [Interoperability](#interoperability) - [Stack size](#stack-size) - [Threading](#threading) - [Pooling Kryo instances](#pooling-kryo-instances) - [Logging](#logging) - [Scala](#scala) - [Objective-C](#objective-c) - [Benchmarks](#benchmarks) - [Projects using Kryo](#projects-using-kryo) - [Contact / Mailing list](#contact--mailing-list) ## New in release 3.0.0 The 3.0.0 release fixes many reported issues and improves stability and performance. The maven groupId is changed from `com.esotericsoftware.kryo` to `com.esotericsoftware`. The Unsafe-based IO serialization format was changed and is incompatible with previous versions (therefore the new major version), the standard serialization format is still compatible. See [ChangeLog](https://github.com/EsotericSoftware/kryo/blob/master/CHANGES.md) for more details about this release. ## Installation Kryo JARs are available on the [releases page](https://github.com/EsotericSoftware/kryo/releases) and at [Maven Central](http://search.maven.org/#browse|1975274176). Latest snapshots of Kryo including snapshot builds of master are in the [Sonatype Repository](https://oss.sonatype.org/content/repositories/snapshots/com/esotericsoftware/kryo/kryo). ### Integration with Maven To use the official release of Kryo, please use the following snippet in your pom.xml ```xml <dependency> <groupId>com.esotericsoftware</groupId> <artifactId>kryo</artifactId> <version>3.0.1</version> </dependency> ``` If you experience issues because you already have a different version of asm in your classpath, you can use the kryo-shaded jar which has its version of asm included, relocated in a different package: ```xml <dependency> <groupId>com.esotericsoftware</groupId> <artifactId>kryo-shaded</artifactId> <version>3.0.1</version> </dependency> ``` If you want to test the latest snapshot of Kryo, please use the following snippet in your pom.xml ```xml <repository> <id>sonatype-snapshots</id> <name>sonatype snapshots repo</name> <url>https://oss.sonatype.org/content/repositories/snapshots</url> </repository> <dependency> <groupId>com.esotericsoftware</groupId> <artifactId>kryo</artifactId> <version>3.0.1-SNAPSHOT</version> </dependency> ``` ### Using Kryo without Maven If you use Kryo without Maven, be aware that Kryo jar file has a couple of external dependencies, whose JARs you need to add to your classpath as well. These dependencies are [MinLog logging library](https://github.com/EsotericSoftware/minlog/) and [Objenesis library](https://code.google.com/p/objenesis/). ## Quickstart Jumping ahead to show how the library is used: ```java Kryo kryo = new Kryo(); // ... Output output = new Output(new FileOutputStream("file.bin")); SomeClass someObject = ... kryo.writeObject(output, someObject); output.close(); // ... Input input = new Input(new FileInputStream("file.bin")); SomeClass someObject = kryo.readObject(input, SomeClass.class); input.close(); ``` The Kryo class orchestrates serialization. The Output and Input classes handle buffering bytes and optionally flushing to a stream. The rest of this document details how this works and advanced usage of the library. ## IO The Output class is an OutputStream that writes data to a byte array buffer. This buffer can be obtained and used directly, if a byte array is desired. If the Output is given an OutputStream, it will flush the bytes to the stream when the buffer becomes full. Output has many methods for efficiently writing primitives and strings to bytes. It provides functionality similar to DataOutputStream, BufferedOutputStream, FilterOutputStream, and ByteArrayOutputStream. Because Output buffers when writing to an OutputStream, be sure to call `flush()` or `close()` after writing is complete so the buffered bytes are written to the underlying stream. The Input class is an InputStream that reads data from a byte array buffer. This buffer can be set directly, if reading from a byte array is desired. If the Input is given an InputStream, it will fill the buffer from the stream when the buffer is exhausted. Input has many methods for efficiently reading primitives and strings from bytes. It provides functionality similar to DataInputStream, BufferedInputStream, FilterInputStream, and ByteArrayInputStream. To read from a source or write to a target other than a byte array, simply provide the appropriate InputStream or OutputStream. ## Unsafe-based IO Kryo provides additional IO classes, which are based on the functionalities exposed by the sun.misc.Unsafe class. These classes are UnsafeInput, UnsafeOutput. They are derived from Kryo's Input and Output classes and therefore can be used as a drop-in replacement on those platforms, which properly support sun.misc.Unsafe. For the case you need to serialize to or deserialize from direct-memory ByteBuffers or even off-heap memory, there are two dedicated classes UnsafeMemoryInput and UnsafeMemoryOutput whose instances can be used for this purpose instead of the usual Input and Output classes. Using Unsafe-based IO may result in a quite significant performance boost (sometimes up-to an order of magnitude), depending on your application. In particular, it helps a lot when serializing large primitive arrays as part of your object graphs. ### ** DISCLAIMER ABOUT USING UNSAFE-BASED IO ** *Unsafe-based IO is not 100% compatible with Kryo's Input and Output streams when it comes to the binary format of serialized data.* This means that data written by Unsafe-based output streams can be read only by Unsafe-based input streams, but not by usual Input streams. The same applies on the opposite direction: data written by usual Output streams cannot be correctly read by Unsafe-based input streams. It should be safe to use Unsafe IO streams as long as both serialization and deserialization are using them and are executed on the same processor architecture (more precisely, if the endianness and internal representation of native integer and floating point types is the same). Unsafe IO was extensively tested on X86 hardwar