Java Enterprise Edition (Java EE)
Werbung
Java Enterprise Edition (Java EE)
Eine Einführung
© itemis AG
Java Enterprise Editon
• Java EE platform
• API and runtime environment
• for developing and running enterprise
applications and services
• designed to reduce the complexity of
enterprise application development,
providing
• large-scale
• a development model
• multi-tiered
• APIs for standard system services
• scalable
• runtime environment
• reliable
• secure
• allows developers to concentrate on
business and presentation logic
• distributed
• network applications
© itemis AG
2
Distributed Multitiered Applications
• Java EE platform uses a distributed
multitiered application model for
enterprise applications
• Application logic is divided into
components according to function
• Components are grouped in a
stack of tiers
• Components are potentially
installed on various machines
• Typically
• Presentation: client and web tier
• Business tier
• Persistent data tier
© itemis AG
3
Java EE
• Genau genommen: Spezifikation einer Softwarearchitektur für Enterprise JavaAnwendungen von Sun jetzt Oracle
• In der Praxis aber auch: Spring, Tomcat, Hibernate
• Spezifiziert werden Komponenten und Dienste
• Aktuelle Version: JEE 6
• JEE 5/6 vereinfacht die Entwicklung enorm gegenüber J2EE (1.4) aus 2003
• Wesentlicher Unterschied: Menge der zu erstellenden Artefakte
(Schnittstellen, Deployment-Deskriptoren, Implementierungsvorschriften für
Callback-Methoden)
© itemis AG
4
Warum JEE?
• Standardisierung
• Skalierbarkeit
• Interoperabilität
© itemis AG
5
Applicationserver
• Java-EE-Komponenten erfordern als Laufzeitumgebung eine spezielle
Infrastruktur, den Java EE Applicationserver
• Dieser Server stellt verschiedene technische Funktionalitäten bereit
• Security
• Transaktionsmanagement
• Namens- und Verzeichnisdienste
• Skalierung
• Kommunikation zwischen Java-EE-Komponenten
• Management der Komponenten über den gesamten Lebenszyklus (inklusive
Instanziierung)
• Unterstützung für die Installation (Deployment) und den Betrieb von
Anwendungen
© itemis AG
6
Applicationserver
• Open Source Server
• Apache Geronimo
• JBoss Application Server
• GlassFish
• ...
• Proprietäre Server
• IBM WebSphere
• Oracle Application Server
• Oracle WebLogic Server
• SAP NetWeaver Application Server
• ...
• Alternativen
• Spring-Framework
• Tomcat WebContainer
• ...
© itemis AG
7
Wichtige Subspezifikationen
• Insgesamt 23
• Die wichtigsten Spezifikationen innerhalb von JEE:
• EJB (Enterprise Java Beans)
• JMS (Java Message Service)
• JTA (Java Transaction API)
• JPA (Java Persistence API)
• CDI (Context and Dependency Injection)
• JNDI (Java Naming and Directory Interface)
• JAAS (Java Authentication and Authorization)
© itemis AG
8
Applikationsserver
© itemis AG
9
Applicationserver
• Ein Java-EE-Server wird in diverse
logische Komponenten unterteilt:
• Web-Container
• Laufzeitumgebung für Servlets und
JavaServer Pages (JSP)
• Bereitstellung von verschiedenen
Diensten für Servlets
• EJB-Container
• Laufzeitumgebung für Enterprise Java Beans
• Überwachung des Lebenszyklus von EJBs
• Instanzen-Pooling
• Bereitstellung von verschiedenen Diensten für EJBs (Namens- und
Verzeichnisdienst, Transaktionsdienst, Nachrichtendienstes
• Persistenz
• JCA-Container (JEE Connector Architecture)
• Laufzeitumgebung Anbindung heterogener Fremdarchitekturen
© itemis AG
10
Aufbau einer Anwendung
• Presentation Tier (Web Tier)
• JSF Pages (Java Server Faces)
• JSF Backing Beans
• Business Tier
• Enterprise Beans
• JTA (Java Transaction API)
• Persistence Tier
• Entity Beans
• JPA (Java Persistence API)
© itemis AG
11
Einordnung der APIs
Darstellungsschicht
JSF
JSP
XSL
Servlets
JMX
JNDI
Logik &
Kommunikation
EJB
JMS
Webservices
JTA
XML
JPA
Datenhaltungsschicht
…
© itemis AG
12
JavaEE-APIs
• JavaServer Pages (JSP)
• Framework für Webapplikationen
• basiert auf aus JSPs generierten Servlets
• Java Server Faces (JSF)
• Framework für Webapplikationen
• Alternative zu JSP
• Java Servlet API
• Erlaubt die Erweiterung von Servern, deren Protokoll auf Anfragen und
Antworten basiert
© itemis AG
13
JavaEE-APIs
• Java Transaction API (JTA)
• Schnittstelle zur standardisierten Kontrolle von Transaktionen
• Java Persistence API (JPA)
• Schnittstelle zur vereinfachten Zuordnung und Übertragung von JavaObjekten zu Datenbankeinträgen
• Java Naming and Directory Interface (JNDI)
• Schnittstelle mit der alle Java Klassen auf Namens- und Verzeichnisdienste
zugreifen können
• über JNDI wird insbesondere der Zugriff auf Java-EE-Komponenten
sichergestellt
© itemis AG
14
JavaEE-APIs
• Java Message Service (JMS)
• API zur asynchronen Nachrichtenverarbeitung
• Java Connector Architecture (JCA)
• dient der transparenten Integration von externen Systemen
• Java Management Extensions (JMX)
• dient der Verwaltung von Java-EE Komponenten
• Webservice, JAAS, JavaMail, StAX, …
© itemis AG
15
Deployment einer Anwendung
• Deployment als EAR (EnterpriseArchive)
|-- META-INF/
|-- application.xml
|-- MANIFEST.MF
|-- <Library JAR files>
|-- <EJB Module JAR files>
|-- <Web Module WAR files>
|-- <ResourceAdapter RAR files>
© itemis AG
16
Aufbau einer Anwendung am Beispiel
Schnelldurchlauf von oben nach unten
© itemis AG
Demoumgebung
• Umgebung
• Datenbank MySQL
• Application Server Glassfish (Referenzimplementierung, besser nicht für
produktiven Einsatz)
• Datenbank MySQL
• XAMPP-Paket: http://www.apachefriends.org/de/xampp.html
• XAMPP installieren laut Anleitung
• XAMPP Control zum starten/stoppen von MySQL und Apache (für phpMyAdmin)
• phpMyAdmin: http://localhost:80/phpmyadmin/
• Benutzer (hier „jee“) mit Datenbank anlegen
© itemis AG
18
Demoumgebung
• Applicationserver GlassFish
• Download
• kommerziell: http://www.oracle.com/technetwork/middleware/glassfish/downloads/
• Open Source: https://glassfish.java.net/de/
• Installation
• Kurzanleitung: http://www.torsten-horn.de/techdocs/jee-sunglassfish.htm
• Doku: http://www.oracle.com/technetwork/middleware/glassfish/documentation/
View Library Installation Guide / Quick Start Guide
• Schritte
• MySQL JDBC-Treiber installieren (jar in GlassFish-lib-Verzeichnis)
• GlassFish starten (siehe JEE- Eclipse)
• GlassFish JDBC Connection Pool einrichten
• GlassFish JDBC DataSource unter JNDI-Namen einrichten
© itemis AG
19
Demoumgebung
• JEE-Eclipse
• Download: http://www.eclipse.org/downloads/ Eclipse IDE for Java EE
• Server in Eclipse einrichten
• Servers View New Server GlassFish 3.1.2
• (ggf. vorher Download additional server adapters)
• Kontextmenü auf Server
• Start, Stop, AdminConsole (i.d.R. localhost:4848)
• JEE-Project
• New Other ... Web Dynamic Web Project
• Target runtime: GlassFish 3.1.2
© itemis AG
20
Java Server Faces (JSF 2.0)
Eine Einführung
© itemis AG
Aufbau einer Anwendung
• Presentation Tier (Web Tier)
• JSF Pages (Java Server Faces)
• JSF Backing Beans
© itemis AG
22
Java Server Faces 2.0
Controller
• JSF: Framework für Web-Anwendungen in JavaEE
• Trennung von Darstellungsschicht und
Programmlogik nach MVC-Pattern
Facelet
XHTML-Template
Model
Backing Bean
POJO
getAttr()
setAttr(...)
action()
<html>!
<h:body>!
<h2>Customer with id!
"#{bankingBean.customerId}“!
</h2>!
<h:inputText value=!
"#{bankingBean.name}“/>!
<h:commandButton!
value="Speichern“!
action="#{personFormular.!
speichern}"/>!
</h:body>!
</html>!
View
© itemis AG
23
Facelets und Backing Beans
• Backing Beans (einfache Java-Klassen)
• Zugriff auf Daten durch get- und set- Methoden
• Aktions-Methoden, die z.B beim Klick auf einen Button ausgeführt werden
• JSF lädt diese Beans bei Bedarf automatisch in den Speicher
• Facelets
• Template-Engine zwischen Backing Beans und Web-Browser
• erzeugt Webseiten auf der Grundlage von Vorlagen (Facelets), die mit Daten
aus den Beans befüllt werden
• Java Klassen enthalten kein HTML, Facelets enthalten kein Java-Code
• Trennung von Java-Programmierung von HTML-Entwicklung
© itemis AG
24
Facelets
• Templates für Webseiten (typischerweise Endung .xhtml) enthalten
HTML
+
Ausdrücke aus der Expression Language
+
JSF Tags
• Expression Language Ausdrücke
#{user.name}!#{geld.eingang - geld.ausgang}!
#{auto.farbe != rot}
• JSF-Tags
• Kontrollstrukturen
!
!
!
!
!
<ui:fragment rendered="#{user.alter > 12}“>!
! Du bist alt genug!
</ui:fragment>!
<ui:repeat var="auto" value="#{meinBean.alleAutos}">!
! Das Auto #{auto.name} ist #{auto.farbe}.!
</ui:repeat>
© itemis AG
25
Facelets
• JSF-Tags
• HTML-(Formular-)Elemente
! <h:form>!
! ! <h:inputText value="#{personFormular.name}“/>!
! ! <h:commandButton value="Speichern“
! !
!
!
!
action="#{personFormular.speichern}"/>!
! </h:form>
• Bestimmung des Page-Flows
• Facelet-Name als Rückgabewert der Aktions-Methoden (ohne Endung.xhtml)
! public String speichern() {!
! ! ... Aufruf Geschäftslogik ...!
! ! return “gespeichert“;!
! }!
ruft Facelet gespeichet.xhml auf
© itemis AG
26
Zusammenspiel mit Backing Bean
© itemis AG
27
Grundkonfiguration
•
WebContent/WEB-INF/web.xml
(sun-web.xml brauchen wir hier nicht)
• JSF ist ein Aufsatz auf die Servlet API, d.h. Faces-Servlet konfigurieren
<?xml version="1.0" encoding="UTF-8"?>!
<web-app xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance!
xmlns=http://java.sun.com/xml/ns/javaee!
xmlns:web=http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd!
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee!
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd” id="WebApp_ID" version="3.0">!
<display-name>WebApp Name</display-name>!
<welcome-file-list>!
<welcome-file>index.xhtml</welcome-file>!
</welcome-file-list>!
<servlet>!
<servlet-name>Faces Servlet</servlet-name>!
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>!
<load-on-startup>1</load-on-startup>!
</servlet>!
<servlet-mapping>!
<servlet-name>Faces Servlet</servlet-name>!
<url-pattern>*.xhtml</url-pattern>!
</servlet-mapping>!
</web-app>!
© itemis AG
28
Grundkonfiguration
• WebContent/WEB-INF/faces-config.xml
• Überbleibsel von JSF 1.0
• Konfiguration bei JSF 2.0 weitgehend über Annotationen
• d.h. entfällt i.d.R. oder leer
<?xml version="1.0" encoding="UTF-8"?>!
<faces-config!
xmlns="http://java.sun.com/xml/ns/javaee"!
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"!
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee !
!
!
!
!
http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd"!
version="2.0">!
</faces-config>!
© itemis AG
29
Backing Bean
• Annotation @ManagedBean!
• automatisch bei Bedarf vom Container instantiiert
• unter dem Klassennamen der Template Engine bekannt gemacht
• eindeutiger Name für Managed-Beans, egal in welchem Package
• optional @ManagedBean(name="person”)
• Scoping von Beans, d.h. Definition der Lebensdauer, per Annotation
• @ApplicationScoped: genau einmal geladen, solange im Speicher, wie die
Applikation läuft
• @RequestScoped: für jeden HTTP Request eine neue eigene Instanz
• @SessionScoped: in der HTTP-Session abgelegt und wieder verwendet
• @ViewScoped: solange, wie Nutzer die aktuelle Seite benutzt
© itemis AG
30
Backing Bean
package de.skatulla.jee.jsfbeans;!
import java.io.Serializable;!
import javax.faces.bean.ManagedBean;!
import javax.faces.bean.SessionScoped;!
@ManagedBean @SessionScoped!
public class PersonBean implements Serializable {!
!
private static final long serialVersionUID = -5684916245218747993L;!
!
private String _name;!
!
private String _id;!
!
public String getName() {!
!
!
return _name;!
!
}!
!
public void setName(String name) {!
!
!
_name = name;!
!
}!
!
public String getId() {!
!
!
return _id;!
!
}!
!
public void setId(String id) {!
!
!
_id = id;!
!
}!
!
public String save() {!
!
!
setId(UUID.randomUUID().toString());!
!
!
return "Person";!
!
}!
}!
© itemis AG
31
Facelet
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" !
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">!
<html xmlns="http://www.w3.org/1999/xhtml"!
xmlns:h="http://java.sun.com/jsf/html"!
xmlns:ui="http://java.sun.com/jsf/facelets">!
<head>!
<title>Person</title>!
</head>!
<body>!
!
<h:form>!
!
!
<h1>Person</h1>!
!
!
<h:panelGrid border="0" columns="2">!
!
!
!
!
!
!
<h:outputText value="ID"/>!
<h:outputText value="#{personBean.id}"/>!
!
!
!
!
!
!
<h:outputText value="Name"/>!
<h:inputText value="#{personBean.name}"/>!
!
!
</h:panelGrid>!
!
!
<h:commandButton value="Save" action="#{personBean.save}"/>!
!
</h:form>!
</body>!
</html>!
© itemis AG
32
Enterprise Java Beans (EJB 3.1)
Eine Einführung
© itemis AG
Aufbau einer Anwendung
• Business Tier
• Enterprise Beans
• JTA (Java Transaction API)
© itemis AG
34
EJB – Enterprise Java Bean
• Komponente mit Geschäftslogik und/oder Zugriff auf persistente Daten
• Ausführung im EJB Container
• Seit JEE 5 POJO mit Annotationen
• In J2EE 1.4 mit Home-, Remote- und SessionBean-Interface und DeploymentDeskriptor
• Zugreifbar über die JNDI-Registry
• Unterscheidung:
• Stateless Session Bean
• Stateful Session Bean
• Message Driven Bean
© itemis AG
35
Stateless Session Bean
• Zwei Status: Non existent und Ready
• Callbacks im Lifecycle: @PostConstruct und @PreDestroy
• Zustandlos
© itemis AG
36
Stateful Session Bean
• Eine Instanz pro Client
• Status: Non Existent, Ready, Passivated
• Callbacks im Lifecycle: @PostConstruct, @PreDestroy, @PrePassivate,
@PostActivate
• Wird eher selten eingesetzt
© itemis AG
37
MessageDrivenBean
• Kommunikation über JMS
• Nimmt Nachrichten entgegen, für Queues/Topics, auf die sich eine MDB
registriert hat
© itemis AG
38
Stateless Session Bean
• Service IPersonService.save() deklariert durch Interface
package de.skatulla.jee.services;!
import de.skatulla.jee.jsfbeans.PersonBean;!
public interface IPersonService {!
!
public abstract void save(PersonBean personBean);!
}!
• Implementation durch Stateless Session Bean PersonServiceImpl
package de.skatulla.jee.services;!
import java.util.UUID;!
import javax.ejb.Stateless;!
import de.skatulla.jee.jsfbeans.PersonBean;!
@Stateless!
//@TransactionAttribute(TransactionAttributeType.REQUIRED)!
public class PersonServiceImpl implements IPersonService {!
!
@Override!
!
public void save(PersonBean personBean) {!
!
!
personBean.setId(UUID.randomUUID().toString());!
!
}! !
}!
© itemis AG
39
Verwendung des Services
• Backing Bean erhält Zugriff auf Service durch Dependency Injection (DI)
• keine Abhängigkeit zur Service-Implementation nur zum Interface
• keine Instanziierung von Service-Bean
• Service-Bean wird vom Container instanziiert und „injiziert“ (dem annotierten Feld
zugewiesen)
@EJB!
private IPersonService personService;!
public String save() {!
!
personService.save(this);!
!
return "Person";!
}!
• Vorteile von DI
• Implementation kann ausgetauscht werden
• Separates Deployment
• Instanzen-Pooling durch Container
© itemis AG
40
Transaktionsmanagement (JTA)
• Management der Transaktionen durch den Container
• Zwei Möglichkeiten
• BeanManaged-Transactions (Steuerung durch den Benutzer)
• ContainerManaged-Transactions
• Begin-, Commit und Rollback-Steuerung durch Container an den
Transaktionsgrenzen (Begin, Commit implizit, Rollback bei System Exception oder
manuell mit setRollbackOnly())
• Steuerung durch @TransactionAttribute an (Service-)Bean oder Methoden
• Default: REQUIRED: gerufene Methode in selber
TA wie aufrufende, wenn TA bereits geöffnet,
sonst neue TA öffnen
• REQUIRES_NEW: neue (autonome) TA
• MANDATORY, NEVER, NOT_SUPPORTED,
SUPPORTS!
© itemis AG
41
Java Persistence API (JPA 2.0)
Eine Einführung
© itemis AG
Aufbau einer Anwendung
• Persistence Tier
• Entity Beans
• JPA (Java Persistence API)
© itemis AG
43
JPA – Java Persistence API
• App-Server-Hersteller verwenden meist ihre eigene JPA-Implementation
• JBOSS – Hibernate, Oracle – EclipseLink, Glassfish – EclipseLink
• Datenhalter sind Entities, einfache POJOs
• Eigene Query-Languange JPQL
• Mapping über Annotationen oder xml
© itemis AG
44
JPA Entities
• Datenbankanbindung durch Mapping
von einfachen Java-Klassen auf
Tabellen
• i.d.R. eine Klasse eine Tabelle
• Klassen als einfache Beans
• Felder mit Settern und Gettern
• Mapping Klasse Tabelle
• Annotationen
• @Entity an Klasse opt.Tabellenname
• @Basic (optional) an Spalten
• @Id für Schlüssel-Spalte
• @Column opt. Spaltenname
• alternativ XML-Mappingdefinition
@Entity(name=“TABLE_NAME")
public class Customer {
private String name;
@Id
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private String mail;
@Column(name="COLUMN")
public String getMail() {
return mail;
}
public void setMail(String mail) {
this.mail = mail;
}
@Basic
public String address;
public Customer() {}
}
© itemis AG
45
JPA EntityManager
• In einer SessionBean injiziert über @PersistenceContext(unitName=„Name“)
• Ist entweder TransactionScoped oder Extended
• Managed den Lifecycle einer Entity
• javax.persistence.EntityManager
• Stellt Methoden für das Finden, Löschen, Einfügen von Daten bereit
• persist(Object), find(Class, Id), remove(Object), merge(Object)
• Weiterhin Methoden für
• Queries (createQuery), NamedQueries (createNamedQuery),
NativeQueries(createNativeQuery)
© itemis AG
46
JPA Entities
• Weitere Mapping-Annotationen für
• Spalteneigenschaften
• Not Null, Default, Datentyp, Generierung des Wertes, Indexe, ...
• Beziehungen
• Many-to-One, One-To-One, One-To-Many
• Referentielle Itegrität
• Ableitungshierarchien bei Entities können definiert werden
• verschiedene Abbildungsstrategien auf Tabellen
• Hierarchietabelle
• horizontal / vertikal partitioniert
• Tabelle pro Subtyp
• ...
© itemis AG
47
JPA Entity
package de.skatulla.jee.entities;!
import javax.persistence.Column;!
import javax.persistence.Entity;!
import javax.persistence.Id;!
@Entity!
public class Person {!
private String _name;!
private String _id;!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
}!
@Column!
public String getName() {!
!
return _name;!
}!
public void setName(String name) {!
!
_name = name;!
}!
!
@Id!
public String getId() {!
!
return _id;!
}!
public void setId(String id) {!
!
_id = id;!
}!
!
!
© itemis AG
48
JPA-Konfiguration
•
src/META-INF/persistence.xml
<?xml version="1.0" encoding="UTF-8"?>!
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence"!
!
!
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"!
!
!
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence!
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">!
!
!
!
<persistence-unit name="mypersistenceunit">!
!
!
<jta-data-source>jdbc/jee-test</jta-data-source>!
!
!
<properties>!
!
!
!
<!-- EclipseLink should create the database schema automatically -->!
!
!
!
<property name="eclipselink.logging.level" value="OFF" />!
!
!
!
<property name="eclipselink.ddl-generation" value="create-tables" />!
!
!
!
<property name="eclipselink.ddl-generation.output-mode" value="database" />!
!
!
</properties>!
!
</persistence-unit>!
</persistence>!
© itemis AG
49
JPA Verwendung in Session Beans
• Zugriff auf Entity-Manager
• per Dependency Injection
• Interface EntityManager!
• Annotation
@PersistenceContext
mit definiertem Namen der
Persistence Unit
• Entity anlegen
• über Entity-Manger speichern
package de.skatulla.jee.services;!
import ...!
@Stateless!
public class PersonServiceImpl implements IPersonService {!
!
@PersistenceContext(name="mypersistenceunit")!
!
private EntityManager entityManager;!
!
!
!
!
@Override!
!
public void save(PersonBean personBean) {!
!
!
personBean.setId(UUID.randomUUID().toString());!
!
!
!
!
!
Person person = new Person();!
!
!
person.setId(personBean.getId());!
!
!
person.setName(personBean.getName());!
!
!
entityManager.persist(person);!
!
}!
!
!
}!
© itemis AG
50
JPA Query
• getSingleResult()
• getResultList()
• getFirstResult()
• setParameter()
• setHint()
• excecuteUpdate()
© itemis AG
51
JPA Transaktionen
• Transaktionsteilnahme erfolgt wie konfiguriert
• Resource_Local
EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
//Operationen auf dem EntityManager
em.close();
• JTA
• bei CMT voll automatisch (Methoden-Ein- und Austritt)
• Bei BMT TransactionManager vom Context holen
• TransaktionManager.begin(), commit() und rollback()
© itemis AG
52
JPA Query Language
• SQL-ähnliche Syntax
• Navigation über Objektgraphen
• Beispiel
select
protocol
from
Protocol protocol
where
protocol.protocolId.prt_id = :id
© itemis AG
53
JPA – Weitere Möglichkeiten
• Callbacks an Entities
• @PrePersist, @PostPersist, @PreRemove, @PostRemove, @PreUpdate,
@PostUpdate, @PreLoad
• Vererbungsstrategien
• Eine Tabelle pro Klassenhierachie (mit Diskriminator-Feld)
• Eine Tabelle pro konkreter Entityklasse
• Join-Tabelle mit separaten Tabellen per SubClass und ParentClass
• Unterstützung verschiedener Generierungsmechanismen für Ids (z. B.
Sequences, UUID)
© itemis AG
54
Java EE – Verschiedene Anmerkungen
Eine Einführung
© itemis AG
Wichtige Konzepte
• Trennung von API und dessen Implementierung
• Spezifikation von Schnittstellen für verschiedenste Komponenten und
Aspekte
• Einsatz von APIs erleichtert in der Theorie den Austausch der verwendeten
Implementierung
• Dependency Injection
• Beans mit minimalen Abhängigkeiten untereinander
• Abhängigkieten nur zum Interface
• Wiring von Instanzen von außen
• Abhängige Objekte werden von DI-Framework injiziert
© itemis AG
56
Wichtige Konzepte
• Client-Server-Modell
• JavaSE ausgerichtet auf Entwicklung und Betrieb von Java Programmen auf
Einzelplatzrechnern / JavaEE für Betrieb auf Servern zur Umsetzung von
Diensten gedacht
• Client verwendet die bereitgestellten Server-Dienste ◊ Aufteilung auf mehrere
VMs (und verschiedene Rechner) / Kommunikation zwischen Client und
Server als zusätzlicher Aspekt
• Mehrschichtige Anwendungen
• Aufteilung von Anwendungen in verschiedene Schichten mit klar getrennten
Aufgabenbereichen
© itemis AG
57
„Klassische“ JavaEE-Anwendung
• Aufteilung der zu erstellenden Komponenten auf die verschiedenen Schichten
• Verwendung der spezifizierten und vom Applicationserver bereitgestellten
JavaEE Komponenten mit ihren jeweiligen Schnittstellen (APIs)
• Externe Ressourcen werden den Anwendungen vom Applicationserver
zugänglich gemacht Konfiguration dieser Ressourcen mittels
Applicationserver-Schnittstellen
• Deployment einzelner Anwendungen in Form von .war und .ear Paketen mit
zum Teil Applicationserver spezifischen Konfigurationen
• Management und Überwachung von installierten Anwendungen durch
Applicationserver
© itemis AG
58
JMS
• Queues
• Point-to-Point
• Topics
• Publish - Subscribe
© itemis AG
59
JMS
© itemis AG
60
JMS – Arten von Nachrichten
• Message – Nachricht ohne Inhalt (Body)
• StreamMessage – Nachricht mit einem Stream von Java-Primitiven
• MapMessage – Nachricht mit einer Map von Java-Objekten
• TextMessage – Nachricht mit einem String (z. B. für XML-Messages)
• ObjectMessage – Nachricht mit einem serialisierten Java Objekt
• BytesMessage – Nachricht mit einem Stream von Bytes
© itemis AG
61
JMS – Nachrichten versenden
• ConnectionFactory erstellen
• Connection erstellen
• Session erzeugen
• Message erzeugen
• Message senden
• Asynchron
• MessageProducer.send(Message)
• MessageProducer versendet die Nachricht, ohne auf eine Antwort zu warten
• Synchron
• QueueRequestor.request(Message)
• Request-/Response-Verfahren
• MessageProducer.send(Message) und MessageConsumer.receive(timeToWait)
• MessageConsumer wartet bestimmte Zeit auf Antwort
© itemis AG
62
JMS – Nachrichten empfangen
• Entweder MessageDrivenBean, die sich auf eine Queue/Topic registriert hat
• oder Thread, der auf eingehende Nachrichten wartet
• Implementiert wird javax.jms.MessageListener onMessage(Message)
• Consumer (Queue) bzw. Subscriber (Topic) lauscht über den Listener
© itemis AG
63
EJBs – Enterprise Java Beans
• Gelten als Komponenten einer Anwendung und beinhalten deren
Geschäftslogik oder gestatten Zugriff auf persistente Daten
• Werden innerhalb eines EJB-Containers ausgeführt
• Aufgaben
• Kapselung der Geschäftslogik
• Transaktionsmanagement
• Loadbalancing
• Es gibt drei unterschiedliche Typen von EJBs
• Session-Beans, sowohl statusbehaftet als auch ohne internen Status, welche
die Geschäftslogik implementieren und meistens vom Client zugreifbar sind
• Message-Driven-Beans (MDB) für die Verarbeitung von JMS-Nachrichten
• Entity-Beans für die Abbildung von persistenten Datenobjekten
© itemis AG
64
Probleme von Java EE
• Portabilität von JavaEE-Anwendungen auf verschiedene Applicationserver ist
durch proprietäre Erweiterungen stark eingeschränkt
• durch die hohe Anzahl der APIs ist der Lernaufwand sehr hoch
• Theoretisch sollte durch die APIs die Komplexität reduziert werden. Praktisch
muss der Entwickler trotzdem oft wissen, was genau hinter der API steckt
• J2EE mit EJB2 war sehr umständlich - EJB3 verbessert durch zahlreiche
Vereinfachungen
• Standardisierte Rahmenbedingungen können als Einschränkungen wirken
© itemis AG
65
Ausblick auf die weiteren Veranstaltungen
Uni Jena, 2013-05-06
© itemis AG
Die nächsten Veranstaltungen mit Gästen
03.06.
8-12
Michael Plöd, Senacor
JPA
17.06.
8-10
Ralph Winzinger, Senacor
Ein großes MDSD-JavaEE-Projekt
10-12
Christian Zander, Greenpike
Scrum-Einführung in einem großen
MDSD-JavaEE-Projekt
24.06.* 8-12
Detlef Hornbostel, Ibykus
Ein alternativer MDSD-Ansatz
01.07.* 8-12
Alexander Nittka, itemis
Modellierung von Verhalten
– Algorithmen in Modellen
* evtl. Termine vertauscht
© itemis AG
67
