DZone
Java Zone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
  • Refcardz
  • Trend Reports
  • Webinars
  • Zones
  • |
    • Agile
    • AI
    • Big Data
    • Cloud
    • Database
    • DevOps
    • Integration
    • IoT
    • Java
    • Microservices
    • Open Source
    • Performance
    • Security
    • Web Dev
DZone > Java Zone > Accessing the EntityManager From Spring Data JPA

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.

Martin Farrell user avatar by
Martin Farrell
·
Nov. 09, 17 · Java Zone · Tutorial
Like (16)
Save
Tweet
187.23K Views

Join the DZone community and get the full member experience.

Join For Free

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.

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:

  • Repository
  • CrudRepository
  • JPARepository

But occasionally, you need to access the EntityManager.

EntityManager.refresh

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:

@Entity
@Table(name = "PARKRUNCOURSE")
public class ParkrunCourse {
    @Id
    @Column(name = "PRCOURSE_ID")
    @GeneratedValue
    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 {
    @PersistenceContext
    private EntityManager em;
    @Override
    @Transactional
    public void refresh(ParkrunCourse parkrunCourse) {
        em.refresh(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:

@Autowired
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
parkrunCourseRepository.refresh(parkrunCourse);


Conclusions

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.

Spring Data Data (computing) Spring Framework

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

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • Role of Development Team in an Agile Environment
  • How to Optimize MySQL Queries for Speed and Performance
  • Adaptive Change Management: A DevOps Approach to Change Management
  • A Simple Guide to Heaps, Stacks, References, and Values in JavaScript

Comments

Java Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • MVB Program
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends:

DZone.com is powered by 

AnswerHub logo