Starting with Tapestry 5.3, Tapestry provides built-in integration with the Java Persistence API (JPA). This module supersedes Tynamo's JPA integration.
Contents
Configuring JPA
The persistence.xml file is the standard configuration file in JPA used to define the persistence units. Tapestry reads this file to create the EntityManagerFactory. The following example demonstrates a persistence.xml file.
| Code Block |
|---|
|
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<persistence-unit name="DemoUnit" transaction-type="RESOURCE_LOCAL">
<properties>
<property name="javax.persistence.jdbc.driver" value="org.h2.Driver" />
<property name="javax.persistence.jdbc.url" value="jdbc:h2:mem:test" />
<property name="javax.persistence.jdbc.user" value="sa" />
<property name="eclipselink.ddl-generation" value="create-tables"/>
<property name="eclipselink.logging.level" value="fine"/>
</properties>
</persistence-unit>
</persistence> |
By default, the persistence descriptor is named persistence.xml and is expected to be located on the classpath in the META-INF directory. If you want to place the persistence.xml file in another directory or name it differently, you can make a contribution to the SymbolProvider service, as shown in the following example. This is a quite useful feature if you want to use a different persistence descriptor for tests.
| Code Block |
|---|
|
public class AppModule {
@Contribute(SymbolProvider.class)
@FactoryDefaults
public static void provideFactoryDefaults(final MappedConfiguration<String, String> configuration) {
configuration.add(JpaSymbols.PERSISTENCE_DESCRIPTOR, "/org/example/persistence.xml");
}
} |
...
With Tapestry, configuring JPA is much simpler than as described in the JPA specification. Tapestry allows you to configure the EntityManagerFactory programmatically, without writing any XML. Imagine you want to use JDBC connections managed by the container and provided through JNDI. The resulting persistence descriptor might look like this:
| Code Block |
|---|
|
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
version="2.0">
<persistence-unit name="JTAUnit" transaction-type="RESOURCE_LOCAL">
<non-jta-data-source>
jdbc/JPATest
</non-jta-data-source>
<properties>
<property name="eclipselink.ddl-generation" value="create-tables"/>
<property name="eclipselink.logging.level" value="fine"/>
</properties>
</persistence-unit>
</persistence> |
Now let's see how to provide the same configuration without XML. The following demonstrates an equivalent JPA configuration.
| Code Block |
|---|
|
public class AppModule {
@Contribute(EntityManagerSource.class)
public static void configurePersistenceUnitInfos(MappedConfiguration<String,PersistenceUnitConfigurer> cfg) {
PersistenceUnitConfigurer configurer = new PersistenceUnitConfigurer() {
public void configure(TapestryPersistenceUnitInfo unitInfo) {
unitInfo.nonJtaDataSource("jdbc/JPATest")
.addProperty("eclipselink.ddl-generation", "create-tables")
.addProperty("eclipselink.logging.level", "fine");
}
};
cfg.add("JTAUnit", configurer);
}
} |
...
If you have additional packages containing entities, you may contribute them to the JpaEntityPackageManager service configuration.
| Code Block |
|---|
|
public class AppModule {
@Contribute(JpaEntityPackageManager.class)
public static void providePackages(Configuration<String> configuration) {
configuration.add("org.example.myapp.domain");
configuration.add("com.acme.model");
}
} |
...
Depending on whether more than one persistence unit has been defined, the way to inject EntityManager varies slightly. Let’s start with a simple scenario, where only a single persistence unit is defined. In this case, an EntityManager can be injected using the @Inject annotation.
| Code Block |
|---|
|
public class CreateAddress {
@Inject
private EntityManager entityManager;
@Property
private Address address;
@CommitAfter
void onSuccess() {
entityManager.persist(address);
}
} |
Alternatively, you can use the @PersistenceContext annotation to get the EntityManager injected into a page or component, as shown in the following example.
| Code Block |
|---|
|
public class CreateAddress {
@PersistenceContext
private EntityManager entityManager;
@Property
private Address address;
@CommitAfter
void onSuccess() {
entityManager.persist(address);
}
} |
If you have multiple instances of persistence-unit defined in the same application, you need to explicitly tell Tapestry which persistence unit you want to get injected. This is what the @PersistenceContext annotation’s name attribute is used for? The following example demonstrates how to inject the persistence unit named DemoUnit.
| Code Block |
|---|
|
public class CreateAddress {
@PersistenceContext(unitName = "DemoUnit")
private EntityManager entityManager;
@Property
private Address address;
@CommitAfter
@PersistenceContext(unitName = "DemoUnit")
void onSuccess() {
entityManager.persist(address);
}
} |
...
While component injection occurs only on fields, the injection in the IoC layer may be triggered by a field or a constructor. The following example demonstrates field injection, when a single persistence unit is defined in the persistence descriptor.
| Code Block |
|---|
|
public class UserDAOImpl implements UserDAO {
@Inject
private EntityManager entityManager;
...
} |
The constructor injection is demonstrated in the following example.
| Code Block |
|---|
|
public class UserDAOImpl implements UserDAO {
private EntityManager entityManager;
public UserDAOImpl(EntityManager entityManager) {
this.entityManager = entityManager;
}
...
} |
If multiple persistence units are defined in the same application, you need to disambiguate the unit to inject. This is done with the @PersistenceContext annotation, as shown in the following example. Because @PersistenceContext must not be placed on constructor parameters, you can’t use constructor injection and must switch to field injection.
| Code Block |
|---|
|
public class UserDAOImpl implements UserDAO {
@Inject
@PersistenceContext(unitName = "DemoUnit")
private EntityManager entityManager;
...
} |
...
As you may already know from the Hibernate integration library, Tapestry automatically manages transactions for you. The JPA integration library defines the @CommitAfter annotation, which acts as the correspondent annotation from the Hibernate integration library. Let’s explore the UserDAO interface to see the annotation in action.
| Code Block |
|---|
|
public interface UserDAO {
@CommitAfter
@PersistenceContext(unitName = "DemoUnit")
void add(User user);
List<User> findAll();
@CommitAfter
@PersistenceContext(unitName = "DemoUnit")
void delete(User... users);
} |
...
After placing the @CommitAfter annotation on methods, you need to tell Tapestry to advise those methods. This is accomplished by adding the transaction advice, as shown in the following example.
| Code Block |
|---|
|
public class AppModule {
@Match("*DAO")
public static void adviseTransactionally(
JpaTransactionAdvisor advisor,
MethodAdviceReceiver receiver) {
advisor.addTransactionCommitAdvice(receiver);
}
} |