How can I serialize Jackson's JsonNode object? - memcached

I am replacing an in-house caching system with memcached but memcached client cannot cache the JsonNode objects since they don't implement Serializable.
Is there any way you can achieve serializing a JsonNode object? Does Jackson provide Serializable equivalent of this class?

JSON is best serialized by writing it out as bytes. In Jackson, it is done using ObjectMapper, for example by:
byte[] raw = objectMapper.writeValueAsBytes(root);
MemCache does not really need Serializable since it's all raw bytes; although Java clients may try to be helpful and handle serialization.

Related

Conversion of JSON to Java Pojo using MapStruct

How to convert an incoming JSON object structure to Java Pojo using mapstruct?
The incoming JSON response object structure might be different as per the configuration.
Thanks.
For a moment MapStruct hasn't this functionality. I know, that they are working on mapping from object to JSON. Mb they are also working on opposite conversion.

Kafka Streams: POJO serialize/deserialize backward compatibility

Can the serialVersionUID be defined in the class that extends the Kafka interface Serializer/Deserializer (org.apache.kafka.common.serialization), similar to the one we implement with Serializable? Would we face exception - NotSerializableException, during Java/Kafka upgrade?
For example, in KTable the key/value is serialized with a custom class object. So, if we persisted some data and if any upgrade takes place for either Kafka OR Java OR both, will we be able to to read (deserialize) the key/value, that was persisted prior to the upgrade, without any backward compatibility constraints?
Reference:
What is a serialVersionUID and why should I use it?
If you write a custom Kafka Serializer/Deserializer there is no need to specify Java's serialVersionUID. You can still do it, but it would be unused.
The purpose of Java's serialVersionUID is to use Java's built in serialization mechanism. But this mechanism is not used when you implement a custom Serializer/Deserializer for Kafka.

EventStore - issues integrating with protobuf-net

I was looking at using EventStore with SQL Server for the data storage. Most of the performance hit is with SQL Server actually storing the data, and there is a lot of memory allocated in the web server as well.
It turns out it all boils down to the Serialization of the headers (from CommonDomain's EventStoreRepository class) and of the EventMessage (from EventStore).
So I tried to switch from the Binary Serializer to the Protobuf-net one. But the types that need serialization do not have the required attributes to be properly serialized.
Is it possible to use protobuf-net with EventStore + CommonDomain? Has anyone done it?

Using RPC serialization/deserialization mechanism built in GWT

I am developing GWT offline application using HTML5 Local Storage. I would like to cache/store the transfer objects using com.google.gwt.storage.client.Storage (introduced in version 2.3). But the problem is that as for now (version 2.3) the Storage can only save the string values.
Is there any possibility to use GWT's built in rpc serialization/deseralization mechanism from client side code? So that I will be able to serialize transfer objects and store them in Local Storage and retrieve them when needed and deserialize the content.
GWT Docs have this to say:
Local Storage is String Storage
HTML5 local storage saves data in
string form as key-value pairs. If the data you wish to save is not
string data, you are responsible for conversion to and from string
when using LocalStorage. For proxy classes used with the GWT
RequestFactory, you can use RequestFactory#getSerializer() to do
string serializing. For non-proxy objects, you could use JSON
stringify and parse.
EDIT:
RequestFactory#getSerializer() returns an implementation of ProxySerializer. But
ProxySerializer Serializes graphs of EntityProxy objects. A
ProxySerializer is associated with an instance of a ProxyStore when it
is created via RequestFactory.getSerializer(ProxyStore).
So you cannot use it to serialize arbitrary objects. Only EntityProxy objects can be serialized this way. GWT documentation does not mention any method for doing such serialization for non-EntityProxy objects, so I think it is safe to assume that there is no ready-made solution for doing this so far. For non-EntityProxy objects, GWT docs (quoted above) recommend using JSON serialization.

Sending persisted JDO instances over GWT-RPC

I've just started learning Google Web Toolkit and finished writing the Stock Watcher tutorial app.
Is my thinking correct that if one wants to persist a business object (like a Stock) using JDO and send it back and forth to/from the client over RPC then one has to create two separate classes for that object: One with the JDO annotations for persisting it on the server and another which is serialisable and used over RPC?
I notice the Stock Watcher has separate classes and I can theorise why:
Otherwise the gwt compiler would try
to generate javascript for everything
the persisted class referenced like
JDO and com.google.blah.users.User, etc
Also there may be logic on the server-side
class which doesn't apply to the client
and vice-versa.
I just want to make sure I'm understanding this correctly. I don't want to have to create two versions of all my business object classes which I want to use over RPC if I don't have to.
The short answer is: you don't need to create duplicate classes.
I recommend that you take a look from the following google groups discussion on the gwt-contributors list:
http://groups.google.com/group/google-web-toolkit-contributors/browse_thread/thread/3c768d8d33bfb1dc/5a38aa812c0ac52b
Here is an interesting excerpt:
If this is all you're interested in, I
described a way to make GAE and
GWT-RPC work together "out of the
box". Just declare your entities as:
#PersistenceCapable(identityType =
IdentityType.APPLICATION, detachable
= "false") public class MyPojo implements Serializable { }
and everything will work, but you'll
have to manually deal with
re-attachment when sending objects
from the client back to the server.
You can use this option, and you will not need a mirror (DTO) class.
You can also try gilead (former hibernate4gwt), which takes care of some details within the problems of serializing enhanced objects.
Your assessment is correct. JDO replaces instances of Collections with their own implementations, in order to sniff when the object graph changes, I suppose. These implementations are not known by the GWT compiler, so it will not be able to serialize them. This happens often for classes that are composed of otherwise GWT compliant types, but with JDO annotations, especially if some of the object properties are Collections.
For a detailed explanation and a workaround, check out this pretty influential essay on the topic: http://timepedia.blogspot.com/2009/04/google-appengine-and-gwt-now-marriage.html
I finally found a solution. Don't change your object at all, but for the listing do it this way:
List<YourCustomObject> secureList=(List<YourCustomObject>)pm.newQuery(query).execute();
return new ArrayList<YourCustomObject>(secureList);
The actual problem is not in Serializing the Object... the problem is to Serialize the Collection class which is implemented by Google and is not allowed to Serialize out.
You do not have to create two versions of the domain model.
Here are two tips:
Use a String encoded key, not the Appengine Key class.
pojo = pm.detachCopy(pojo)
...will remove all the JDO enhancements.
You don't have to create separate instances at all, in fact you're better off not doing it. Your JDO objects should be plain POJOs anyway, and should never contain business logic. That's for your business layer, not your persistent objects themselves.
All you need to do is include the source for the annotations you are using and GWT should compile your class just fine. Also, you want to avoid using libraries that GWT can't compile (like things that use reflection, etc.), but in all the projects I've done this has never been a problem.
I think that a better format to send objects through GWT is through JSON. In this case from the server a JSON string would be sent which would then have to be parsed in the client. The advantage is that the final Javascript which is rendered in the browser has a smaller size. thus causing the page to load faster.
Secondly to send objects through GWT, the objects should be serializable. This may not be the case for all objects
Thirdly GWT has inbuilt functions to handle JSON... so no issues on the client end