Enterprise Java Beans - Teil 1 Motivation, Übersicht und JMX Service

Enterprise Java Beans - Teil 1
Motivation, Übersicht und JMX Service
■ Motivation
■ Enterprise JavaBeans: Konzepte
■ Enterprise JavaBeans: Bean Arten
■ Monitoring und Management Dienst: JMX
Motivation: Trennen von Verantwortlichkeiten
"Separation of Concerns" und Komponenten
School of Engineering
© K. Rege, ZHAW
2 von 60
Ausgangslage
Geräte mit
unterschiedlichen
Eigenschaten
Enterprise Anwendungen
EIS
Daten von
verschiedenen Quellen
School of Engineering
© K. Rege, ZHAW
Peter Tomczyk
200560
3 von
1. Schritt: Trennen von Verantwortlichkeiten
■ Erstellung von "Kapseln" mit klaren Schnittstellen und Aufgaben (z.B. Klassen)
DarstellungsDarstellungs-und
und
Interaktionssteuerung
Interaktionssteuerung
Konto
KontoÜbersicht
ÜbersichtJSF
JSF
Bestellung
Bestellung
Sicherheitsdienst
Sicherheitsdienst
Verbindungsdienst
Verbindungsdienst
LebenszyklusLebenszyklusdienst
dienst
Transaktionssteuerung
Transaktionssteuerung
Konto
Konto
Vertrag
Vertrag
Kunde
Kunde
Zustandsverwaltung
Zustandsverwaltung
Persistenzdienst
Persistenzdienst
Konto
KontoDB
DB
School of Engineering
DB
DBAdministration
Administration
© K. Rege, ZHAW
Peter Tomczyk
4 von 60
2. Schritt: Aufteilung nach Tier-"Rolle"
■ Aufteilung nach Hauptverantwortlichkeit (Darstellung, Logik, Persistenz)
DarstellungsDarstellungs-und
und
Interaktionssteuerung
Interaktionssteuerung
Konto
KontoÜbersicht
ÜbersichtJSF
JSF
Bestellung
Bestellung
Sicherheitsdienst
Sicherheitsdienst
Verbindungsdienst
Verbindungsdienst
Vertrag
Vertrag
Logik
LebenszyklusLebenszyklusdienst
dienst
Transaktionssteuerung
Transaktionssteuerung
Konto
Konto
Darstellung
Kunde
Kunde
Zustandsverwaltung
Zustandsverwaltung
Persistenzdienst
Persistenzdienst
Konto
KontoDB
DB
DB
DBAdministration
Administration
Persistenz
Datenquellen
School of Engineering
© K. Rege, ZHAW
Peter Tomczyk
5 von 60
3. Schritt: Abtrennung von geteilten Diensten
■ Trennung von fachlichen und technischen (geteilten) Bestandteilen
<- fachlich
Konto
KontoÜbersicht
ÜbersichtJSF
JSF
technisch ->
Session
Darstellungsund
Session
Darstellungsund
Verwatlung
Interaktionssteuerung
Verwatlung
Interaktionssteuerung
Application
Client Container
Lebenszyklusdienst
Lebenszyklusdienst
Verbindungsdienst
Verbindungsdienst
Bestellung
Bestellung
Persistenzdienst
Persistenzdienst
Kunde
Kunde
Konto
Konto
Sicherheitsdienst
Sicherheitsdienst
Transaktionssteuerung
Transaktionssteuerung
Vertrag
Vertrag
Konto
KontoDB
DB
School of Engineering
Application
Container
Zustandsverwaltung
Zustandsverwaltung
DB
DBAdministration
Administration
© K. Rege, ZHAW
Persistency
Container z.B.
Database
Peter Tomczyk
6 von 60
Komponenten Definition
■ Komponenten sind vielfältig einsetzbare,
in sich abgeschlossene Funktionseinheiten
■ Komponenten interagieren ausschliesslich über
wohldefinierte Schnittstellen mit ihrer Umgebung.
Component
Component
Container
■ Komponenten leben in einer Laufzeitumgebung
oder auch Einsatzumgebung, dem Behälter
■ Komponenten können leicht und flexibel zu grösseren Funktionseinheiten
gruppiert werden: Aggregation
■ Beispiele:
■
■
■
■
Kunde (Geschäftsobjekt)
Bestellung (Geschäftsobjekt)
Kundenverwaltung (komplexe Komponente)
Produktkatalog (komplexe Komponente)
■ Es gibt keine vordefinierte Granularität aus technischer Sicht
■
eher grobe Granularität (eine bis mehrere Klassen)
School of Engineering
© K. Rege, ZHAW
7 von 60
Komponenten Eigenschaften
■ Komponenten sind Softwaremodule, die auf Binärcodeebene
wiederverwendbar sind
■ Komponenten sind selbstbeschreibend sowohl hinsichtlich ihrer exportierten
als auch ihrer importierten Dienste
■ Komponenten sind konfigurierbar
■ Komponenten können einzeln verteilt werden
■ Komponenten bzw. ihre Konfigurationen werden durch Werkzeuge
unterstützt
■ Komponenten implementieren meist keine Infrastrukturdienste, sondern
beziehen sie aus ihrer Einsatzumgebung (Ausnahme:
Infrastrukturkomponenten)
School of Engineering
© K. Rege, ZHAW
Peter Tomczyk
8 von 60
Komponenten Behälter
■ Der Komponenten Behälter ist die Laufzeitumgebung der Komponenten
■ Der Behälter ist für den Lebenszyklus der Komponenten verantwortlich
(z.B.Instanzierung)
■ Der Behälter ist für die technischen Aspekte (Infrastrukturdienste) der
Komponenten verantwortlich (Sicherheit etc.)
■ Der Behälter bietet selber eine Schnittstelle an, über die die Komponenten die
Dienste in Anspruch nehmen können
■ Der Behälter können selber wieder in einem Behälter eingebettet sein (z.B.
Betriebssystem), schirmen die Komponenten von diesem ab
■ Beispiele von Komponenten in Java:
■
■
JavaBeans : "gewöhnliche" Java Bohnen, z.B. im GUI verwendet, Behälter J2SE
Enterprise JavaBeans: Java Bohnen, die in einem EJB Container leben, Behälter EJB Container
School of Engineering
© K. Rege, ZHAW
9 von 60
Vorteile des gewählten Ansatzes
■ Mehrschichtenarchitektur
■
■
■
Austauschbarkeit einzelner Schichten
1:N-Lösungen (z.B. eine Logik – mehrere Oberflächen)
2-10-50 Regel: 2 Jahren GUI, 10 Jahre Logik, 50 Jahre Daten
■ „Separation of Concerns“
■
technische Aspekte sind separiert -> Konzentration auf Fachlogik
■ Modularisierung
■
Vorgegebene Strukturierung der Aufgabe
■ Verwendung von Komponenten
■
Einfache Entwicklung, Wiederverwendbarkeit und Austauschbarkeit
■ Standardisierung
■
■
Teillösungen von verschiedenen Anbietern: "Best of Breed" Ansatz
Vielfach erprobte Lösungen
■ Aber
■
■
Gefahr der "one-fits-all" Komplexität
z.T: implizite, enge Kopplung von Komponenten und Behälter
■ -> Evolution des Behälters selber ist schwierig
School of Engineering
© K. Rege, ZHAW
Peter Tomczyk
10 von 60
Enterprise JavaBeans: Konzepte
School of Engineering
© K. Rege, ZHAW
11 von 60
Oracle Java Enterprise Edition 5
■ JEE5 früher J2EE:
„J2EE
„J2EEdefines
definesthe
thestandard
standardfor
fordeveloping
developing
component-based
multitier
enterprise
component-based multitier enterprise
applications.“
applications.“[java.sun.com/j2ee/]
[java.sun.com/j2ee/]
"Enterprise
"EnterpriseJavaBeans:
JavaBeans: „...stellt
„...stelltininJ2EE
J2EE
die
zentrale
Technologie
zur
Abbildung
die zentrale Technologie zur Abbildungvon
von
Geschäftslogik
und
Geschäftsdaten
dar.“
Geschäftslogik und Geschäftsdaten dar.“
[Backschat/Gardon]"
[Backschat/Gardon]"
■ Entwickelt von Sun Microsystems (ab 1997)
■ Spezifikationen ursprünglich von Sun/Oracle allein, heute breiter abgestützt
durch den Java Community Process (JCP)
■ Resultate der JCPs werden Java Specification Requests (JSR) bezeichnet
■ JSR220: EJB 3 Standard seit 2006
http://jcp.org/aboutJava/communityprocess/final/jsr220/index.html
School of Engineering
© K. Rege, ZHAW
12 von 60
Oracle Java EE 5
■ Aufteilung in Schichten nach Oracle
http://java.sun.com/javaee/5/docs/tutorial/doc/index.html
http://java.sun.com/javaee/5/docs/api/
School of Engineering
© K. Rege, ZHAW
13 von 60
Java Enterprise Edition: Java EE 5
"HTTP Interpreter"
Browser
Browser
Browser
Client
Browser
Client
Client
Client
Application
Client Container
HTTP
JDBC
JSP/JSF*
JSP/JSF*
Web
WebContainer
Container
z.B.
Tomcat
z.B. Tomcat
RMI/IIOP
SOAP*
NonNonBrowser
Browser
Client
Client
Business
Business
Logic
Logic
EJB Container
z.B. Glassfish
Application Server
Application
Client Container
School of Engineering
Oracle
MySQL
z.B. MQ
Existing
Applications
© K. Rege, ZHAW
14 von 60
Java Enterprise Edition Architektur
■ Die EJB Architektur beschreibt die Verantwortlichkeiten und Interaktionen
folgender Teile
Application
ApplicationServer
Server
EJB
EJBClient
Client
Enterprise
EnterpriseJavaBeans
JavaBeans
EJB
EJBContainer
Container
Object
ObjectRequest
RequestBroker
Broker
Data
DataSources
Sources
EJB
EJBClient,
Client,
z.B.
Tomcat
z.B. Tomcat
Enterprise
Enterprise
JavaBean
JavaBean
EJB Container
z.B. JBoss
Object Request Broker (ORB)
Application Server
School of Engineering
© K. Rege, ZHAW
15 von 60
Anwendungsserver
■ Stellt die Laufzeitumgebung für EJB Container zur Verfügung
■
■
■
■
■
Prozess und Thread Verwaltung
Verwaltung von System Ressourcen
Netzwerkverbindungen
Datenbankverbindungen mit Pooling und Caching
APIs für Systemverwaltung
Linux, Solaris, Windows, etc
School of Engineering
© K. Rege, ZHAW
16 von 60
Enterprise JavaBean (EJB)
■ Komponenten die Anwendungslogik enthalten
■ Meist mehrere, Anwendungsdomänen spezifisch: Kunde, Konto, etc.
■ Implementiert zwei Arten von Schnittstellen:
■
■
fachliche, so dass Anwendung strukturiert wird
technische, so dass sie vom EJB Container verwaltet werden kann
■ Nimmt Dienste des EJB Containers in Anspruch
■ Kann (meist) über das Netzwerk angesprochen werden
Enterprise
Enterprise
JavaBean
JavaBean
School of Engineering
© K. Rege, ZHAW
17 von 60
EJB Container
■ Stellt Laufzeitumgebung in Form von Diensten für Enterprise JavaBeans zur
Verfügung
■ Oracle liefert Spec. und Referenzimplementation
■
Monitoring
Monitoring&&Management
Management
Hersteller: IBM, BEA, JBoss
■ Hersteller sind verpflichtet alle Schnittstellen für
EJB‘s einzuhalten -> Test Suite
-> Kompatibilitätslogo
■ Hersteller darf jedoch sog. "Value-added-features"
einbauen -> Kompatibilitätsprobleme
Lebenszyklusverwaltung
Lebenszyklusverwaltung
Verzeichnis-/Verbindungsdienst
Verzeichnis-/Verbindungsdienst
Zustandsverwaltung
Zustandsverwaltung
Sicherheitsdienst
Sicherheitsdienst
Transaktionssteuerung
Transaktionssteuerung
Persistenzdienst
Persistenzdienst
School of Engineering
© K. Rege, ZHAW
18 von 60
Einordnung
■ Virtual Machine
■ vs. Lightweight Container
Einheit die
verwaltet wird
■ vs. Application Container
VM1
VM2
App
AppAA
App
AppAA
Container 1
Container 2
Bins/Libs
Bins/Libs
Bins/Libs
Bins/Libs
App
AppAA
App
AppAA
Guest
GuestOS
OS
Guest
GuestOS
OS
Bins/Libs
Bins/Libs
Bins/Libs
Bins/Libs
EJBs
Dienste
Dienste
App
AppAA
Hypervisor
Hypervisor
Docker
DockerEngine
Engine
EJB/Web
EJB/WebContainer
Container
Host
HostOS
OS
Host
HostOS
OS
Host
HostOS
OS
Server
Server
Server
Server
Server
Server
School of Engineering
© K. Rege, ZHAW
19 von 60
Container-Bean Interaktionen (3 von 4 Arten)
■ 1. Abfangen (Interception)
■
■
EJB Container Isoliert Enterprise JavaBean von Klient
Setzt z.B. Transaktionen, Sicherheit vor und nach dem Aufruf
■ 2. über Container-Schnittstelle: Aufruf
■
Beans können Methoden des Containers aufrufen um Container Services zu benutzen
■ 3. über Bean-Schnittstelle: Rückruf
■
Beans können aufgerufen werden (Callback) über definierte Interfaces der Beans (oder mit
Annotationen gekennzeichnete Methoden)
EJB Container
Client
client request
Sicherheitsdienst
Sicherheitsdienst
Transaktionssteuerung
Transaktionssteuerung
Persistenzdienst
Persistenzdienst
call to container
Enterprise
Enterprise
JavaBean
JavaBean
School of Engineering
callback
© K. Rege, ZHAW
20 von 60
EJB Client
■ Klient ruft die Enterprise JavaBean auf
■ Aufruf wird durch EJB Container kontrolliert und "abgefangen"
■ Klient findet das Enterprise JavaBean mittels JNDI
■ Klient kann Enterprise JavaBean über den ORB ansprechen
■ Ein Enterprise JavaBean kann selber andere Beans aufrufen -> wird somit
ebenfalls zum "Klienten"
EJB
EJBClient,
Client,
z.B.
Tomcat
z.B. Tomcat
School of Engineering
© K. Rege, ZHAW
21 von 60
Object Request Broker
■ Ermöglicht den Zugriff von Enterprise JavaBean Methoden über Maschinen- und
Prozessgrenzen hinweg
■
■
EJBs müssen gefunden werden (Verzeichnisdienst)
Methoden müssen aufgerufen und Daten müssen ausgetauscht werden können
■ Zumindest RMI muss unterstützt sein, andere Protokolle möglich (CORBA,
SOAP); Serialisierung (Marshalling) der Java Typen muss unterstützt sein
■ Zusätzlich ist ein Verzeichnisdienst erforderlich, z.B. JNDI
■ EJB Client und EJB Container können über ORB miteinander kommunizieren
■ EJB Container können untereinander über ORB kommunizieren
Verzeichnisdienst
Object
Request
Broker
Object
Request
Broker
(ORB)
School of Engineering
© K. Rege, ZHAW
22 von 60
Data Sources
■ Sind die persistenten Datenspeicherung
■ kann eine Datenbank sein -> wird über JDBC angesprochen
■ sollte in verteilten Transaktionen eingebunden werden können -> 2PC Protokoll
unterstützen
■ Können aber auch andere Enterprise Information Systems (EIS) sein (z.B. SAP)
-> eigene Zugriffsprotokolle
School of Engineering
© K. Rege, ZHAW
23 von 60
Enterprise JavaBeans:
Session Beans
Entity Beans
Message Driven Beans
School of Engineering
© K. Rege, ZHAW
24 von 60
3 Arten von Enterprise Beans
■ 3 Arten von Enterprise Beans mit unterschiedlichen Eigenschaften
■ Session Bean
■
■
Enthält die Geschäftslogik
ist entweder stateless oder statefull
■ Entity Bean
■
■
Repräsentiert den Zustand ("Geschäftsobjekte")
Ist persistent, d.h. Werte überdauern Container Neustart
■ Message-Driven Bean
■
Dienst für Zugriff auf asynchrone Schnittstelle (JMS)
Wahl
Wahlder
derArt
Artdes
desBeans
Beans
jejenach
Anforderungen,
nach Anforderungen,
bzw.
bzw.dem
demgewünschten
gewünschten
Verhalten
Verhalten
<<Entity Bean>>
<<Entity Bean>>
Konto
Konto
<<Session Bean>>
<<Session Bean>>
BankService
BankService
<<Entity Bean>>
<<Entity Bean>>
Vertrag
Vertrag
<<MDB>>
<<MDB>>
BankVerbindung
BankVerbindung
School of Engineering
© K. Rege, ZHAW
25 von 60
Session Bean - Eigenschaften
■ Repräsentiert einen Prozess, Verhalten oder Ablauf
■ Enthält die Geschäftslogik
<<Session Bean>>
<<Session Bean>>
BankServices
BankServices
■ Hat keine (persistenten) Daten sondert operiert auf diesen
■ Greift auf andere Beans zu - Session, Entity, MDB
■ Hat einen leeren Konstruktor
■ Ist zustandslos (stateless) oder zustandsbehaftet (statefull) -> später
■ Wird oft direkt vom Klienten lokal oder entfernt aufgerufen
■ Kann (optional) Teil einer Transaktion sein
School of Engineering
© K. Rege, ZHAW
26 von 60
Entity Bean - Eigenschaften
■ Repräsentiert einen Zustand
<<Entity Bean>>
<<Entity Bean>>
■ persistente Werte von Geschäftsentitäten
Konto
Konto
■ Bildet eine Datenquelle auf eine Klasse ab
■ Jede Entity Bean Instanz
■
■
■
■
repräsentiert einen Daten-Satz, z.B. Konto des Herrn Müllers
muss einen eindeutigen Schlüssen haben
kommt nur einmal im System vor
ab EJB3 Entity Bean = JPA Managed Object
■ Überlebt die Verbindungszeit und sogar die Container Lebenszeit
■ Kann nicht direkt vom Klienten angesprochen werden sondern ausschliesslich
über lokale Session Beans
■ Immer Teil einer Transaktion
School of Engineering
© K. Rege, ZHAW
27 von 60
Message-Driven Bean - Eigenschaften
<<MDB>>
<<MDB>>
BankVerbindung
BankVerbindung
■ Realisiert einen asynchronen Prozess oder
ist ein Vermittler
■ Entspricht inhaltlich einem stateless SessionBean
■ MDBs reagieren als Listeners von Meldungs Brokern, die via JMS
angesprochen werden.
■ Die Meldung kann von jeder JEE5 Komponente gesendet werden: einem
Anwendungs-Klienten, einem anderen EJB, einer Web Komponenten oder
einem nicht-JEE5 System: Dient auch als Vermittler zu anderem System
■ Hat keine persistenten Daten oder Zustand
■ Kann optional Teil einer Transaktion sein
School of Engineering
© K. Rege, ZHAW
28 von 60
Übersicht - Eigenschaften
Session Bean
Entity Bean
MDB
Prozess/Logik
Zustand
Vermittler
statefull:ja
ja
nein
Zustands-/
Persistenzverwalter
stateless:-
BMP:Bean
-
statefull:Container
CMP:Container
Lebensdauer
des Zustands
Aufruf/Session
∞
Aufruf
Zugriff
entfernt/lokal
lokal
entfernt
Teil von
Transaktion
optional
immer
optional
Hauptanwendung
Zustand
(indiv. für Klient)
School of Engineering
stateless:nein
© K. Rege, ZHAW
29 von 60
Entwurf: Wahl von Enterprise Bean Typ
■ Meist eindeutig durch Zweck und/oder Eigenschaften bestimmt
■ Prozess/kein Zustand -> Session Bean
■ Mit Zustand als Teil von Prozess -> Entity Bean
■ Mit Zustand entfernter Zugriff -> Session + Entity Bean
■ Schnittstelle zu anderem System MDB
Hat
Hatpersistenten
persistentenZustand,
Zustand,
wird
lokal
über
BankService
wird lokal über BankService
angesprochen
angesprochen
hat
hatkeinen
keineneigenen
eigenenZustand,
Zustand,
verarbeitet
verarbeitetlediglich
lediglichDaten,
Daten,
wird
entfernt
zugegriffen
wird entfernt zugegriffen
<<Entity Bean>>
<<Entity Bean>>
Konto
Konto
<<Session Bean>>
<<Session Bean>>
BankService
BankService
<<Entity Bean>>
<<Entity Bean>>
Vertrag
Vertrag
<<MDB>>
<<MDB>>
BankVerbindung
BankVerbindung
School of Engineering
© K. Rege, ZHAW
Verbindung
Verbindungzu
zuanderer
andererBank
Bank
30 von 60
Aufbau einer EJB Komponente
■ Eine EJB Komponente besteht aus eine Menge von Klassen, Interfaces und
Beschreibungsdateien
■ In EJB 3.0 sind gegenüber EJB 2.1 einige weggefallen
■ Enterprise Bean Klasse: Implementation der Funktionalität; entweder Session
oder MDB
School of Engineering
© K. Rege, ZHAW
Local
Local
Impl
Impl
Remote
Remote
Stub,Impl
Stub,Impl
generiert
Remote
Interface
■ Deployment Descriptor:
Konfigurationseinstellungen eines EJB
Local
Interface
■ Remote und Local Interfaces: Schnittstelle für die eigentliche Logik des Beans;
wird auch benötigt um Hilfsklassen für den entfernen Zugriff zu generieren (z.B.
RMI)
EJB Class
Deployment
Descriptor
Manifest
31 von 60
Remote Interface
■ Schnittstelle für den remote Zugriff auf die EJB Klasse
■ Namenskonvention: BeanNameRemote.java oder auch einfach BeanName.java
■ Hat dieselben Methoden wie die dazugehörige EJB Klasse
■ Stub und Imp für Kommunikation werden aus Interface generiert
■ Impl. delegiert an Container weiter (nicht an EJB Klasse direkt) diese dann
weiter an Bean Implementation
■
Einstiegspunkt für "Interception"; z.B. Sicherheit, Transaktion, etc.
Home
Stub, Imp
Remote
Remote
Stub,
Impl
Stub,
Imp
EJB Class
Remote
Remote
Interface
Interface
public
public interface
interface BankService
BankService {{
public
public KontoData
KontoData getKontoFor(String
getKontoFor(String acctName)
acctName)
throws
Exception;
throws Exception;
}}
Home
Interface
■ Remote Client spricht EJB immer über R. Interface an
Deployment
Descriptor
School of Engineering
© K. Rege, ZHAW
Manifest
32 von 60
Local Interfaces
■ zweiter Satz von Schnittstellen für den lokalen Zugriff
■ zur Optimierung für Zugriff innerhalb derselben VM
■ Namenskonvention: BeanNameLocal.java
■ Entwickler kann Remote, Local Interfaces oder beide erweitern
Home
Local
Stub, Imp
Local
Impl
Impl
Deployment
Descriptor
School of Engineering
© K. Rege, ZHAW
EJB Class
Remote
Stub, Imp
Remote
Interface
public
public interface
interface BankServiceLocal
BankServiceLocal {{
public
public AccountData
AccountData getAccountFor(String
getAccountFor(String acctName);
acctName);
}}
Home
Local
Interface
Interface
■ Achtung: Unterschiede beim Gebrauch: z.B. byRef und byVal
Parameterübergabe, Exceptions
Manifest
33 von 60
Deployment Descriptor
■ ejb-jar.xml: Hier werden die (standard) Konfigurationseinstellungen eines EJB
hinterlegt, diese werden vom EJB Container verwendet um ein EJB ausführen
zu können
■ Ab EJB3 die meisten Eigenschaften von Beans via Annotation
DTO, Exception
etc Classes
Home
Stub, Imp
Remote
Stub, Imp
Remote
Interface
<?xml
<?xmlversion="1.0"
version="1.0"encoding="UTF-8"?>
encoding="UTF-8"?>
<ejb-jar
…
>
<ejb-jar … >
<description>
<description>Stateless
StatelessBankService
BankServiceBean</description>
Bean</description>
<display-name>BankService
Bean
Example
<display-name>BankService Bean Example(stateless)</display-name>
(stateless)</display-name>
<enterprise-beans^/>
<enterprise-beans^/>
</ejb-jar>
</ejb-jar>
…..
…..
Home
Interface
■ können durch Einträge im Deployment Descriptor übersteuert werden
Deployment
Deployment
Descriptor
Descriptor
School of Engineering
© K. Rege, ZHAW
EJB Class
Manifest,
Manifest
etc.
34 von 60
Enterprise Bean Implementation
■ Implementation der anwendungsspezifische Funktionalität
■ Namenskonvention: BeanNameBean.java
■ Implementiert die Home/Remote Interfaces i. Allg. nicht direkt, sondern ist nur
lose verpflichtet über Namenskonvention
}
}
School of Engineering
© K. Rege, ZHAW
Remote
Stub, Imp
EJB Class
EJB Class
Remote
Interface
// own Methods implementation
// own Methods implementation
public AccountData getAccountFor(String acctName) {
public AccountData getAccountFor(String acctName) {
… …
… …
… …
… …
}
}
DTO, Exception etc
Classes
Home
Interface
@Stateless
@Stateless
@Remote (BankService.class)
@Remote (BankService.class)
@Local (BankServiceLocal.class)
@Local (BankServiceLocal.class)
public class BankServiceBean {
public class BankServiceBean {
// Session Bean methods implementation
// Session Bean methods implementation
@PostConstruct
@PostConstruct
public void activate() {…}
public void activate() {…}
Home
Stub, Imp
■ Die Callback Methoden mit den entsprechenden Annotationen, z.B.
@PostConstruct
Deployment
Descriptor
Manifest
35 von 60
Session Bean Implementation
■ Implementiert einen Geschäftsablauf, -Logik, z.B. Banküberweisung
■ Callbacks werden vom Container bei Zustandswechsel aufgerufen
@PostConstruct
public void activate();
2 Varianten von Session Beans
■ Stateless: speichert keine Information zwischen den Aufrufen; dadurch schneller
als statefull
■ Statefull: Zustand wird zwischen Client-Aufrufen gehalten; eine Instanz ist über
mehrere Methodenaufrufe explizit einem Client zugeordnet, bis sie mittels
remove() wieder freigegeben, die Verbindung unterbrochen wird oder ein
Timeout abgelaufen ist.
School of Engineering
© K. Rege, ZHAW
36 von 60
Entity Bean in EJB3 = JPA
■ Ein Entity Bean entspricht einer persistenten Geschäftsentität
■
z.B. einem Datensatz in der Datenbank
■ Jedes Entity Bean wird durch eindeutigen Schlüssel identifiziert
■ Lokal angesprochen via EntityManager
@Entity
@Entity
@Table(name = "Dozenten")
@Table(name = "Dozenten")
public class Dozent implements
public class{Dozent implements
Serializable
Serializable {
String getName() ..
String
getName() ..name) ...
void
setName(String
void setName(String name) ...
}
}
School of Engineering
DTO, Exception etc
Classes
public Collection <Dozent> findByName (String namePattern) {
public Collection <Dozent> findByName (String namePattern) {
return em.createQuery(...)
return em.createQuery(...)
}
}
EJB Class
EJB Class
Remote
Interface
@PersistenceContext (unitName="DozentEntity")
@PersistenceContext (unitName="DozentEntity")
private EntityManager em;
private EntityManager em;
Home
Interface
@Stateless
@Stateless
public class DozentService {
public class DozentService {
Home
Stub, Imp
}
Remote
Stub, Imp
}
Deployment
Descriptor
© K. Rege, ZHAW
Manifest
37 von 60
Interaktion zur Laufzeit
■ Zusammenwirken der verschiedenen Teile am Beispiel Session Bean
Client
Client
Remot
Remot
e
e
Stub
Stub
Impl.
Impl.
Remote
Remote
Interface
Interface
School of Engineering
Remote Interface
Remote Interface
Implementation
Implementation
Bean
Bean Bean
Bean
Instanz
Instanz
Instanz
Bean
Instanz
Bean
Instanz
Instanz
© K. Rege, ZHAW
38 von 60
Zusammenfassung
■ Java EE 5 eine Architektur zur Entwicklung von serverseitigen Komponenten
■ Architektur basiert auf Aufteilung in die 3 Schichten: Präsentation, Logik,
Persistenz
■ Ermöglicht verteilte Anwendung mit standardisierten Kommunikationsprotokollen
■ Komponenten werden als Enterprise JavaBeans (EJB) bezeichnet
■ Es gibt 3 Ausprägungen
■
■
■
Session
Entity
Message Driven Bean
■ Der EJB Container
■
■
ist die Laufzeitumgebung für diese Komponenten.
Verwaltet Enterprise Beans und bietet eine Reihe von Services für die Komponenten an
School of Engineering
© K. Rege, ZHAW
39 von 60
Monitoring und Management Dienst
Monitoring
Management
Monitoring&
& Management
Monitoring
Management
Monitoring&
& Management
Lebenszyklusverwaltung
Lebenszyklusverwaltung
Verbindungsdienst
Verbindungsdienst
Zustandsverwaltung
Zustandsverwaltung
Sicherheitsdienst
Sicherheitsdienst
Transaktionssteuerung
Transaktionssteuerung
Persistenzdienst
Persistenzdienst
School of Engineering
© K. Rege, ZHAW
40 von 60
Monitoring & Management Dienst
■ In einem betrieblichen Umfeld müssen verschiedenartige
Infrastrukturkomponenten überwacht und konfiguriert werden
■ Der Betreiber einer Infrastruktur möchte gerne alle wesentlichen Einstellung
einheitlich auf einem Schirm betrachten und einstellen können
■ Punkt-zu-Punkt Lösungen werden mit der Zeit unübersichtlich
by Max Goff
■ Herstellerlösungen: IBM Tivoli, HP OpenView,Oracle Solstice EM sind "optimiert"
auf eigene Produkte
■ -> Es braucht Standards für die Verwaltung der Ressourcen
■
Bsp: SNMP basierend auf UDP
für Netzwerk-Ressourcen
School of Engineering
© K. Rege, ZHAW
by Max Goff
41 von 60
Monitoring & Management
■ Überwachen eines Systems bzw. einzelner Ressourcen im laufenden Betrieb
für
■
■
■
■
Status Monitoring
Fehlersuche, Diagnose, Debugging
Alarmierung bei Fehlern
Performance Analyse -> Ausgangspunkt für Performance Tuning
■ Konfiguration des Systems bzw.von Ressourcen zur Laufzeit
■
z.B.Logging/Tracing Level Optionen etc.
■ Probleme
■
■
■
Vielzahl von Einzelkomponenten zu überwachen
Unterschiedliche Standards (Hersteller/Produktekategorien)
Werden nicht vom Entwickler vorgenommen
School of Engineering
© K. Rege, ZHAW
42 von 60
Monitoring auf verschiedenen Ebenen
■ vom Betriebssystem bis zur Anwendung
■ Anforderung
■
Plattform Unabhängigkeit
■
Protokoll Unabhängigkeit
■
Information Model Unabhängigkeit
■
Management Anwendung Unabhängigkeit
School of Engineering
© K. Rege, ZHAW
43 von 60
Monitoring von JEE Systemkomponenten
■ Performance Daten/Statistiken
■
■
■
Ermitteln der Aufrufzahlen für Servlets/JSP
Performance/Ressourcenbenutzung, Antwortzeiten (min,max,avg)
Logs/Probleme
■ Transaktionen
■
■
Anzahl von Commits/Rollbacks pro EJB
Durchschnittliche Anzahl von Beans die gelockt sind
■ Connection Pools
■
■
Anzahl von Connections im Pool
Avg.Wartezeit auf Pool-Connections
■ Überwachung der eigenen Applikation
■
■
■
Auslesen/Ändern von Applikationsparametern zur Laufzeit
Backend Ressourcen
Fachliche Properties
■ Zustellung von Nachrichten bei
■
■
Fehler
Zustandsänderungen
School of Engineering
© K. Rege, ZHAW
44 von 60
Java Management Extensions (JMX)
■ JMX besteht aus einer Architektur, einer API und Services für das Management
von
■
■
■
Java Applikationen
Infrastruktur Komponenten
...
■ Ermöglicht das Überwachen von Java Applikationen mit Standard Management
Konsolen
■ unabhängig von Java EE entstanden
School of Engineering
© K. Rege, ZHAW
45 von 60
JMX Architektur
■ <RessourceName>MBean Interface
■
legt die Schnittstelle des MBeans fest
■ <RessourceName> Klasse = "Sonde"
■
Implementiert das Interface, greift auf die Ressource zu (instrumentalisiert) die Ressource
■ <RessourceName> Agent
■
■
Registriert das MBean, inklusive Bekanntmachung der Funktionalität
"Sonde" registriert sich oft auch selber
Ressource
<<interface>>
CoffeeMBean
Management
Console
e.g. JConsole
Coffee
CoffeeAgent
MBeanServer
Connector Services
School of Engineering
© K. Rege, ZHAW
46 von 60
Verschiedene MBean Typen
■ Alles was als Java Objekt darstellbar ist kann mit JMX überwacht (=
instrumentiert) werden (HW,SW,Services,...)
■ Die Instrumentierung erfolgt über MBeans,von denen JMX verschiedene
Varianten vorsieht
■ Die wichtigsten zwei sind:
■ Standard MBeans: Schnittstelle statisch
■
■
■
Schnittstelle durch Java Interface definiert
einfachster Weg für JMX Instrumentierung
aber statisches Interface
■ Dynamic MBeans: Schnittstelle dynamisch
■
■
■
Schnittstellen durch MBeanInfo Klasse definiert
Schnittstelle kann zur Laufzeit verändert werden
aber komplexer in der Implementierung
School of Engineering
© K. Rege, ZHAW
47 von 60
Standard MBean
■ Interface wird vom <Ressource>MBeand spezifiziert
■ Exponiert werden public Attribute, Methoden, Konstruktoren und Notifikationen
(Events)
■ JMX spezifizierte Namenskonventionen für Standard MBeans
■
■
■
Die Ressource muss ein Interface mit Getter/Setter für R/W Attribute bzw. Getter für ReadOnly
Attribute spezifizieren
Das Interface träg den Namen <Ressource>MBean
Eine Klasse <Ressource> muss dieses Interface implementieren
■ MBeans werden meist als Singletons implementiert
School of Engineering
© K. Rege, ZHAW
48 von 60
Hello MBean
■ für ein einfaches MBean müssen 2 Dateien erstellt werden
package
package com.example.jmx;
com.example.jmx;
package
package com.example.jmx;
com.example.jmx;
public
public interface
interface HelloMBean
HelloMBean {{
public
public String
String getGreeting();
getGreeting();
public
void
setGreeting(String
public void setGreeting(String str1);
str1);
public
public int
int getChangeCount();
getChangeCount();
}}
public class Hello implements HelloMBean
public class Hello implements HelloMBean
{{
int
int ctr;
ctr;
String
String greeting;
greeting;
}}
School of Engineering
public
public int
int getChangeCount()
getChangeCount() {{
return
return ctr;
ctr;
}}
public
public String
String getGreeting()
getGreeting() {{
return
return greeting;
greeting;
}}
public
public void
void setGreeting(String
setGreeting(String str1)
str1) {{
greeting=
str1;
greeting= str1;
ctr++;
ctr++;
}}
© K. Rege, ZHAW
49 von 60
Erzeugung der MBean Instanz
Erstellung des Singletons und Registrieren des MBeans in MBeanServer
package com.example.jmx;
package com.example.jmx;
public class Hello implements HelloMBean {
public class Hello implements HelloMBean {
……………
……………
public static void initManagment() {
public static void initManagment() {
try { // Register MBean in Platform MBeanServer
try { // Register MBean in Platform MBeanServer
ManagementFactory.getPlatformMBeanServer().
ManagementFactory.getPlatformMBeanServer().
registerMBean(new Hello (), new ObjectName("hello:type=Hello"));
registerMBean(new Hello (), new ObjectName("hello:type=Hello"));
}catch(JMException ex) {
}catch(JMException ex) {
// TODO handle exception
// TODO handle exception
}
}
}
}
static {
static {
initManagment();
initManagment();
}
}
public void main(String[] artg) throws Exception {
public void main(String[] artg) throws Exception {
log.info("Hello started. Waiting...");
log.info("Hello started. Waiting...");
Thread.sleep(Long.MAX_VALUE);
Thread.sleep(Long.MAX_VALUE);
}
}
School of Engineering
© K. Rege, ZHAW
50 von 60
Dynamic MBean
■ Entwickler hat mehr Kontrolle über Schnittstelle
■ Management Interfaces werden dynamisch zur Laufzeit erzeugt
■
■
Interface kann modifiziert werden ohne den Code zu ändern
Interface kann zur Laufzeit sich dem Zustand der Ressource anpassen
■ MBeans implementieren das Interface DynamicMBean
■
Methoden get/setAttribute(s), getMBeanInfo und invoke
School of Engineering
© K. Rege, ZHAW
51 von 60
Hello DynamicMBean
■package
package com.example.jmx;
package package com.example.jmx;
Beschreibung
Beschreibung
der
derSchnittstelle
Schnittstelle
import java.lang.reflect.*;
import java.lang.reflect.*;
import javax.management.*;
import javax.management.*;
public class HelloDynamic implements DynamicMBean{
public class HelloDynamic implements DynamicMBean{
private String greeting;
private String greeting;
public MBeanInfo getMBeanInfo() {
public MBeanInfo getMBeanInfo() {
MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[1];
MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[1];
attributes[0] = new MBeanAttributeInfo("Greeting", // name
attributes[0] = new MBeanAttributeInfo("Greeting", // name
"java.lang.String", // type
String
"java.lang.String", // type
StringAttribut
Attribut"Greeting"
"Greeting"
"Hello World Text", // description
"Hello World Text", // description
true, // isReadable?
true, // isReadable?
true, // isWritable?
true, // isWritable?
false); // isIs?
false); // isIs?
Constructor[] constructors = this.getClass().getConstructors();
Constructor[] constructors = this.getClass().getConstructors();
MBeanConstructorInfo[] dConstructors = new MBeanConstructorInfo[1];
MBeanConstructorInfo[] dConstructors = new MBeanConstructorInfo[1];
dConstructors[0] = new MBeanConstructorInfo("DynamicMBean", constructors[0]);
dConstructors[0] = new MBeanConstructorInfo("DynamicMBean", constructors[0]);
return new MBeanInfo(this.getClass().getName(),"Test einer Dynamic MBean",
return new MBeanInfo(this.getClass().getName(),"Test einer Dynamic MBean",
attributes,
attributes,
dConstructors,
dConstructors,
new MBeanOperationInfo[0] ,new MBeanNotificationInfo[0]);
new MBeanOperationInfo[0] ,new MBeanNotificationInfo[0]);
}
}
School of Engineering
© K. Rege, ZHAW
52 von 60
… Hello DynamicMBean
public void setAttribute (Attribute attribute) throws AttributeNotFoundException,
public void setAttribute (Attribute attribute) throws AttributeNotFoundException,
InvalidAttributeValueException, MBeanException, ReflectionException {
InvalidAttributeValueException, MBeanException, ReflectionException {
if (attribute.getName().equals("Greeting")) {
if (attribute.getName().equals("Greeting")) {
universelle
greeting = (String)attribute.getValue();
universelleset
setMethode
Methode
greeting = (String)attribute.getValue();
}
}
}
}
public Object getAttribute (String attributeName) throws AttributeNotFoundException,
public Object getAttribute (String attributeName) throws AttributeNotFoundException,
MBeanException, ReflectionException { Object ret = null;
MBeanException, ReflectionException { Object ret = null;
if (attributeName.equals("Greeting")) ret = greeting;
if (attributeName.equals("Greeting")) ret = greeting;
universelle
return ret;
universelleget
getMethode
Methode
return ret;
}
}
public AttributeList setAttributes (AttributeList attributes) {
public AttributeList setAttributes (AttributeList attributes) {
setAttribute(attributes.get(0))}
setAttribute(attributes.get(0))}
public AttributeList getAttributes (String[] attributeNames) {
public AttributeList getAttributes (String[] attributeNames) {
String v = getAttribute (attributeNames[0]);
String v = getAttribute (attributeNames[0]);
Attribute a = new Attribute(attributeNames[0],v);
Attribute a = new Attribute(attributeNames[0],v);
AttributeList al = new AttributeList();
AttributeList al = new AttributeList();
al.add(new Attribute(attributeNames[0],v));
al.add(new Attribute(attributeNames[0],v));
return al;
return al;
}
}
}
universelle set multiple Methode
universelle set multiple Methode
universelle
universelleget
getmultiple
multipleMethode
Methode
public Object invoke (String operationName, Object params[], String signature[]) throws
public Object invoke (String operationName, Object params[], String signature[]) throws
MBeanException, ReflectionException {
MBeanException, ReflectionException {
Object ret = Void.TYPE;
Object ret = Void.TYPE;
return ret;
return ret;
}
}
}
School of Engineering
© K. Rege, ZHAW
53 von 60
Zugriff auf MBean
andere
andereManagement
Management
Anwendung
Anwendung
Zugriff
Zugriffinnerhalb
innerhalbJVM
JVM
entfernter Zugriff
entfernter Zugriff
School of Engineering
© K. Rege, ZHAW
54 von 60
Programmatischer lokaler Zugriff auf MBeans
■ Mittels Standard Adaptern/Connektoren werden die Informationen abgerufen
■ Zugriff auf lokales MBean (in derselben VM)
import
import javax.management.*;
javax.management.*;
import
javax.naming.InitialContext;
import javax.naming.InitialContext;
……
//
// simpliefied
simpliefied version
version if
if there
there is
is only
only one
one MBean
MBean Server
Server in
in the
the Virtual
Virtual Machine
Machine
MBeanServer
mbs=
ManagementFactory.getPlatformMBeanServer();
MBeanServer mbs= ManagementFactory.getPlatformMBeanServer();
■ Direkt über Proxy Instanz
String
String name=""hello:type=Hello";
name=""hello:type=Hello";
HelloMBean
HelloMBean hello
hello == (HelloMBean)MBeanServerInvocationHandler.newProxyInstance(mbs,
(HelloMBean)MBeanServerInvocationHandler.newProxyInstance(mbs,
new
new ObjectName(name),HelloMBean.class,
ObjectName(name),HelloMBean.class, false);
false);
hello.setGreeting("Hallo
Welt");
hello.setGreeting("Hallo Welt");
■ oder über MBeanServer Methoden
String
String name=""hello:type=Hello";
name=""hello:type=Hello";
mbs.setAttribute(new
mbs.setAttribute(new ObjectName(name),
ObjectName(name), new
new Attribute("Name",
Attribute("Name", "Andy
"Andy Schaefer"));
Schaefer"));
http://java.sun.com/j2se/1.5.0/docs/api/javax/management/package-summary.html
School of Engineering
© K. Rege, ZHAW
55 von 60
Entfernter Zugriff - Management Seite
■ JSR-160 Remote Access Specification: definiert und vereinheitlicht verschiedene
JMX Zugriffsarten
■ Lokaler Zugriff (innerhalb VM)
MBeanServer
MBeanServer server
server == ManagementFactory.getPlatformMBeanServer();
ManagementFactory.getPlatformMBeanServer();
ObjectName
ObjectName objName
objName == new
new ObjectName("jmx.example.com:service=HelloMBean");
ObjectName("jmx.example.com:service=HelloMBean");
String
a
=
(String)server.getAttribute(obName,
String a = (String)server.getAttribute(obName, “Greeting”);
“Greeting”);
■ Entfernter Zugriff
JMXConnector c = JMXConnectorFactory.connect(url);
JMXConnector c = JMXConnectorFactory.connect(url);
MBeanServerConnection server = c.getMBeanServerConnection();
MBeanServerConnection server = c.getMBeanServerConnection();
ObjectName objName = new ObjectName("jmx.example.com:service=HelloMBean");
ObjectName objName = new ObjectName("jmx.example.com:service=HelloMBean");
String a = (String)server.getAttribute(obName, “Greeting”);
String a = (String)server.getAttribute(obName, “Greeting”);
c.close();
c.close();
immer
immerschliessen
schliessen
School of Engineering
© K. Rege, ZHAW
56 von 60
Zugriff über die JConsole
School of Engineering
© K. Rege, ZHAW
57 von 60
Zusammenfassung
■ Mit JMX steht eine flexible und mittlerweile bewährte Technologie zur Verfügung
um Monitoring und Management von Applikationen und Servern vorzunehmen
■ JMX erlaubt Monitoring in allen Schichten
■
Selbst tiefere Schichten wie OS und Hardware sind per JMX Wrapper integrierbar
■ Nahezu alle gängigen Application Server arbeiten bereits heute mit JMX
■
Infrastruktur kann auch für eigene Monitoring Aufgaben eingesetzt werden
■ Java Releases ab J2SE 1.5 /JEE 5 bieten eine Standardisierung für das
Applikationsmonitoring basierend auf JMX
School of Engineering
© K. Rege, ZHAW
58 von 60
Anhang A JMX Namenskonvention
■ Objekt Namen
■
[Domain]:property=value[,otherproperty=othervalue]
■ Anmelden
■
z.B. "com.example.jmx:type=CashRegister, com.example.jmx:vendor=Nestle"
■ Abfragen:
■
■
■
■
voll Qualifiziert
" com.example.jmx:type=CashRegister"
oder mit Wildcards
*:type=CashRegister,*
■ *vendor=Nestle
School of Engineering
© K. Rege, ZHAW
59 von 60
Anhang B Einstellungen für Remote Zugriff
■ starten der VM so dass die MBeans auch remote zugegriffen werden können
java
java -Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote \\
-Dcom.sun.management.jmxremote.port=8004
-Dcom.sun.management.jmxremote.port=8004 \\
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.authenticate=false \\
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.ssl=false \\
hello.HelloAgent
hello.HelloAgent
http://www.onjava.com/pub/a/onjava/2004/09/29/tigerjmx.html
School of Engineering
© K. Rege, ZHAW
60 von 60