JPA Buddy
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

Persistence top

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

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.

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!