When and Why JPA Entities Should Implement the Serializable Interface

When and why JPA entities should implement the Serializable interface?

This usually happens if you mix HQL and native SQL queries. In HQL, Hibernate maps the types you pass in to whatever the DB understands. When you run native SQL, then you must do the mapping yourself. If you don't, then the default mapping is to serialize the parameter and send it to the database (in the hope that it does understand it).

JPA, When exactly must Entity implement Serializable

As per this reference, valid Entity classes must be top-level classes, meaning that your inner class won't work.

Try pulling it out into a Entity class of its own, as it would be in a proper system, and persist again.

Do Hibernate table classes need to be Serializable?

Is there any actual need for these classes to implement Serializable?

The JPA spec (JSR 220) summarizes it pretty well (the same applies to Hibernate):

2.1 Requirements on the Entity Class

(...)

If an entity instance is to be passed by value as a detached object (e.g., through a remote interface), the entity class must implement the Serializable interface.

So, strictly speaking, this is not a requirement unless you need detached entities to be sent over the wire to another tier, to be migrated to another cluster node, to be stored in the HTTP session, etc.

If so, is there any tool to add a generated serialVersionUID field to a large number of classes at once

I think that you could batch this with the Serial version (Ant) Tasks.

It is required to implement Serializable interface when declaring a class?

Serialization is not a Spring-specific feature. You use serialization to transfer objects over the wire or store in the filesystem.

But according to effective java, serialization is dangerous and should not be used at all costs due to security holes.
Another disadvantage to serialization is when you release a new version of your class to the public you'll need to make sure to support the old deserialized class.

Moral of the story: Don't ever use serialization in your code. For more info read chapter 12 of effective java book.

When should we implement Serializable interface?

1. From What's this "serialization" thing all about?:

   It lets you take an object or group of
   objects, put them on a disk or send
   them through a wire or wireless
   transport mechanism, then later,
   perhaps on another computer, reverse
   the process: resurrect the original
   object(s). The basic mechanisms are to
   flatten object(s) into a
   one-dimensional stream of bits, and to
   turn that stream of bits back into the
   original object(s).

   Like the Transporter on Star Trek,
   it's all about taking something
   complicated and turning it into a flat
   sequence of 1s and 0s, then taking
   that sequence of 1s and 0s (possibly
   at another place, possibly at another
   time) and reconstructing the original
   complicated "something."

   So, implement the Serializable interface when you need to store a copy of the object, send them to another process which runs on the same system or over the network.

2. Because you want to store or send an object.

3. It makes storing and sending objects easy. It has nothing to do with security.

---

Related Topics