Over a million developers have joined DZone.

Accessing the EntityManager From Spring Data JPA

DZone's Guide to

Accessing the EntityManager From Spring Data JPA

Learn how to access your EntityManager using a custom interface with Spring Data JPA as well as the benefits and drawbacks involved.

· Java Zone
Free Resource

Build vs Buy a Data Quality Solution: Which is Best for You? Gain insights on a hybrid approach. Download white paper now!

Spring Data JPA allows you to rapidly develop your data access layer through the use of Repository interfaces. Occasionally, you will need to access the EntityManager from Spring Data JPA. This post shows you how to access the EntityManager.


The purpose of the EntityManager is to interact with the persistence context. The persistence context will then manage entity instances and their associated lifecycle. This was covered in my blog post on the JPA Entity Lifecycle.

Spring Data JPA does an excellent job abstracting you from the EntityManager through its Repository interfaces:

But occasionally, you need to access the EntityManager.


An example of this is the refresh method. The refresh method refreshes the state of an instance from the database and overwrites the copy held by the EntityManager. This ensures the EntityManager manager has the most up to date version of the data

Spring Data JPA Example

Let's use the JPA object from my normal test ground:

@Table(name = "PARKRUNCOURSE")
public class ParkrunCourse {
    @Column(name = "PRCOURSE_ID")
    private Long courseId;
    @Column(name = "COURSENAME")
    private String courseName;
    @Column(name = "URL")
    private String url;
    @Column(name = "AVERAGETIME")
    private Long averageTime;

And it's associated repository:

public interface ParkrunCourseRepository extends CrudRepository {

This is a standard implementation of a Spring repository, with the CrudRepository taking ParkrunCourse, and its key type Long

Create Custom Interfaces and Implementation

The first step is to define a new interface with the same signature as the underlying EntityManager method we want to access:

public interface ParkrunCourseRepositoryCustom {
    void refresh(ParkrunCourse parkrunCourse);

The key point is the custom implementation must end with “Custom” — unless overridden in Spring Data configuration.

Next, we provide the implementation for this interface and inject the EntityManager:

import javax.persistence.PersistenceContext;
import javax.persistence.EntityManager;
import com.glenware.springboot.form.ParkrunCourse;
import org.springframework.transaction.annotation.Transactional;
public class ParkrunCourseRepositoryImpl implements ParkrunCourseRepositoryCustom {
    private EntityManager em;
    public void refresh(ParkrunCourse parkrunCourse) {

We must end our implementation name with “Impl”.

We then change the ParkrunCourseRepository interface to:

public interface ParkrunCourseRepository extends CrudRepository, ParkrunCourseRepositoryCustom {

We can then refresh our JPA object:

private ParkrunCourseRepository parkrunCourseRepository;
ParkrunCourse parkrunCourse = parkrunCourseRepository.findOne(1L);
// Do some work & in the mean time the database has been updated by a batch job
// refresh object and now up to date


This approach shows how to access the EntityManager using Spring Data JPA. The advantage of this approach is you can access the EntityManager for a specific JPA implementation. The disadvantage of this approach is that you would need to repeat this task for each JPA implementation. The next post looks at a more generic approach to the custom repository implementation, allowing other JPA objects to benefit.

Build vs Buy a Data Quality Solution: Which is Best for You? Maintaining high quality data is essential for operational efficiency, meaningful analytics and good long-term customer relationships. But, when dealing with multiple sources of data, data quality becomes complex, so you need to know when you should build a custom data quality tools effort over canned solutions. Download our whitepaper for more insights into a hybrid approach.

java ,spring data jpa ,entitymanager ,tutorial

Published at DZone with permission of Martin Farrell, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}