The PersistenceUnit defines the set of entity classes along with their configuration, and it represents a logical grouping of these entities that the entity manager manages. We can create a persistence unit by creating a persistence.xml file or extending the PersistenceUnitInfo interface.
The @PersistenceUnit JPA annotation injects an entity manager factory into a bean:
@PersistenceUnit(name = "persistence-unit-name")
private EntityManagerFactory entityManagerFactory;
The persistence unit supports two types: RESOURCE_LOCAL and JTA.
A big advantage of the persistence unit is that we can define multiple persistence units within the same application, each adapted for different parts of the system or even separate databases.
4.1. Resource Local PersistenceUnit
By default, Spring applications use the resource local persistence unit. In a resource local PersistenceUnit, we are responsible for managing the transactions. It does not rely on an external transaction manager.
Let’s declare a persistence.xml file, located at META-INF/persistence.xml on the classpath:
<persistence-unit name="com.baeldung.contextvsunit.h2_persistence_unit" transaction-type="RESOURCE_LOCAL">
<description>EntityManager serializable persistence unit</description>
<class>com.baeldung.contextvsunit.entity.Product</class>
<exclude-unlisted-classes>true</exclude-unlisted-classes>
<properties>
<property name="hibernate.hbm2ddl.auto" value="update"/>
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.generate_statistics" value="false"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
<property name="jakarta.persistence.jdbc.driver" value="org.h2.Driver"/>
<property name="jakarta.persistence.jdbc.url" value="jdbc:h2:mem:db2;DB_CLOSE_DELAY=-1"/>
<property name="jakarta.persistence.jdbc.user" value="sa"/>
<property name="jakarta.persistence.jdbc.password" value=""/>
</properties>
</persistence-unit>
As we can see, we define the persistence unit with database connection properties. Additionally, we configure Hibernate properties including the dialect, transaction settings, and other properties for persistence operations. Every time an application interacts with the database, it operates within the context of a persistence unit. We define mappings between Java entities and database tables within the persistence unit.
Now, let’s use this persistence unit in our PersistenceUnitProductService class:
@Service
public class PersistenceUnitProductService {
@PersistenceUnit(name = "com.baeldung.contextvsunit.h2_persistence_unit")
private EntityManagerFactory emf;
@Transactional
void insertProduct(Product product) {
EntityManager entityManager = emf.createEntityManager();
entityManager.persist(product);
}
Product find(long id) {
EntityManager entityManager = emf.createEntityManager();
return entityManager.find(Product.class, id);
}
}
Let’s persist a Product entity to verify if everything is working as we expect:
@Test
void whenProductPersistWithEntityManagerFactory_thenShouldPersist() {
Product p = new Product(1L, "Product 1", 100.0);
persistenceUnitProductService.insertProduct(p);
Product createdProduct = persistenceUnitProductService.find(1L);
assertNotNull(createdProduct);
}
4.2. JTA PersistenceUnit
Using JTA means that we delegate the work to the container. Consequently, we cannot obtain an EntityManager through the EntityManagerFactory. Instead, we must use an EntityManager that the container supplies and injects via the @PersistenceContext annotation.
Enterprise applications commonly use JTA persistence units when deploying in Java EE containers such as TomEE and WildFly.
5. Conclusion
In this article, we learned the difference between the persistence unit and the persistence context.
We started with a brief introduction of EntityManager and EntityManagerFactory to understand their roles. Next, we examined the persistence context, delving into its scope and available types.
Finally, we turned our attention to the persistence unit, which acts as a central configuration unit for entities and facilitates efficient data management.
As always, the full implementation of these examples can be found over on GitHub.
