Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Architecture Persistente Domänenmodelle mit JPA 2.0 und Bean Validation.

Ähnliche Präsentationen


Präsentation zum Thema: "Architecture Persistente Domänenmodelle mit JPA 2.0 und Bean Validation."—  Präsentation transkript:

1 Architecture Persistente Domänenmodelle mit JPA 2.0 und Bean Validation

2 EJB 3.x Dependency Liefert eine Referenz zur Liefert eine Referenz zum EntityManger private EntityManager private EntityManagerFactory emf;

3 Stateless Session Beans public class EmployeeService type=PersistenceContextType.TRANSACTION) private EntityManager em; public Employee findById(Integer id) { Employee e = em.find(Employee.class, id); return e; }

4 Stateful Session Beans public class EmployeeService type=PersistenceContextType.EXTENDED) private EntityManager em; public Employee findById(Integer id) { Employee e = em.find(Employee.class, id); return e; }

5 Persistence Unit 5 jdbc/emp

6 Data Access Object (DAO) Problem You want to encapsulate data access and manipulation in a separate layer Solution Use a Data Access Object to encapsulate all access to the persistent store. The Data Access Object manages the connection with the data source to obtain and store data DAOs werden als einfache, zustandslose Klassen realisiert, die den Zugriff auf eine Datenquelle kapseln Ziele: Trennung von Business Logik und technischer Zugriffslogik Kapselung von Zugriff auf Datenbank oder Fremdsystem

7 DAO Klassendiagramm

8 DAO und JPA Häufig überflüssig dank EntityManager Wenn schon DAO dann generisch public interface GenericDAO { T create(T t); T find(Class type, Serializable id); T update(T t); void delete(Object t); List findByNamedQuery(String queryName); List findByNamedQuery(String queryName, Map parameters); }

9 Transfer Object (TO) Problem You want to transfer multiple data elements over a tier Solution Use a Transfer Object to carry multiple data across a tier Daten werden in Datencontainern zusammengefasst und über Tier-Grenzen transportiert Das Konzept sollte generell zwischen den Schichten eingesetzt werden Ziel: Verringerung der übertragenen Datenmenge

10 TO und JPA Mit Constructor Expressions existiert eine einfache Möglichkeit direkt aus den Resultaten Transfer Objects zu erzeugen. public class EmpMenu { public EmpMenu(String employeeName, String deptName){...} } List result = em.createQuery( "SELECT NEW jpa.util.EmpMenu(e.name, e.department.name) " + "FROM Project p JOIN p.employees e " + "where p.name = "ZLD").getResultList(); for (EmpMenu menu : result) { log.info(menu.employeeName + "," + menu.deptName); }

11 Schichtung und Verteilung ApplikationsserverDB Server Datenzugriff Business Client oder Webserver Präsentations- schicht Datenhaltung ServiceFassade 3rd Party Applikation XY TOs und Entities Ausschliesslich TOs

12 Client/Server Ausschliesslich TOs Entities

13 Lazy Loading und Verteilung Lazy Loading deaktivieren Vorteil: einfach, für wenig Daten nutzbar Nachteil: bei vielen Daten aus Performance Gründen nicht nutzbar Open Session in View Pattern geht davon aus, dass in einer Webappliaktion die Session erst geschlossen wird, wenn der Request beendet ist. Vorteil: Die Daten werden bei Bedarf nachgeladen Nachteil: Funktioniert nur bei einer Webapplikation, Änderungen der Daten auf dem GUI-Level unter Umgehung der Businesslogik, saubere Trennung der Layer nicht möglich. Preload Pattern: Der Aufrufer einer DAO-Methode übergibt Informationen, welche Daten vorgeladen werden sollen. Vorteil: Abhängig von der Situation kann Lazy Loading eingesetzt oder umgangen werden Nachteil: Kann zu einer Schwemme von DAO-Methoden führen um die möglichen Kombinationen anzubieten. 13 Java Persistence API

14 Open Session in View 14 Java Persistence API HTTP Session Transaktion 1Transaktion 2 O1 Lazy

15 Preload Pattern nach Jürgen Kohl (1) Jürgen Kohl beschreibt in der Ausgabe 4/2008 des Java Magazins sein Preload Pattern, dass in einigen Praxisprojekten erfolgreich eingesetzt wurde. Hierbei liegt der Fokus darauf die Methodenschwemme zu vermeiden und weiterhin die Nutzung eines GenericDAO zu erlauben. Seine Anforderungen sind: generischer Mechanismus keine Verkomplizierung der Backend-Methoden bei steigender Komplexität des Domain Models Anwender der Backend-Methoden können denkbare Preload-kombinationen selbst definieren. 15 Java Persistence API

16 Preload Pattern nach Jürgen Kohl (2) 16 Java Persistence API public class Preload { private Class modelClass; private String property; public Preload(Class modelClass, String property) { this.modelClass = modelClass; this.property = property; } }

17 Preload Pattern nach Jürgen Kohl (3) 17 Java Persistence API public abstract class GenericDAO { private Class persistentClass; private String getPropertyGetterName(String property ) { String propertyUpper = property.toUpperCase().substring(0, 1); return "get" + propertyUpper + property.substring(1); } private Object invokeGetter(Object entity, Preload preload) { String getterName = getPropertyGetterName(preload.getProperty()); try { Method method = preload.getModelClass().getMethod( getterName, (Class[]) null); return method.invoke(entity, (Object[]) null); } catch (Exception ex) { throw new RuntimeException("Can't invoke getter for property: " + preload.getProperty(), ex); } }

18 Preload Pattern nach Jürgen Kohl (4) 18 Java Persistence API // Fortsetzung GenericDAO protected void preload(Object entity, Preload[] preloads) { if (entity instanceof Collection) { for (Object resultEntity : (Collection) entity) { preload(resultEntity, preloads); } } else { for (Preload preload : preloads) { if (preload.getModelClass().isInstance(entity)) { Object getterResult = invokeGetter(entity, preload); preload( getterResult, preloads); } }

19 Preload Pattern nach Adam Bien Idee: Verwendung JXPath für die Initiatlisierung von Lazy Loading Beziehungen Beispielklasse mit Lazy OneToOne Beziehung: Aufruf der Getter-Methode mit JXPath: 19 Java Persistence public class Master private Detail detail;... } JXPathContext.newContext(master).getValue("/detail");

20 Batch Problematik Sequenzielle Verarbeitung von grossen Datenmengen Verwendung von Cursors mit JPA nicht möglich Lösung Pagination Vorsicht Persistence Context kann gross werden und sollte regelmässig aufgeräumt werden (EntitManager.clear())

21 Clustering Zur Erhöhung der Verfügbarkeit und der Verbesserung der Performance werden Application Server häufig geclustert Problem Persistence Context auf mehreren Knoten vorhanden Synchronität mit Datenbank nicht gegeben Lösung Synchronisation (Providerabhängig) Referesh der Entitäten bei Bedarf


Herunterladen ppt "Architecture Persistente Domänenmodelle mit JPA 2.0 und Bean Validation."

Ähnliche Präsentationen


Google-Anzeigen