A very commonly encountered and annoying limitation of Hibernate is that it can't proxy nullable one-to-one relationships. The rationale is that the reference should be null if there is no associated object but a proxy is always non-null, so Hibernate doesn't know if it can use a proxy until it performs the necessary join, at which point it may as well fetch the associated object.

However, I have seen people hack around this limitation by mapping one-to-ones as one-to-manys and having the application enforce that the collection has at most one element. Such a hack can offer much-improved performance at the cost of some ugliness that can be encapsulated in the domain object (if mapping by field), and thus the benefit sometimes outweighs the cost. It seems that a "better" solution would be to have Hibernate drop a "reference" object into the owning object. The reference object would contain a nullable reference to the associated object and would provide the necessary indirection to avoid needing to load the referenced object upfront.

One principle of Hibernate is that the domain model should consist of POJOs, and thus an org.hibernate.Reference shouldn't pollute domain objects. Instead, why not simply use a reference class built into the standard library, like AtomicReference? Then you could write the following proxyable one-to-one: