Informatik II Grundlagen der Softwaretechnik - ias.uni

Werbung
Grundlagen der Softwaretechnik
Info 2 - GdS
§ 8 Komponentenbasierte Softwareentwicklung
Lernziele
– Den Hintergrund komponentenbasierter Softwareentwicklung kennen
– Verstehen, was eine Komponente ist
– Den Unterschied zwischen Klassen und Komponenten erklären können
– Einen Überblick über die Java Komponententechnologie JavaBeans
bekommen
– Das Ereignismodell bei JavaBeans verstehen
© 2015 IAS, Universität Stuttgart
449
8.1 Komponentenbasierte Software
Info 2 - GdS
§8
Komponentenbasierte Softwareentwicklung
8.1
Komponentenbasierte Software
8.2
Einführung in JavaBeans
8.3
Zusammenfassung
© 2015 IAS, Universität Stuttgart
450
8.1 Komponentenbasierte Software
Info 2 - GdS
Warum Komponenten?
– Probleme bei der Entwicklung komplexer Systeme
Kosten
 Termintreue
Qualität
 Wartbarkeit
 Idee: Einsatz von vorgefertigten Softwarekomponenten
Neues Programmierparadigma auf Basis objektorientierter Konzepte
– Prinzip der Komponententechnologie
1. Komponentensammlung
Kaufen („Off the shelf“)
© 2015 IAS, Universität Stuttgart
2. Komposition zu einer Anwendung
Auswählen
Konfigurieren
Verknüpfen
451
8.1 Komponentenbasierte Software
Info 2 - GdS
Aufgaben beim Einsatz von Komponenten
– Entwicklung mehrfach verwendbarer Komponenten
Bereitstellung von mehrfach verwendbaren Software-Bausteinen
Kein Abfall-Produkt eines Entwicklungsprojekts
 Erstellung muss technisch und finanziell geplant werden,
basierend auf wohlfundierter Softwaretechnologie
– Anwendung der Komponenten zur Realisierung neuer Systeme
Auswahl von Komponenten aus Komponentenkatalogen
Anpassung der Komponenten an die Aufgabenstellung
Integration der Komponenten
– Aufwand im Vergleich zur Individualprogrammierung um die
Größenordnung einer Zehnerpotenz reduziert
Parametrierung und
Beschleunigung des Entwicklungsprozesses
Konfiguration statt
Erhöhung der Flexibilität
Programmierung
Nutzung der Wiederverwendung
© 2015 IAS, Universität Stuttgart
452
8.1 Komponentenbasierte Software
Info 2 - GdS
Nutzen des Einsatzes von Komponenten
– Kostenverlauf bei der Verwendung von Komponenten
Kosten
Kostenfaktoren
Gesamtkosten
• Entwickeln
• Testen
Transaktionskosten
• Suchen
• Beschaffen
Herstellkosten
Anteil
Komponenten
© 2015 IAS, Universität Stuttgart
Min (
Kosten) ?
453
8.1 Komponentenbasierte Software
Info 2 - GdS
Einordnung der Komponententechnologie
+ Paketierung
+ Kombinierbarkeit
+ Interoperabilität
Abstraktion
Kapselung
Komponententechnologie
OO Technologie
Klassische Softwareentwicklung
(3GL Technologie)
– Komponententechnologien
Microsoft - Component Object Model (COM, ActiveX)
Sun - JavaBeans
CORBA Component Model (CCM)
Web Services
© 2015 IAS, Universität Stuttgart
454
8.1 Komponentenbasierte Software
Info 2 - GdS
Was ist eine Komponente? (1)
Definition 1:
A reusable software component is a logical cohesive, loosely coupled module
that denotes a single abstraction.
[Booch 1987]
Definition 2:
Kleine überschaubare Softwareeinheiten werden schnell und unabhängig voneinander entwickelt und dann zu größeren Anwendungen zusammengesetzt.
Dadurch erreicht man Reduktion der Komplexität und bessere Qualität durch
getestete Komponenten.
[Piemont 1999]
1
2
3
4
© 2015 IAS, Universität Stuttgart
0
Vcc1
Software CHIP
GND
0
5
6
7
8
455
8.1 Komponentenbasierte Software
Info 2 - GdS
Was ist eine Komponente? (2)
– Eigenschaften
Abgeschlossene funktionale Softwareeinheit (black-box) in einem
Anwendungskontext
Qualitativ hochwertig und gut dokumentiert
Eigenständig ablauffähig
Kapselung von Funktionalität und Verhalten
Mehrfach verwendbar
Skalierbar und parametrisierbar
Einsatzbereit für eine bestimmte Komponenteninfrastruktur
Vollständig spezifizierte und standardisierte Schnittstelle
(Eigenschaften, Methoden, Ereignisse)
Hierarchiefähigkeit, ermöglicht die Konstruktion von neuen
Komponenten aus existierenden Komponenten
© 2015 IAS, Universität Stuttgart
456
8.1 Komponentenbasierte Software
Info 2 - GdS
Vergleich Komponenten und Klassen (1)
– Gemeinsamkeiten
Unterstützung objektorientierter Konzepte und Methoden
 Kapselung von Verhalten und Zustand
 Polymorphismus
 Verwendung von Schnittstellen
Komponenten können als Klassen realisiert werden
– Unterschiede
Klassen
– Klassen sind Abstraktionen
Jede Klasse hat bestimmte
Verantwortlichkeiten
Engere Beziehungen
untereinander
© 2015 IAS, Universität Stuttgart
Komponenten
– Komponenten sind höherwertige
Abstraktionen
Stellen Dienste über definierte
Schnittstellen zur Verfügung
Größere Eigenständigkeit
457
8.1 Komponentenbasierte Software
Info 2 - GdS
Vergleich Komponenten und Klassen (2)
Klassen
– Klassen stellen Standardfunktionalität zur Verfügung
Komponenten
– Komponenten werden als Bausteine
verwendet
Funktionsumfang auf konkrete
Problemlösung ausgerichtet
Größerer Funktionsumfang als
Klassen
Minimalistische
Vorgehensweise beim Entwurf
Eigenschaften werden konfiguriert
Erweiterungen durch
Vererbung möglich
– Komponenten werden nicht geändert
Hohe Produktivität, da keine
Programmierung erforderlich
– Unterschiedliche Anwendung von Komponenten und Klassen muss beim
Entwurf berücksichtigt werden
Komponente muss flexibler gestaltet sein für Konfiguration
Bei Komponenten müssen möglichst viele Eigenschaften einstellbar sein
Bei Komponenten findet Kommunikation über „Ereignisse“ statt
© 2015 IAS, Universität Stuttgart
458
§ 8 Komponentenbasierte Softwareentwicklung
Info 2 - GdS
Frage zur Kapitel 8.1
– Welche Vorteile bietet der Einsatz von Softwarekomponenten?
Antwort
Vorteile:
– höhere Produktivität
_____________, da keine Eigenentwicklung erforderlich
– höhere Qualität
_____________, da bereits getestet
– höhere _____________,
Verständlichkeit da einheitliche Schnittstellen
– bessere Einsetzbarkeit
_____________, da plattformunabhängig
© 2015 IAS, Universität Stuttgart
459
8.2 JavaBeans
Info 2 - GdS
§ 8 Komponentenbasierte Softwareentwicklung
8.1
Komponentenbasierte Software
8.2
Einführung in JavaBeans
8.3
Zusammenfassung
© 2015 IAS, Universität Stuttgart
460
8.2 JavaBeans
Info 2 - GdS
Überblick (1)
– Das JavaBeans-Modell ist eine Komponententechnik für die
Programmiersprache Java
– Ein JavaBean ist eine wiederverwendbare und plattformunabhängige
Softwarekomponente, die eine normierte Schnittstelle nach Außen besitzt
– Bean-Spezifikation festgelegt durch Sun
– JavaBean-Konzept ermöglicht dem Anwendungsentwickler das
Zusammensetzen von Bean-Komponenten:
entweder manuell mit Hilfe von Programmcode
oder visuell über einen sogenannten BeanBuilder
© 2015 IAS, Universität Stuttgart
461
8.2 JavaBeans
Info 2 - GdS
Überblick (2)
– Ein JavaBean besitzt drei Strukturelemente:
Eigenschaften (Properties)
 Zustände und Datenwerte
Methoden (Methods)
 sichtbare Verhaltensmerkmale
Ereignisse (Events)
 Nachrichtentransfer
Methoden
(Methods)
Ereignisse
(Events)
Eigenschaften
(Properties)
JavaBean
© 2015 IAS, Universität Stuttgart
462
8.2 JavaBeans
Info 2 - GdS
Beispiel
Die JavaBean SimpleBean realisiert ein Textfeld, das eine Integerzahl darstellt
public class SimpleBean extends java.awt.TextField {
// Konstruktoren
public SimpleBean() { super(); }
public SimpleBean (int pColumns){ super(pColumns); }
// Bean-Eigenschaft value
public int getValue() {
return Integer.parseInt(super. getText());
}
public void setValue(int pValue) {
super. setText ( " " +pValue ) ;
}
}
// Bean-Methode checkValue
public boolean checkValue () {
String s = super.getText().trim();
if (s.length() == 0) return false;
for(int i=0; i < s.length(); i++) {
if ( !Character.isDigit (s.charAt(i))) return false;
}
return true;
}
© 2015 IAS, Universität Stuttgart
463
8.2 JavaBeans
Info 2 - GdS
Eigenschaften
– Beschreibung der Beans
– Darstellung der nach außen sichtbaren Datenwerte und Zustände
– Lese- (GETeigenschaft) und eine Schreibmethode
(SETeigenschaft), zur Veränderung der Eigenschaften
– Geheimnisprinzip („Information Hiding”)
– Implementierungsänderung leicht möglich
Methoden
– Bean-Methoden sind gewöhnliche öffentliche Methoden einer Java-Klasse
– Mit Hilfe dieser Methoden können die verschiedenen Aktionen einer BeanKomponente aufgerufen werden
© 2015 IAS, Universität Stuttgart
464
8.2 JavaBeans
Info 2 - GdS
Ereignisse
– Publisher-Subscriber-Ansatz
– Ereignisse (Events) dienen zur Realisierung eines quasi-asynchronen
Nachrichtentransfers
– Ermöglichen eine Kommunikation verschiedener Bean-Komponenten
– Durch das Versenden von Ereignissen können Bean-Komponenten
bestimmte Programmsituationen anderen Bean-Komponenten mitteilen
– Ereignisse werden in Java mit der Basisklasse EventObject realisiert
– Damit eine Bean-Komponente ein Ereignis empfangen kann, muss sie
sich als sogenannter Listener bei der Quellkomponente registrieren
– 2 Konzepte zum Nachrichtentransfer zwischen Beans
Direkte Kommunikation
Kommunikation über Event Adapter
© 2015 IAS, Universität Stuttgart
465
8.2 JavaBeans
Info 2 - GdS
Prinzip des Nachrichtentransfers (1)
Variante 1: Direkte Kommunikation
AddEvent
Listener
1. Registrierung als EventListener
Bean B
(Ziel)
– Registrieren bei Quellkomponente (Bean A)
– Eintrag in Eventliste
Bean A
(Event Source)
OnEvent
2. Event auslösen
EventObject
Event
Interface
– Beim Eintreten des
Ereignisses:
 Instanzierung des
EventObjects
 Aufruf der onEventMethode mit Übergabe
des EventObjects
– Vorteil:
Quell- und Ziel-Komponenten sind direkt miteinander verbunden
– Nachteil:
Blockierung der Quellkomponente (durch direkten Methodenaufruf)
© 2015 IAS, Universität Stuttgart
466
8.2 JavaBeans
Info 2 - GdS
Prinzip des Nachrichtentransfers (2)
Variante 1: Direkte Kommunikation
/* --- Bean-Component A (Source) --- */
public class BeanA
{
// EventListener Liste
protected SendListener listener = null;
/* --- Bean-Component B (Target) --- */
class BeanB implements SendListener {
// Component A (Source)
protected BeanA komponenteA;
// Constructor
public BeanB(BeanA komponente) {
komponenteA = komponente;
// Add Listener
komponenteA.addSendListener(this);
}
// Constructor
public BeanA() {}
// Add Listenermethod
public void addSendListener(SendListener l){
listener = l;
}
public void continiousSend() {
for(;;) {
// Loop Forever
wait(500);
// Wait For 500 Millisec.
// Fire Event
if (listener != null) {
System.out.println("SendEvent fired");
listener.onSend(new SendEvent(this));
}
}
}
}
© 2015 IAS, Universität Stuttgart
}
// Event method
public void onSend(SendEvent evt) {
System.out.println
("SendEvent received");
}
/* --- SendEventObject --- */
class SendEvent extends EventObject {
// Constructor
public SendEvent(Object source)
{ /*...*/ }
}
/* --- Interface SendListener --- */
interface SendListener {
public abstract void onSend(SendEvent e);
}
467
8.2 JavaBeans
Info 2 - GdS
Prinzip des Nachrichtentransfers (3)
Variante 2: Kommunikation über Event Adapter
addEvent
Listener
Bean A
(Event Source)
Erweiterung von Variante 1
1. Registrierung
als EventListener Event Adapter
onEvent
2. Event auslösen
Bean B
(Ziel)
Methode
EventObject
Interface
Event
– Event Adapter als eine Zwischenklasse
– Event Adapter registriert sich bei der Quellkomponente (A)
– Event Adapter leitet ausgelösten Event an die Methode der
Zielkomponente (B)
– Komponenten bleiben unverändert
Keine Blockierung der Quellkomponente
© 2015 IAS, Universität Stuttgart
468
8.2 JavaBeans
Info 2 - GdS
Vorgehen zur Realisierung einer Ereigniskommunikation
1. Definieren einer Beobachter-Schnittstelle mit dem Namen
<Ereignisname>Listener
– Schnittstelle deklariert Operation, die bei Eintreffen des Ereignisses zur Benachrichtigung aufgerufen wird:
void <ereignisname> (<Ereignisname>Event e);
(Operationsname gleich Ereignisname, nur klein geschrieben)
2. Implementieren einer Ereignisklasse mit dem Namen
<Ereignisname>Event
3. Hinzufügen der Funktionalität zum An- und Abmelden von
Ereignisabhörern
Liste für die Verwaltung der Ereignisabhörer, z.B. mit java.util.vector
Implementieren der Operationen zum An- und Abmelden von Ereignisabhörern:
 add<Ereignisname>Listener
 remove<Ereignisname>Listener
Implementieren einer Operation zum Benachrichtigen registrierter
Ereignisabhörer
© 2015 IAS, Universität Stuttgart
469
8.2 JavaBeans
Info 2 - GdS
Weitere Merkmale von Beans (1)
– Eigenschafteneditoren (property editors)
Dienen zur Änderung der Beans-Eigenschaften
Diese Editoren können speziell für jede Bean-Komponente
programmiert werden
Sie ermöglichen eine einfache Konfiguration der Bean-Komponenten
während des Entwurfes
– Serialisierung (persistence)
Zur Abspeicherung des momentanen Zustands einer BeanKomponente
Dieser Zustand kann später wieder hergestellt werden
Diese Eigenschaft ist besonders wichtig bei der Konfiguration bzw.
Parametrisierung der Bean-Komponente
© 2015 IAS, Universität Stuttgart
470
8.2 JavaBeans
Info 2 - GdS
Weitere Merkmale von Beans (2)
– Introspektion
Die Introspektions-APIs definieren Techniken, die Komponenten dazu
veranlassen, ihre interne Struktur zur Entwurfszeit direkt zur
Verfügung zu stellen
Zur Realisierung wird eine eigene Klasse erzeugt, die das Interface
java.beans.BeanInfo implementiert
Standardklasse java.beans.SimpleBeanInfo implementiert alle
Methoden prototypisch
Sie dient zur Vereinfachung der Introspektion
Hinweis: JavaBeans-Spezifikationen
http://www.oracle.com/technetwork/java/javase/documentation/spec-136004.html
JavaBeans-Tutorial
https://docs.oracle.com/javase/tutorial/javabeans/index.html
© 2015 IAS, Universität Stuttgart
471
8.2 JavaBeans
Info 2 - GdS
Weitere Merkmale von Beans (3)
Beispiel
Introspektion
package MyPackage;
import java.beans.*;
public class MyClassBeanInfo extends SimpleBeanInfo {
private final static Class beanClass = MyClass.class;
// Allgemeine Informationen ueber die Komponente
public BeanDescriptor getBeanDescriptor() {
BeanDescriptor bd = new BeanDescriptor (beanClass);
bd.setDisplayName("MyBean");
return bd;
}
// Informationen ueber Eigenschaften der Komponente
public PropertyDescriptor[] getPropertyDescriptors() {}
// Information ueber Methoden der Komponente
public MethodDescriptor[] getMethodDescriptors() {}
}
© 2015 IAS, Universität Stuttgart
472
§ 8 Komponentenbasierte Softwareentwicklung
Info 2 - GdS
Frage zur Kapitel 8.2 (1)
Die Bean Temperatursensor soll das Ereignis BereichsFehler verschicken,
falls das Messergebnis außerhalb des vorgegebenen Messbereichs liegt.
Implementieren Sie alle notwendigen Schritte zur Weiterleitung des Ereignisses.
Antwort
– 1. Schritt: Schnittstelle für Abhörer definieren
public interface BereichsFehlerListener extends java.util.EventListener{
// Alle Ereignis-Abhörer müssen diese Schnittstelle implementieren
void bereichsFehler(BereichsFehlerEvent e);
}
– 2. Schritt: Klasse für Ereignis implementieren
public class BereichsFehlerEvent extends java.util.EventObject {
public float minNeu, maxNeu;
BereichsFehlerEvent(Object Ereignisquelle, float minNeu, float maxNeu){
// Konstruktor zum Anlegen eines neuen Event-Objekts
super(Ereignisquelle);
this.minNeu = minNeu; this.maxNeu = maxNeu;
}
}
© 2015 IAS, Universität Stuttgart
473
§ 8 Komponentenbasierte Softwareentwicklung
Info 2 - GdS
Frage zur Kapitel 8.2 (2)
– 3. Schritt: Funktionalität in der Klasse Temperatursensor zum AnBenachrichtigen von Ereignisabhörern
und Abmelden sowie zum ____________________________________
//Vector, der die Abhörer verwaltet
private java.util.Vector Abhoerer = new java.util.Vector(); ...
//An- und Abmelden von BereichsFehlerListener-Objekten
public synchronized void addBereichsFehlerListener(BereichsFehler Listener l){
Abhoerer.addElement(l);
}
public synchronized void removeBereichsFehlerListener(BereichsFehler Listener l){
Abhoerer.removeElement(l);
}
//Alle angemeldeten BereichsFehlerListener benachrichtigen
protected void notifyBereichsFehler() {
java.util.Vector AbhoererKopie;
//Hier wird ein synchronized-Block eingefügt, um zu gewährleisten, dass alle vor
Verschicken des Ereignisses angemeldeten Beobachter benachrichtigt werden
synchronized(this) {
AbhoererKopie = (java.util.Vector)Abhoerer.clone();
}
for (int i=0; i < AbhoererKopie.size(); i++) {
((BereichsFehlerListener)AbhoererKopie.elementAt(i)).bereichsFehler(einEreignis);
}
}
© 2015 IAS, Universität Stuttgart
474
8.3 Zusammenfassung
Info 2 - GdS
§ 8 Komponentenbasierte Softwareentwicklung
8.1
Komponentenbasierte Software
8.2
Einführung in JavaBeans
8.3
Zusammenfassung
© 2015 IAS, Universität Stuttgart
475
§ 8 Komponentenbasierte Softwareentwicklung
Info 2 - GdS
Zusammenfassung § 8
–
Vorteile des JavaBeans Ansatzes
Komponentenmodell für Klienten und Server
Dynamisches Nachladen von Klassen möglich
Introspektion
Umfangreiche Bibliotheken
–
Nachteile des JavaBeans Ansatzes
Zur Zeit nicht echtzeitfähig
Einfache Implementierungsvererbung teils hinderlich, z.B. bei
Entwurfsmustern
Keine hinreichende Unterstützung bei der Erzeugung von
Komponenten
Video: Automatisierter Tischkicker
© 2015 IAS, Universität Stuttgart
476
§ 8 Komponentenbasierte Softwareentwicklung
Info 2 - GdS
Vorbereitungsfragen zu § 8
Frage 1: Welche der folgenden Aussagen zur direkten
Ereigniskommunikation von JavaBeans sind richtig?
(WS 06/07)
Antwort

Damit eine Bean-Komponente ein Ereignis empfangen kann, muss sie
sich als Ereignisabhörer bei der Quellkomponente (Ereignisquelle)
registrieren.

Ein Ereignisabhörer informiert eine Ereignisquelle über das Eintreten eines
Ereignisses.


Jede Ereignisquelle lässt nur einen Ereignisabhörer zu.

Alle Ereignisquellen müssen Operationen zum Anmelden von
Ereignisabhörern enthalten.
Alle Ereignisquellen müssen eine Beobachter-Schnittstelle
implementieren.
© 2015 IAS, Universität Stuttgart
477
§ 8 Komponentenbasierte Softwareentwicklung
Info 2 - GdS
Vorbereitungsfragen zu § 8
Frage 2: Welche der folgenden Aussagen zur komponentenbasierten
Softwareentwicklung sind richtig? (WS 06/07)
Antwort

Durch komponentenbasierte Softwareentwicklung erreicht man eine
Reduktion der Komplexität und bessere Qualität durch getestete
Komponenten.




Komponenten stellen Dienste über definierte Schnittstellen zur Verfügung.
Komponenten besitzen engere Beziehungen untereinander als Klassen.
Komponenten besitzen einen kleineren Funktionsumfang als Klassen.
Der Einsatz von Komponenten ermöglich die Nutzung der
Wiederverwendung, verlangsamt jedoch den Entwicklungsprozess.
© 2015 IAS, Universität Stuttgart
478
Herunterladen
Explore flashcards