An object that doesn’t contain all of the data you need but knows how to get it.


Say you have a parent and that parent has a collection of children. Hibernate now can “lazy-load” the children, which means that it does not actually load all the children when loading the parent. Instead, it loads them when requested to do so. You can either request this explicitly or, and this is far more common, hibernate will load them automatically when you try to access a child.

Lazy-loading can help improve the performance significantly since often you won’t need the children and so they will not be loaded.

Also beware of the n+1-problem. Hibernate will not actually load all children when you access the collection. Instead, it will load each child individually. When iterating over the collection, this causes a query for every child. In order to avoid this, you can trick hibernate into loading all children simultaneously, e.g. by calling parent.getChildren().size().

“Lazy loading” means that an entity will be loaded only when you actually accesses the entity for thefirst time.

The pattern is like this:

public Entity getEntity() {
    if (entity == null) {
        entity = loadEntity();
    return entity;

This saves the cost of preloading/prefilling all the entities in a large dataset beforehand while you after all actually don’t need all of them.

In Hibernate, you can configure to lazily load a collection of child entities. The actual lazy loading is then done inside the methods of the PersistentSet which Hibernate uses “under the hoods” to assign the collection of entities as Set.


public class Parent {
    private Set<Child> children;

    public Set<Child> getChildren() {
        return children;


public void doSomething() {
    Set<Child> children = parent.getChildren(); // Still contains nothing.

    // Whenever you call one of the following (indirectly), 
    // Hibernate will start to actually load and fill the set.