I would like to have a collection of child objects (here cat-kitten example) that are ordered. And keep their order on adding of new elements.
@Entity
public class Cat {
@OneToMany(mappedBy = "cat", cascade = CascadeType.ALL)
@OrderBy("name ASC")
private List<Kitten> kittens;
public void setKittens(List<Kitten> kittens) { this.kittens = kittens; }
public List<Kitten> getKittens() { return kittens; }
}
When I do cat.getKittens.add(newKitten)
the order by name will be broken.
Is it possible to let hibernate do the work of keeping the collection always ordered? By using the @Sort hibernate annotation?
@Sort has the disadvantage that it forces you to implement Comparable interface ...
What would be the right 'pure JPA' way to do that? Saving everything to DB and reloading it?
Makes it sense to combine @OrderBy and @Sort?
Update
Solution up to now is to combine @OrderBy and @Sort. @OrderBy leads to a ORDER BY
clause in the generated SQL which is better for performance (I assume that java is "sorting" again on inserting into the sorted container, but that should be much faster because the elements are already sorted)
@Sort together with an implemented Comparable
interface leads to a always sorted container. Note that I use now SortedSet
instead of List
. Here the updated Code:
@Entity
public class Cat {
@OneToMany(mappedBy = "cat", cascade = CascadeType.ALL)
@OrderBy("name ASC")
@Sort(type = SortType.NATURAL)
private SortedSet<Kitten> kittens;
public void setKittens(SortedSet<Kitten> kittens) { this.kittens = kittens; }
public SortedSet<Kitten> getKittens() { return kittens; }
}
If you want to avoid non-standard annotations, you could make kittens
use some sorted Collection
implementation. This would ensure that kittens
is always in sorted order. Something like this:
@Entity
public class Cat {
@OneToMany(mappedBy = "cat", cascade = CascadeType.ALL)
@OrderBy("name ASC")
private SortedSet<Kitten> kittens = new TreeSet<>();
}
Note that this approach also requires Kitten
to implement Comparable
(alternatively, you could pass a Comparator
to your TreeSet
constructor). Also, I'm using a Set
because I'm not aware of any standard sorted List
implementation and I'm assuming the Cat
does not have any clones in its litter =p.
Update:
I'm not sure how picky Hibernate is with its getter/setter definitions, but with EclipseLink I've been able to remove a setter entirely and wrap the List
returned by my getter in a Collections.unmodifiableList(...)
call. I then defined special methods for modifying the collection. You could do the same thing and force callers to use an add method that inserts elements in sorted order. If Hibernate complains about not having the getter/setter, maybe you could change the access modifier? I guess it comes down to how far you're willing to go to avoid non standard dependencies.