To initialize or not initialize JPA relationship mappings?

user_438319 0
Viewed 10156

In one to many JPA associations is it considered a best practice to initialize relationships to empty collections? For example.

@Entity
public class Order { 

   @Id
   private Integer id;

   // should the line items be initialized with an empty array list or not?
   @OneToMany(mappedBy="order")
   List<LineItem> lineItems = new ArrayList<>();

}

In the above example is it better to define lineItems with a default value of an empty ArrayList or not? What are the pros and cons?

openjpa eclipselink jpa hibernate java
4 Answers

I would rather prefer an utility like this:

public static <T> void forEach(Collection<T> values, Consumer<T> consumer) {
  if (values != null) values.stream().forEach(consumer);
}

and use it in code like:

Utils.forEach(entity.getItems(), item -> {
    // deal with item
});
user_106954540

My suggestion would be to not initialize them.

We ran into a situation where we initialized our collections, then retrieved same entity essentially twice successively. After the second retrieve, a lazy loaded collection that should have had data was empty after calling its getter. If we called the getter after the first retrieve, on the other hand, the collection did load the data. Theory is that the second retrieve got a managed entity from the session that had its collection initialized to empty and appeared to already be loaded or appeared to be modified, and therefore no lazy load took place. Solution was to NOT initialize the collections. This way we could retrieve the entity multiple times in the transaction and have its lazy loaded collections load correctly.

One more item to note: in a different environment, the behavior was different. The collection was lazy loaded just fine when calling the collection's getter on the entity that was retrieved the second time in the same transaction.

Unfortunately I don't have information on what was different between the two environments. It appears - although we didn't prove it 100% and didn't identify the implementations - that different JPA implementations work differently with respect to initialized collections.

We were using hibernate - just don't know which version we were using on each of the two platforms.

user_34164410
Related