Viele Applikationen sowie Java-EE-Anwendungen werden heute genau an Kundenanforderungen angepasst und so detailliert spezifiziert, dass diese ohne Modifikationen oder Neuentwicklungen nicht für weitere Kunden verwendet werden können. Durch die EJB3-(Enterprise-JavaBeans-)Spezifikation ist das Entwickeln solcher Systemen einfacher geworden. Die JPA (Java Persistence API) ermöglicht den Einsatz von Entity Beans und bringt ein standardisiertes OR Mapping (Object Relational Mapping) mit sich. Des Weiteren wird im Package javax.persistence das EntityManager Interface angeboten, um den Zugriff auf die Entitäten zu ermöglichen. Die Implementierung des EntityManagers wird von einem OR Mapping-Anbieter wie Hibernate oder Toplink bereitgestellt. Üblicherweise wird der EntityManager innerhalb eines EJB Containers mittels der Annotation @PersistenceContext aus dem Package javax.persistence, geladen:

1. @PersistenceContext(unitName = "PERSISTENCE_UNIT_NAME")
2. private EntityManager entityManager;

Der unitName-Parameter der Annotation muss bereits zur Programmierzeit bekannt sein und lässt somit keinen Spielraum für ein dynamisches Wechseln der dahinter liegenden Datenbanken zu. Es stellt sich die Frage, wie es nun möglich wird, eine solche Dynamik in den Code zu bringen.
Um für den oben genannten generischen DAO Layer eine bestmögliche Anwendung zu gewährleisten, ist es ratsam, ein eigenes Entity-Interface (Marker-Interface) anzubieten (Listing 1). Damit sollten alle Entitäten des Systems das Marker-Interface implementieren. Dieses Interface ermöglicht auch ein einfaches Anbinden an Legacy-Systeme.

1. Listing 1: Entity-Marker-Interface und konkrete Entity-Klasse
2. // Marker interface.
3. package javamagazin.virtual.entities;
4. import java.io.Serializable;
5. public interface Entity extends Serializable {
6. }
7. // Entity class
8. package javamagazin.virtual.entities;
9. @Entity
10. public class User implements Entity {
11. ....private static final long serialVersionUID = -7931125774297472732L;
12. @Column(nullable = false)
13. private String username;
14. private String firstname;
15. private String lastname;
16. // ... getter and setter Methods
17. }

Der generische DAO Layer teilt sich in ein BaseDao-Interface und eine BaseDaoImpl-Implementierung. Dieses BaseDao-Interface ist ein Wrapper für den EntityManager. Methoden für das Laden von einzelnen und mehreren Entitäten sowie das Speichern, Updaten und Löschen werden von Entitäten angeboten. Wie die Aufteilung in Interface und Implementierung vermuten lässt, wird dieses DAO als EnterpriseBean angeboten. Oft ist es sinnvoll, das BaseDao sowie die dazugehörige Implementierung nicht als EnterpriseBean zu deklarieren, sondern für unterschiedliche Projekte eigene DAO-Interfaces und -Implementierungen, die das BaseDao erweitern, anzubieten (Listing 2), um weitere spezifischere Methoden zur Verwaltung von Interaktion mit Entitäten bereitzustellen.

1. Listing 2: BaseDao und Erweiterung
2. // BaseDao interface
3. package javamagazin.virtual.dao;
4. public interface BaseDao {
5. <T extends Entity> T get(String key, Class<T> entity, Serializable id);
6. <T extends Entity> T load(String key, Class<T> entity, Serializable id)
7. throws NoSuchEntityException;
8. <T extends Entity> T getByQuery(String key, String namedQuery,
9. Object... parameters);
10. <T extends Entity> T loadByQuery(String key, String namedQuery,
11. Object... parameters) throws NoSuchEntityException;
12. <T extends Entity> List<T> findByQuery(String key, String namedQuery,
13. Object... parameters);
14. <T extends Entity> Serializable save(String key, T entity);
15. <T extends Entity> void update(String key, T entity);
16. <T extends Entity> void delete(String key, T entity);
17. <T extends Entity> Serializable merge(String key, T entity);
18. <T extends Entity> void refresh(String key, T entity);
19. <T extends Entity> void refresh(String key, List<T> entities);
20. }
21. // Concrete local dao interface
22. package javamagazin.virtual.dao;
23. @Local
24. public interface VirtualDao extends BaseDao {
25. // Any specific methods for the VirtualDao.
26. }
27. // concrete stateless enterprise bean
28. package javamagazin.virtual.dao;
29. @Stateless
30. public class VirtualDaoImpl extends BaseDaoImpl implements VirtualDao {
31. // Implementation of all specific VirtualDao methods.
32. }

Wie in Listing 2 zu sehen ist, übernimmt jede Interfacemethode einen Schlüssel (key). Dieser Schlüssel ist ausschlaggebend, um den für den zugreifenden Kunden richtigen EntityManager zu laden. Konfiguriert wird dieser Zugriff in der ejb-jar.xml.