Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

NPI – JPA Buddy – JPA (partner)
announcement - icon

JPA is huge! It covers nearly every aspect of communication between relational databases and the Java application and is deeply integrated into all major frameworks.

If you're using IntelliJ, JPA Buddy is super helpful. The plugin gently guides you through the subtleties of the most popular JPA implementations, visually reminds you of JPA features, generates code that follows best practices, and integrates intelligent inspections to improve your existing persistence code.

More concretely, it provides powerful tooling to generate Spring Data JPA repositories and methods, Flyway Versioned Migrations, Liquibase Differential Changelogs, DDL and SQL statements, DTO objects, and MapStruct interfaces.

Oh, and it actually generates JPA entities from an existing database and gradually update the data model as the database evolves! Yeah.

>> Become a lot more productive with JPA Buddy

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:

>> GET ACCESS NOW

November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:

>> GET ACCESS NOW

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

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().

As usual, the full source code that accompanies the tutorial is available over on GitHub.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:

>> GET ACCESS NOW

Persistence footer banner
Comments are closed on this article!