announcement - icon

JPA can behave very differently depending on the exact circumstances under which it is used. Code that works in our local environment or in staging performs very poorly (or even flat out fails) when thrown against real-scale databases in production environments.

Debugging these JPA issues in production is pretty difficult - existing APMs don’t provide enough granular insights at the code level, and tracking every single place someone queried entities one by one instead of in bulk can be a grueling, time-consuming task.

Lightrun is a new approach to debugging in production. Using Lightrun’s Logs and Snapshots, you can now get debugger-level granularity in production without opening inbound ports, redeploying, restarting, or even stropping the running application.

In addition, instrumenting Lightrun Metrics at runtime allows you to track down persistence issues securely and in real-time. Want to see it in action? Check out our 2-minute tutorial for debugging JPA performance issues in production using Lightrun:

>> Debugging Spring Persistence and JPA Issues Using Lightrun

1. Overview

We usually don't need to access the EntityManager directly when working on a Spring Data application. However, sometimes we may want to access it, for example, to create custom queries or to detach entities.

In this short tutorial, we'll see how to access the EntityManager by extending a Spring Data Repository.

2. Access EntityManager with Spring Data

We can get the EntityManager by creating a custom repository that extends, for instance, a built-in JpaRepository.

Firstly, let's define an Entity, for example, for the users we want to store in a database:

public class User {
    private Long id;
    private String name;
    private String email;
    // ...

We don't have direct access to the EntityManager in a JpaRepository. Therefore, we need to create our own.

Let's create one with a custom find method:

public interface CustomUserRepository {
    User customFindMethod(Long id);

Using @PeristenceContext, we can inject the EntityManager in the implementation class:

public class CustomUserRepositoryImpl implements CustomUserRepository {

    private EntityManager entityManager;

    public User customFindMethod(Long id) {
        return (User) entityManager.createQuery("FROM User u WHERE = :id")
          .setParameter("id", id)

Likewise, we can use the @PersistenceUnit annotation, in which case we'll access the EntityManagerFactory and, from it, the EntityManager.

Finally, let's create a Repository that extends both the JpaRepository and CustomRepository:

public interface UserRepository extends JpaRepository<User, Long>, CustomUserRepository {

In addition, we can make a Spring Boot application and test to check everything is tied up and working as expected:

@SpringBootTest(classes = CustomRepositoryApplication.class)
class CustomRepositoryUnitTest {

    private UserRepository userRepository;

    public void givenCustomRepository_whenInvokeCustomFindMethod_thenEntityIsFound() {
        User user = new User();
        user.setEmail("[email protected]");

        User persistedUser =;

        assertEquals(persistedUser, userRepository.customFindMethod(user.getId()));

3. Conclusion

In this article, we looked at a quick example of accessing the EntityManager in a Spring Data application.

We can access the EntityManager in a custom repository and still use our Spring Data Repository by extending its functionality.

As always,  the code for these examples is available over on GitHub.

Persistence bottom
Get started with Spring Data JPA through the reference Learn Spring Data JPA course: >> CHECK OUT THE COURSE
Persistence footer banner
Comments are closed on this article!