I'm still a little confused about UserType, and when it is necessary, and how to implement it, and am hoping somebody could just scan the following and see if I'm on the right track.

If I have the following class:



Is creating my own helper class that implements UserType the easiest way of persisting objects of this type, or am I missing an easier solution?

If that is the simplest solution, does the following look like the correct mapping for this class?



thanks very much...

The mapping should be like


Where PropertiesType is you helper UserType which knows how to persist the properties into a database field.

Thanks very much for the help, Michael. I was thinking the UserType was responsible for persisting the whole object, but I see now that it's just responsible for persisting an object field to a database field, which makes sense now that I think about it.

I've also just discovered an easier solution, for anybody else reading this thread later. The following mapping works fine without needing to create a UserType at all:



The difference is that I defined the database column as VARBINARY instead of VARCHAR, and I declared the hibernate type as serializable. Hibernate seems to take care of everything else required, as long as the object's class implements java.io.Serializable (which java.util.Properties, like most Java classes, does).

I asked another question once before about persisting an org.dom4j.Document, and was told to use UserType by a Hibernate developer. I'm curious why I haven't seen the serializable approach recommended. Is there some big limitation to the approach above, or some reason why for simple serializable classes it is better to do it via a user type than just to declare it as serializable? Not defining a UserType for every custom class is much less work, but maybe I'm overlooking something.

thanks....

If in the future you change the code for the class you have serialized (say add some fields), the old serialized objects in the database may not deserialize, unless you take specific measures to ensure that all future versions of your class can deserialize old version (in general this is a non-trivial thing to do).

Querying on the properties of a serialized object in the database is not possible (as far as I know).

A serialized object stored in the database cannot be used by a non-Java program.

These are just a few of the possible gotchas...

In your case, I believe java.util.Properties serializes into a form that is pretty future proof, so it just may work depending on your needs. But, I'd still say no if one of my developers tried to do that, as a matter of principle.

--gus

Thanks for the explanation, Gus. they're all very good points, and good reasons to define a UserType. In this case, I don't need to query the database on anything but id, so that isn't a concern, but it would certainly be better to persist as varchar using the standard Properties.store() format so that there is no Java or class-version dependency.

cheers..