Proxy in Hibernate load() Method

1. Overview

In this tutorial, we’ll see what a proxy is in the context of Hibernate’s load() method.

For readers new to Hibernate, consider getting familiar with basics first.

2. A Brief Introduction To Proxies and load() Method

By definition, a proxy is “a function authorized to act as the deputy or substitute for another”.

This applies to Hibernate when we call Session.load() to create what is called an uninitialized proxy of our desired entity class.

Simply put, Hibernate subclasses our entity class, using the CGLib library. Other than the @Id method, the proxy implementation delegates all other property methods to the Hibernate session to populate the instance, somewhat like:

public class HibernateProxy extends MyEntity {
    private MyEntity target;

    public String getFirstName() {
        if (target == null) {
            target = readFromDatabase();
        }
        return target.getFirstName();
    }
}

This subclass will be the one to be returned instead of querying the database directly.

Once one of the entity methods is called, the entity is loaded and at that point becomes an initialized proxy.

3. Proxies and Lazy loading

3.1. A Single Entity

Let’s think about Employee as an entity. To begin, we’ll assume that it has no relation to any other tables.

If we use Session.load() to instantiate an Employee:

Employee albert = session.load(Employee.class, new Long(1));

Then Hibernate will create an uninitialized proxy of Employee. It will contain the ID that we gave it but otherwise will have no other values because we haven’t hit the database yet.

However, once we call a method on albert:

String firstName = albert.getFirstName();

Then Hibernate will query the employee database table for an entity with a primary key of 1, populating albert with his properties from the corresponding row.

If it fails to find a row, then Hibernate throws an ObjectNotFoundException.

3.2. One-to-Many Relationships

Now, let’s create a Company entity as well, where a Company has many Employees:

public class Company {
    private String name;
    private Set<Employee> employees;
}

If we this time use Session.load() on the company:

Company bizco = session.load(Company.class, new Long(1));
String name = bizco.getName();

Then the company’s properties are populated as before, except the set of employees is just a bit different.

See, we only queried for the company row, but the proxy will leave the employee set alone until we call getEmployees depending on the fetching strategy.

3.3. Many-to-One Relationships

The case is similar in the opposite direction:

public class Employee {
    private String firstName;
    private Company workplace;
}

If we use load() again:

Employee bob = session.load(Employee.class, new Long(2));
String firstName = bob.getFirstName();

bob will now be initialized, and actually, workplace will now be set to be an uninitialized proxy depending on the fetching strategy.

4. Lazy-ish Loading

Now, load() won’t always give us an uninitialized proxy. In fact, the Session java doc reminds us (emphasis added):

This method might return a proxied instance that is initialized on-demand, when a non-identifier method is accessed.

A simple example of when this can happen is with batch size.

Let’s say that we are using @BatchSize on our Employee entity:

@Entity
@BatchSize(size=5)
class Employee {
    // ...
}

And this time we have three employees:

Employee catherine = session.load(Employee.class, new Long(3));
Employee darrell = session.load(Employee.class, new Long(4));
Employee emma = session.load(Employee.class, new Long(5));

If we call getFirstName on catherine:

String cathy = catherine.getFirstName();

Then, actually, Hibernate may decide to load all three employees at once, turning all three into initialized proxies.

And then, when we call for darrell‘s first name:

String darrell = darrell.getFirstName();

Then Hibernate doesn’t hit the database at all.

5. Eager Loading

5.1. Using get()

We can also bypass proxies entirely and ask Hibernate to load the real thing using Session.get():

Employee finnigan = session.get(Employee.class, new Long(6));

This will call the database right away, instead of returning a proxy.

And actually, instead of an ObjectNotFoundException, it will return null if finnigan doesn’t exist.

5.2. Performance Implications

While get() is convenient, load() can be lighter on the database.

For instance, let’s say gerald is going to work for a new company:

Employee gerald = session.get(Employee.class, new Long(7));
Company worldco = (Company) session.load(Company.class, new Long(2));
employee.setCompany(worldco);        
session.save(employee);

Since we know that we are only going to change the employee record in this situation, calling load() for Company is sensible.

If we called get() on Company, then we’d have loaded all its data needlessly from the database.

6. Conclusion

In this article, we briefly learned how Hibernate proxies work and how this impacts the load method with entities and their relationships.

Also, we took a quick look at how load() differs from get().