How can I serialize/deserialize java.util.stream.Stream using Jackson?

Question

Assuming I have the following object

public class DataObjectA {
    private Stream<DataObjectB> dataObjectBStream;
}

How can I serialize them using Jackson?

Answer 1

As others have pointed out, you can only iterate once over a stream. If that works for you, you can use this to serialize:

new ObjectMapper().writerFor(Iterator.class).writeValueAsString(dataObjectBStream.iterator())

If you're using a Jackson version prior to 2.5, use writerWithType() instead of writerFor().

Answer 2

See https://github.com/FasterXML/jackson-modules-java8/issues/3 for the open issue to add java.util.Stream support to Jackson. There's a preliminary version of the code included. (edit: this is now merged and supported in 2.9.0).

Streaming support feels like it would work naturally/safely if the stream is the top level object you were (de)serializing, eg returning a java.util.stream.Stream<T> from a JAX-RS resource, or reading a Stream from a JAX-RS client.

A Stream as a member variable of a (de)serialized object, as you have in your example, is trickier, because it's mutable and single use:

private Stream<DataObjectB> dataObjectBStream;

Assuming it was supported, all of the caveats around storing references to streams would apply. You wouldn't be able to serialize the object more than once, and once you deserialized the wrapping object presumably it's stream member would retain a live connection back through the JAX-RS client and HTTP connection, which could create surprises.

Answer 3

You don’t.

A Stream is a single-use chain of operations and never meant to be persistent. Even storing it into an instance field like in your question is an indicator for a misunderstanding of it’s purpose. Once a terminal operation has been applied on the stream, it is useless and streams can’t be cloned. This, there is no point in remembering the unusable stream in a field then.

Since the only operations offered by Stream are chaining more operations to the pipeline and finally evaluating it, there is no way of querying its state such that it would allow to create an equivalent stream regarding its behavior. Therefore, no persistence framework can store it. The only thing a framework could do, is traversing the resulting elements of the stream operation and store them but that means effectively storing a kind of collection of objects rather than the Stream. Besides that, the single-use nature of a Stream also implies that a storage framework traversing the stream in order to store the elements had the side-effect of making the stream unusable at the same time.

If you want to store elements, resort to an ordinary Collection.

On the other hand, if you really want to store behavior, you’ll end up storing an object instance whose actual class implements the behavior. This still works with Streams as you can store an instance of a class which has a factory method producing the desired stream. Of course, you are not really storing the behavior but a symbolic reference to it, but this is always the case when you use an OO storage framework to store behavior rather than data.

Answer 4

I had below class having 2 elements one of them was Stream, had to annotate the getterStream method with@JsonSerializer and then override Serialize method, produces stream of JSON in my Response API:

public class DataSetResultBean extends ResultBean { private static final long serialVersionUID = 1L;

private final List<ComponentBean> structure;
private final Stream<DataPoint> datapoints;

private static class DataPointSerializer extends JsonSerializer<Stream<DataPoint>> 
{
    @Override
    public void serialize(Stream<DataPoint> stream, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException
    {
        gen.writeStartArray();
        try
        {
            stream.forEach(dp -> serializeSingle(gen, dp));
        }
        catch (UncheckedIOException e)
        {
            throw (IOException) e.getCause();
        }
        finally
        {
            stream.close();
        }
        gen.writeEndArray();
    }
    
    public synchronized void serializeSingle(JsonGenerator gen, DataPoint dp) throws UncheckedIOException
    {
        try
        {
            gen.writeStartObject();
            
            for (Entry<DataStructureComponent<?, ?, ?>, ScalarValue<?, ?, ?>> entry: dp.entrySet())
            {
                gen.writeFieldName(entry.getKey().getName());
                gen.writeRawValue(entry.getValue().toString());
            }
            
            gen.writeEndObject();
        }
        catch (IOException e)
        {
            throw new UncheckedIOException(e);
        }
    }
}

public DataSetResultBean(DataSet dataset)
{
    super("DATASET");
    
    structure = dataset.getMetadata().stream().map(ComponentBean::new).collect(toList());
    datapoints = dataset.stream();
}

public List<ComponentBean> getStructure()
{
    return structure;
}

@JsonSerialize(using = DataPointSerializer.class)
public Stream<DataPoint> getDatapoints()
{
    return datapoints;
}

}