Fabio Cepeda

Archive for the ‘Hibernate’ Category

Today, I experienced what I have read in this document from Hibernate a couple of months ago. The importance of the equals() and the hashCode() methods for hibernate when working with collections in persistent objects.

The problem:

I had an object that needed a many-to-many instead of a many-to-one relationship. Since last week I had the same requirement, I thought, this should be done in no time maybe from 1 to 3 hours after updating the DB and all the code that needed to be re-written. Well, I had a tough time finding the reason for something awkward that was happening to this piece of code. I guess bugs are hard to find when they are not part of the code that you are changing directly or when you expect certain things in place.


  1. If I inserted records in the join table directly the page was rendered correctly with all the collection elements. No problem here.
  2. When the form was submitted the collection elements disappear, the same behavior happened when adding a new element to the collection through jQuery
  3. When a validation error occurred and the collection had elements the form was rendered with empty collection elements.

Can you guess what was the problem? In my search of this error I double check the whole code: JSP, the controller, the mappings, the hibernate code and the POJO. Initially, I focused in the controller and the JSP because it was what I change the most. By the way, this application is based on Appfuse ant it uses SpringMVC. I noticed that the form controller was not calling the formBackingObject() after the form was submitted successfully, but I could not figure out why. Check the settings on the controller and I did not find anything unusual.

Check the hibernate mapping and everything was ok. It was ok because it showed the collections when it was added directly to the DB and it did not any hibernate errors, the entity was getting at the hibernate method with correct elements in the collection. After this two observations I knew the problem was lower in the POJO itself.

Well, finally I checked the persitent entity completely and what I found was that the POJO did not have neither equals() nor hashCode() implemented, and since this application uses OpenSessionInViewInterceptor that is one session-per-request all the awkwardness made sense.

After implementing this methods everything worked ok.

The lesson learned:

  • Always give a quick check to the basics, check for equals, hashCode and toString methods in your POJOs.
  • Hibernate uses the session to identify objects. The collection was shown correctly the first time one request one hibernate session and then session closed, but at the second request at form submission new hibernate session new request and then weird stuff happening because Hibernate was not able to tell if that object on the form was the same as the one previously fetched from the DB.
  • Hibernate uses this session to be able to move objects in and out of memory and that is way equals and hashCode are important.
  • If you want to store an object List, Map, or Set then it is a requirement to implement equals() and hashCode(), so they obey the contract from the specification.

The good thing for me is once I learned this way is really hard to forget.



I develop a java web application that uses a lot of type objects. For example, Object Visit has a property state that could be Programmed, Done, Cancelled, etc… The current solution for this is to have a table in the DB representing the state of the visit and a FK from the table visit to the table with the states. Within the layers of the code the state is manage as an Entity with its own CRUD implemetation.

When you have a lot of object value types this could add up a lot tables in your DB and code in your application. In some cases I guess is ok to have CRUD functionality, but in others I wish the process could be shorter. For example: types that are not reusable and unique to a particular POJO. So, I was thinking of a way to be able to reduce some of the states or types using enum types throughout my application.

Today, I researched about how to map a JAVA 5 Enum type to a MySQL enum in order to be used with a web application that uses Spring.

Here, some of my findings:

I found these good article on how to deal with the Hibernate part, it seems straight forward:


For the Spring part, I guess it is just a matter of writing the PropertyEditor

Doubts still remaining:

Will that solution above, map the Enumeration to a enum type in MySQL? Does Hibernate supports this? Is it better to map the elements of an enumeration to another table in the DB or having it inside your main table as a MySQL enum is better?

Will mapping the JAVA enumeration to the MySQL enumeration saves time when adding a new type?

Here are some disadvanges:

From what I read, it seems you have to recompile your code when you have a JAVA enumeration and you want to add and extra element to it. In the current solution, you only have to add that value in the DB and Hibernate can deal with it without a recompile.

Some Advantages:

Enumeration could make your code cleaner making it easier to code tests for states and types comparissions. Surely it will be less verbose and easier to read.

I develop a web application using appfuse, springframework, and hibernate, MySQL . I had the following situation:

I needed to persiste a collection of unique integers for an object. Where the primary Id of the collection table was the primary key of the table mapped by Contacto.

public class Contacto implements java.io.Serializable {

private Integer contactoId; //Primary key of this object
Set private Set beneficiarioTitularDe = new HashSet(); // Collection of unique integers.

//Getters and setters omitted for simplicity

Here is the db table script

CREATE TABLE `beneficiariosprimariosinmuebles` (
`contactoID` int(10) unsigned NOT NULL default ‘0’,
`inmuebleID` int(10) unsigned NOT NULL default ‘0’,
PRIMARY KEY (`contactoID`, inmuebleID),
KEY `beneficiariosprimariosinmuebles_FKIndex1` (`contactoID`)

# Foreign keys for table propietariosinmuebles

ALTER TABLE `beneficiariosprimariosinmuebles`
ADD FOREIGN KEY (`contactoID`) REFERENCES `contactos` (`contactoID`) ON UPDATE NO ACTION;

Here is the mapping file of hibernate:

Trying to persist this kind of collection was a challenge in the case where the field inmuebleID was null because it was a primay key of my collection table in the database. Reason why I did this in the database was to assure unique integers in the DB. However, for some reason hibernate was not able to delete the record from the database because the inmuebleID was the primary key in the DB table.

The solution I came up with was to assure the Set did not have null values before calling the save method on the onBind method of my contoller.