@ManyToOne and @BatchSize
hibernate, hibernate-annotations, hibernate-mapping, java
Solution
`@ManyToOne` associated with `@BatchSize` could make sense only if the corresponding field is marked as `lazy` (`lazy=true`).
Indeed, if the field is not `lazy`, it's by definition already loaded since the enclosing entity is loaded, so the problem of database calls doesn't apply.
Imagine a `Person` class who has a collection of `ShoesPair` element (`ShoesPair`.class) and within this one is present an `owner` field marked as lazy (since optional and not really bringing an important information when retrieving a specific pair of shoes).
One wants to iterate through 25 pair of shoes (25 `ShoesPair` objects) in order to retrieve their owner.
If the `owner` field (corresponding to one person) is only annotated with `@ManyToOne`, there would be 25 select to database.
However, if annoted with `@BatchSize(size=5)`, there would be merely 5 calls and so increasing performance.
From the Hibernate documentation, it is precised that batch size does not only apply with collections:
You can also enable batch fetching of collections.
Hibenate mentions especially `@OneToMany` cases, because these one are applied with fields that are in 90% of cases marked as `lazy`.
Problem
I found in some old code strange thing (at least for me). The field which is annotated `@ManyToOne` is also annotated with `@BatchSize`. I always thought that `@BatchSize` annotation only affects when annotated at class level or on a collection (`@OneToMany`) and affects pre-fetching when iterating. But maybe I am wrong and annotating `@ManyToOne` with `@BatchSize` affects something. I can't find the answer in the documentation. Does annotating `@ManyToOne` with `@BatchSize` have sense?