Sie sind auf Seite 1von 20

Wissen aus erster Hand.

Leseprobe
In dieser Leseprobe lernen Sie die Grundlagen und Techniken zur
Entwicklung von Entwurfsmustern kennen.

Kapitel 2:
Umgang mit Entwurfsmustern

Inhalt

Index

Die Autoren

Leseprobe weiterempfehlen

Nurgl Atilgan, Markus Straub


Entwurfsmuster in ABAP
357 Seiten, gebunden, Januar 2015
69,90 Euro, ISBN 978-3-8362-2833-6

www.sap-press.de/3579
Um Software wiederverwendbar und einfach zu entwickeln,
ist es sehr wichtig, die abzubildenden Prozesse genau zu
spezifizieren. Dabei helfen Ihnen Kenntnisse in UML und
ABAP Objects.

2 Umgang mit Entwurfsmustern

In diesem Kapitel erlutern wir die Grundlagen und Techniken zur


Entwicklung von Entwurfsmustern. Zu Beginn zeigen wir auf, wie
Sie die Problemstellungen, die ein Entwurfsmuster lsen soll, in
UML abstrakt aufzeichnen und so Lsungswege definieren knnen.
Darber hinaus bringen wir Ihnen in diesem Kapitel die Grundlagen
und wichtigen Elemente der SAP-Entwicklung nher, damit Sie die
Entwurfsmuster in SAP-Entwicklungsprojekten einsetzen knnen.

2.1 UML-Grafiken erstellen


Die Unified Message Language (UML) ist eine Modellierungssprache, UML
mit der Sie Anwendungen und deren Sachverhalte durch standardi-
sierte Notationen abbilden knnen. Durch diese Abbildung werden
die Sachverhalte abstrahiert, und die Geschftsprozesse knnen fr
andere verstndlich und sichtbar dargestellt werden. Dies ist zum
einen wichtig, da die Prozesse so berprft werden knnen, um
frhzeitig eventuell enthaltene Fehler zu entdecken. Zum anderen
kann der Software-Entwickler dieser Modelle heranziehen, um die
Anwendung zu realisieren.

In UML gibt es unterschiedliche Mglichkeiten, Anwendungen und Diagrammtypen


deren Bestandteile bersichtlich und verstndlich zu gestalten. Dafr
stehen verschiedene Diagrammtypen zur Verfgung. Jeder dieser
Typen hat seine Bewandtnis und ist fr die vollstndige Modellie-
rung einer Anwendung erforderlich.

UML entwickelt sich stetig weiter und wird immer wieder durch die UML und BPMN
Object Management Group neu definiert. Dieses Konsortium entwi-

37
2 Umgang mit Entwurfsmustern UML-Grafiken erstellen 2.1

ckelt auch die Modelliersprache Business Process Model and Notation Im Folgenden gehen wir auf die im UML zur Verfgung stehenden
(BPMN) stetig weiter und verffentlicht regelmig neue Versionen. Diagrammtypen nher ein.
Whrend UML sich mit der grafischen Beschreibung von objektori-
entierten Modellen befasst, ermglicht BPMN die Beschreibung von
2.1.1 Klassendiagramm
Geschftsprozessen mithilfe grafischer Elemente. Diese Elemente
haben jeweils ihre spezifische Bedeutung, die von der Objekt Das Klassendiagramm ist eine Variante eines UML-Diagramms, das Beziehungen
Klassen und deren Beziehung zueinander beschreibt. In einem Klas- zwischen Klassen
Management Group in einem Regelwerk festgehalten wird. Abbil-
dung 2.1 stellt die beiden Sprachen in den Versionen BPMN 2.0 und sendiagramm werden die Klassen als Rechtecke dargestellt. In den
UML 2.0 gegenber. Dabei entsprechen die dargestellten Objekte Rechtecken werden die einzelnen Attribute und Methoden der Klas-
der Notationen links (BPMN 2.0) denen der Notationen auf der rech- sen angezeigt. In der Praxis ist diese Darstellung nicht immer voll-
ten Seite (UML 2.0). In der Praxis wird heutzutage meistens UML 2.0 stndig, je nachdem, ob das Diagramm aus Fachbereichs- oder Ent-
angewendet, da UML aus deutlich weniger Elementen besteht und wicklungssicht erstellt wurde. Der Fachbereich beschreibt einen
dadurch viel einfacher einzusetzen ist. Prozess immer aus betriebswirtschaftlicher Sicht; hierbei werden
aber womglich wichtige Informationen vergessen, die der Entwick-
ler zur Modellierung der Anwendung bentigt.
BPMN 2.0 UML 2.0
Um die Klassen miteinander in Beziehung zu setzen, werden Beispiel
wiederholen Pfeile verwendet. Es gibt unterschiedliche Pfeile, die eine Verer-
BPMN Activity bung, Abstraktion oder das Interface einer Klasse kennzeichnen.
Schleife Schleife Abbildung 2.2 zeigt ein Beispiel fr ein UML-Klassendiagramm.
Sie sehen oben die Superklasse formen, die zwei Attribute (ge-
kennzeichnet mit einem Minuszeichen) und drei Funktionen (ge-
kennzeichnet mit einem Pluszeichen) enthlt.

BPMN Activity formen


parallele
Schleife Mittelpunkt :int
Mehrfach-
sichtbar :boolean Methoden werden
ausfhrung
+ anzeigen() :void
vererbt oder
+ entfernen() :void berschrieben
+ verschieben() :void

Abbildung 2.1 Vergleich von BPMN 2.0 und UML 2.0

In BPMN stehen dagegen fr viele Situationen und Aktionen jeweils linie kreis stern
eigene Symbole zur Verfgung. BPMN wurde geschaffen, um einfa- ZahlA :int Radius :int ZahlA :int
che Geschftsprozessmodelle abzubilden. Da jedoch auch komplexe ZahlB :int
+ anzeigen() :void
ZahlB :int
ZahlC :int
Geschftsprozesse darstellbar sein sollten, ist mit der Zeit eine groe + entfernen() :void + anzeigen() :void
+ anzeigen() :void + verschieben() :void + entfernen() :void
Menge von Darstellungselementen entstanden. SAP Business Process + entfernen() :void + verschieben() :void
Management (BPM) wird z.B. von BPMN untersttzt. Mit diesem + verschieben() :void

Werkzeug lassen sich Geschftsprozesse modellieren, ohne die Not-


wendigkeit, Code zu schreiben. Abbildung 2.2 Beispiel fr ein UML-Klassendiagramm

38 39
2 Umgang mit Entwurfsmustern

Die weiteren drei Klassen linie, kreis und stern erben die Funktio-
nen von der Klasse formen, wobei der Programmcode der Super-
klasse ausgefhrt wird. Die Klasse stern kann die Methoden anzei-
gen() oder entfernen() aber auch berschreiben, sodass hier
eigener Programmcode ausgefhrt wird. Dies knnen Sie am Bei-
spiel der Funktion anzeigen() sehen. Die Klasse formen selbst imple-
mentiert die Anzeigefunktion nicht aus, dies erfolgt in den erbenden
Klassen.

Abstrakte Klassen Abstrakte Klassen werden in UML mit dem Prfix {Abstract} gekenn-
zeichnet. Diese Klassen knnen nicht instanziiert werden. Es handelt
sich um beschreibende Klassen, die an eine andere Klasse angedockt
werden, oft durch Vererbung. ber die Vererbung werden das Ver-
halten und die Eigenschaften der abstrakten Klasse formen als Objekt
definiert. Eine abstrakte Klasse wird nie selbst implementiert, son-
dern die Implementierung findet in den erbenden Klassen statt.

Sichtbarkeiten Sichtbarkeiten beschreiben, wie die Methoden und Attribute von


anderen Klassen und Methoden wahrgenommen werden knnen.
Um Sichtbarkeiten der Funktionen, aber auch die Attribute selbst
besser beschreiben zu knnen, knnen Sie in UML ein paar zustzli-
che Operanden verwenden. Die Sichtbarkeiten werden immer vor
das Attribut geschrieben. Hier werden vier Kategorien unterschie-
den, die in Tabelle 2.1 aufgefhrt sind.

Notation Kategorie Beschreibung


+ public fr alle Klassen sichtbar
~ package fr alle im gleichen Paket sichtbar
# protected fr alle befreundeten Klassen und Interfaces
- private nur fr die eigene Klasse sichtbar

Tabelle 2.1 Operanden zur Beschreibung der Sichtbarkeit von Klassen

Datentypen Um den Attributen einen Datentyp zuzuweisen, werden die Attri-


zuweisen bute, die in einer Klasse stehen, hinterlegt. Auf die gleiche Weise
werden auch den Methoden Datentypen zugewiesen. Die Angaben
knnen wie folgt definiert werden:

Attribute:
Sichtbarkeit des Attributsnamens im Datentyp hinterlegen:
+ Auftragsnummer:Y_DE_AUFTRAGSNR (DDIC)

40
Grundlagen der objektorientierten Programmierung mit ABAP 2.2

Sie erkennen den zeitlichen Ablauf der Aktionen, die das Programm
ausfhren soll, um erfolgreich durchgefhrt zu werden. Dabei wird
aufgezeigt, welche weiteren Klassen und Objekte involviert sind. In
diesem Beispiel wird der Ablauf mit einem Kommando in Gang
gesetzt. In Rechtecken knnen Sie die Klassen erkennen, Kreise
kennzeichnen Aktionen, die durch den Anwender ausgelst werden.

2.2 Grundlagen der objektorientierten


Programmierung mit ABAP
In diesem Abschnitt machen wir Sie mit den Grundlagen der objekt-
orientierten Programmierung mit ABAP vertraut. Das Verstndnis
dieser Konzepte ist die Voraussetzung, um Entwurfsmuster in ABAP
umsetzen zu knnen. Dieser Abschnitt richtet sich in erster Linie an
Entwickler, die keine oder noch wenig Erfahrung mit der Sprache
ABAP haben. Wir stellen Ihnen die Besonderheiten und die Umset-
zung des Konzepts der Objektorientierung vor. Wenn Sie bereits
Erfahrung mit ABAP Objects haben, knnen Sie diesen Abschnitt
berspringen.

Die Objektorientierung ist die Grundlage fr die Nutzung von Ent-


wurfsmustern bei der Anwendungsentwicklung. ber 80% der Ent-
wurfsmuster basieren auf der objektorientierten Entwicklung. Die
anderen 10% basieren auf klassenbasierter Entwicklung, die auch
ohne Objektorientierung mglich ist.

2.2.1 ABAP Objects


ABAP Objects ist die Bezeichnung fr die objektorientierte Ausrich- Ganzheitlicher
tung der Sprache ABAP. Die Objektorientierung ist in erster Linie als Ansatz

Programmierkonzept bekannt. Die Objektorientierung sollte immer


das gesamte Entwicklungsprojekt betrachten, sodass die Objektori-
entierung vom Entwurf bis zur Implementierung erfolgt.

Sie kennen den objektorientierten Ansatz vielleicht bereits aus


anderen Programmiersprachen wie Java oder C. Er lst die prozedu-
rale Programmierung ab, die heute noch sehr verbreitet ist, z.B. in
den Sprachen Visual Basics for Applications (VBA) fr Microsoft
Office und ANSI C, einem Ende der 1980er Jahre formulierten Stan-
dard der Programmiersprache C. Objektorientierte Programmier-

43
2 Umgang mit Entwurfsmustern Grundlagen der objektorientierten Programmierung mit ABAP 2.2

sprachen knnen komplexere Entwicklungen viel bersichtlicher der Wiederverwendungsgrad der Softwarekomponenten erheblich
darstellen. Eine weitere groe Strke des objektorientierten Ansat- gesteigert. Die Sichtbarkeit von Methoden, Attributen und Ereignis-
zes ist die Wiederverwendbarkeit von Methoden und Klassen. sen knnen Sie in ABAP Objects deutlicher mit den Kategorien
public, protected und private steuern. Die Erweiterung einer
Historische Nachdem in den 1950er Jahren die ersten Programmiersprachen
Programmier- Anwendung ist durch die transaktionale Objektsteuerung realisier-
aufkamen, gab es in den 1970er Jahren die ersten funktionsgetriebe-
anstze bar, bei der die Reihenfolge der Objektbearbeitung eingehalten
nen Anstze, wie z.B. Hierarchy plus Input Process Output (HIPO). Aus
wird. Auf diese Weise kann eine bessere Kapselung der Software-
diesen Anstzen gingen in den 1980er Jahren datengetriebene
komponenten stattfinden. Die Kommunikation erfolgt nur noch
Anstze hervor. Programmiersprachen, die in diesem Zuge entstan-
ber klar definierte Schnittstellen, wodurch man die Software robus-
den, werden auch als prozedurale Programmiersprachen bezeichnet
ter und weniger angreifbar macht.
und werden noch hufig eingesetzt. Aus diesen Programmierpara-
digmen sind schlielich die objektorientierten Programmieranstze ABAP Objects hat jedoch nicht nur Vorteile, sondern auch noch Nachteile von
hervorgegangen. Wichtige Werkzeuge fr die objektorientierte nicht gelste Eigenschaften. Methoden knnen bei ABAP Objects ABAP Objects

Anwendungsentwicklung sind UML und BPMN. Abbildung 2.5 ver- noch nicht RFC-fhig (Remote Function Call) aufgerufen werden.
anschaulicht diese Entwicklung. Hierzu muss aktuell der Umweg ber einen RFC-fhigen Funktions-
baustein gegangen werden. Dynpros knnen nicht in Klassen er-
stellt werden, sondern werden immer ber einen Funktionsbau-
objektorientierte Anstze stein oder Programme gekapselt. Um ABAP Objects in der tglichen
1990
(z. B. UML) Programmierung zu verwenden, mssen Sie Zeit investieren, um
die objektorientierte Programmierweise zu beherrschen und ent-
sprechend einzusetzen.
datengetriebene Anstze
1980
(z. B. strukturierte Analyse) Remote Function Calls

RFC-Verbindungen werden zur Kommunikation mit anderen Systemen


(SAP oder Nicht-SAP-Systeme) eingesetzt. Mit dem RFC-Verfahren lassen
funktionsgetriebene Anstze sich Funktionsaufrufe zwischen zwei SAP-Systemen umsetzen. Mit der
1970
(z. B. HIPO) Anweisung CALL FUNCTION DESTINATION kann ein entfernter Funk-
tionsbaustein (Remote-Baustein) aufgerufen werden. Dazu muss der RFC-
Funktionsbaustein als remote definiert sein.
Abbildung 2.5 Entwicklung der Programmiersprachen

Vorteile der Objekt- Durch die Weiterentwicklung der Programmiersprachen wurden 2.2.2 Klassen in ABAP
orientierung jeweils deutliche Verbesserungen erzielt, die mit den objektorien-
Eine Klasse definiert einen Rahmen oder Instanzen eines Objekts. In
tierten Programmiersprachen ihr Ende nahmen. Die Objektorientie-
diesem Rahmen knnen Typen, Funktionen oder Attribute definiert
rung ermglicht einen hheren Wiederverwendungsgrad der Soft-
werden, die dann bei der Verarbeitung der Funktionen oder bei
ware. Die Sichtbarkeit von Variablen und Modulen kann viel
einem externen Aufruf abgerufen werden.
filigraner gesteuert werden als bei prozeduralen Sprachen. Vor der
Objektorientierung gab es keine Gruppierung von Methoden in Lokale Klassen werden in Programmen selbst definiert und knnen Lokale Klassen

einer Klasse bzw. Funktionsgruppe. dann auch nur in diesem Programm wiederverwendet werden. Wird
in einem ABAP-Report ein Include-Programm eingebunden, entste-
Vorteile von ABAP Objects bietet neben der Objektorientierung noch weitere hen im Hintergrund zwei eigenstndige Klassen, die einen identi-
ABAP Objects Vorteile gegenber dem Standard-ABAP. Mit ABAP Objects wurde

44 45
2 Umgang mit Entwurfsmustern Grundlagen der objektorientierten Programmierung mit ABAP 2.2

schen Aufbau haben, aber nicht typkompatibel sind. Typkompatibel ber die Sichtbarkeiten definieren Sie, ob Attribute, Methoden oder Sichtbarkeiten
bedeutet, dass die Objekte der Klassen nicht gegenseitig von den Ereignisse von anderen Klassen verwendbar sein sollen oder nicht.
Klassen verwendet werden knnen. Auf diese Weise knnen Sie eine Klasse von auen (d.h. von anderen
Klassen) unverwundbar machen. Im Class Builder stehen Ihnen die
Globale Klassen Globale Klassen werden im ABAP Dictionary erstellt und abgelegt. Sie
folgenden Sichtbarkeiten zur Auswahl:
sind typkompatibel und knnen dadurch in jedem ABAP-Report
direkt verwendet und miteinander vermischt werden. Diese Klassen public
legen Sie ber den Class Builder, d.h. ber die Transaktion SE24 an Die Klassenbestandteile sind fr alle Klassen sichtbar und definie-
(siehe Abbildung 2.6). Es gibt noch weitere Untertypen von Klassen ren die Schnittstelle der Klasse nach auen.
in ABAP, die wir im Folgenden erlutern. protected
Die Klassenbestandteile sind nur fr die vererbten (verwandten)
Klassen sichtbar und zugreifbar.
private
Die Klassenbestandteile sind nur fr die Klasse selbst sichtbar und
zugreifbar.

Konstruktoren werden bei jedem Erzeugen einer Instanz einer Klasse Konstruktoren
aufgerufen, sofern sie in der Klasse vorhanden sind. Der Konstruktor
wird mit dem reservierten Methodennamen CONSTRUCTOR erstellt
und abgelegt (siehe Abbildung 2.8). Dieser Konstruktor hat keine
Importparameter. Die einzige Ausnahme besteht bei einem ABAP-
Report mit Select-Option-Feldern, hierbei erhlt der Konstruktor
diese Felder als Importparameter.
Abbildung 2.6 Class Builder zum Anlegen einer Klasse
Importparameter in Konstruktoren

Auch alle Komponenten der Klassendefinitionen, die Sie in einer ber Importparameter im Konstruktor werden Werte bernommen, die
lokalen Klasse in den Quelltext einer Anwendung eingeben, werden der Objekterzeugung dienen.
im Class Builder auf den einzelnen Registerkarten erfasst (siehe
Abbildung 2.7). Um eine Klasse zu verwenden, mssen Sie diese
aktivieren.

Abbildung 2.8 Konstruktor in einer ABAP-Klasse

Abbildung 2.7 Class Builder Registerkartenpflege

46 47
2 Umgang mit Entwurfsmustern Grundlagen der objektorientierten Programmierung mit ABAP 2.2

Statische Klassen Bei statischen Klassen ist ein sogenannter Klassenkonstruktor vorhan- Die Attribute knnen unterschiedliche Werte aus dem ABAP Dictio-
den. Dieser wird einmalig bei der ersten Instanziierung der Klasse nary reprsentieren, z.B. Tabellen, Strukturen, Datenelemente, Klas-
ausgefhrt, d.h. dem ersten Zugriff auf die Klasse. Dieser Konstruk- sen oder Datentypen. Bei der dynamischen Programmierung werden
tor wird mit dem reservierten Methodennamen CLASS_CONSTRUCTOR diese Datentypen erst whrend der Laufzeit definiert, da sie wh-
in der Klasse erstellt. Diese Methode ist nur beim ersten Zugriff zu rend der Laufzeit generiert werden. Hierbei wird oft der dynamische
sehen; wurde eine statische Klasse bereits instanziiert, finde Sie die- Datentyp ANY oder TABLE verwendet.
sen Eintrag nicht mehr. Den Klassenkonstruktor legen Sie ebenso
Um Funktionen in ABAP-Klassen umzusetzen, gibt es Methoden. Instanzmethoden
wie den normalen Konstruktor im Class Builder an (ber den
Diese Methoden knnen wie die Attribute statisch oder an die
Menpfad Bearbeiten Klassenkonstruktor anlegen, siehe Abbil-
Instanz gebunden sein. Bei Instanzmethoden muss vorweg ein
dung 2.9).
Objekt erzeugt werden, um dann auf Basis des Objekts die Funktion
auszufhren. Listing 2.1 zeigt exemplarisch den Aufruf einer Instanz-
methode.

DATA: ref_cl TYPE REF OF classname.


CREATE OBJECT ref_cl.
CALL METHOD ref_cl->methodenname
EXPORTING ..
IMPORTING ..
Listing 2.1 Aufruf einer Instanzmethode

Bei statischen Methoden hingegen kann das Objekt direkt ber den Statische Methoden
Abbildung 2.9 Klassenkonstruktor anlegen Klassennamen aufgerufen werden (siehe Listing 2.2). Hierbei wird
kein Objekt der Klasse bentigt. Dieses Objekt wird im Hintergrund
Attribute Bei Attributen werden drei Typen unterschieden: automatisch erzeugt und anschlieend immer verwendet, egal in
statische Attribute welcher Klasse diese Methode aufgerufen wird.
Diese Attribute sind an die Klasse gebunden und werden nicht bei CALL METHOD cl_gui_frontend_services=>execute
der Instanziierung der Klasse initialisiert. Bei neuen Objekten der EXPORTING
Klasse bleibt das Attribut bzw. dessen Wert gleich. Auf die Attri- document = lv_url_string
bute wird folgendermaen zugegriffen: EXCEPTIONS
others = 1.
Klassenname=>Attributsname
Listing 2.2 Aufruf einer statischen Methode
Instanzattribute
Diese Attribute sind an die Instanz der Klasse gebunden. Sie wer- Persistente Klassen sind eine Sonderform der normalen ABAP-Klas- Persistente Klassen
den bei der Instanziierung des Klassenobjekts initialisiert. Auf die sen. Diese Klassen erlauben einen persistenten Zugriff auf Objekte
Attribute wird wie folgt zugegriffen: aus der Datenbank. Persistente Klassen kennen Sie vielleicht vom
Objektname->Attributsname Hibernate-Ansatz aus der Java-Welt. Der Hibernate-Ansatz wurde in
ABAP als Object Services umgesetzt und basiert auf persistenten
Konstanzattribute Klassen. Die Object Services sorgen in ABAP fr das Transaktions-
Diese Attribute sind komplett unabhngig von statischen und handling, das fr grere Entwicklungsprojekte sehr wichtig ist.
Instanzattributen. Auf die Attribute wird wie folgt zugegriffen:
Klassenname=>Konstante

48 49
2 Umgang mit Entwurfsmustern Grundlagen der objektorientierten Programmierung mit ABAP 2.2

Interfaces Durch ABAP Objects wurde noch ein neuer Begriff in die ABAP- 2.2.3 Programmelemente, Interfaces
Sprachwelt eingefhrt: Interfaces zhlen zu den gleichen Objektty- und Klassen verwenden
pen wie Klassen, reprsentieren aber nur einen Teilaspekt einer Im SAP-System und dessen Entwicklungsumgebung gibt es sehr viele Polymorphismus
Klasse. Sie sind eine spezielle Form einer abstrakten Klasse. Interfaces unterschiedliche Elemente, die man erstellen und verwenden kann.
reprsentieren einen Rahmen von Funktionen, die implementiert Um Entwurfsmuster im SAP NetWeaver Applikation Server ABAP
werden, sobald das Interface der Klasse hinzugefgt wird. (AS ABAP) zu entwickeln, werden hauptschlich Klassen und Inter-
faces bentigt. Diese reprsentieren alle Elemente, die in den An-
Abstrakte Klassen
wendungen wichtig sind. Sie folgen dem Prinzip des Polymorphis-
Abstrakte Klassen lassen sich nicht instanziieren. In ihnen werden ledig- mus. Der Begriff Polymorphismus beschreibt Klassen, die Methoden
lich abstrakten Methoden deklariert. Die Methoden knnen nicht in der-
und Attribute von der vererbenden Superklasse erhalten. Daher kn-
selben Klasse implementiert werden, sondern erst in einer Unterklasse,
nen die Methoden der Superklasse durch das Sprachelement super
die von der abstrakten Klasse erbt.
aufgerufen werden.

Abbildung 2.10 zeigt, wie ein Interface im Class Builder dargestellt


wird. Das Interface wird immer in die Klassen implementiert, in Konventionen fr die Programmierung
denen Sie seine Funktionen nutzen mchten. Diese Funktionen kn- Um Elemente sauber erstellen und verwenden zu knnen, sollte eine
nen dann in den Objekten der Klasse ausgefhrt werden. Dabei ms- Namenskonvention definiert werden. Diese wird in Kundenprojek-
sen Sie die Funktionen jedoch separat je Objekt, d.h. je Klasse aus- ten oft bereits durch die IT-Abteilung vorgegeben. Sie untersttzt die
implementieren. Entwickler, den Code schneller verstehen zu knnen und frdert so
die bersichtlichkeit und Wiederverwendbarkeit der Software bzw.
der verwendeten Entwurfsmuster.

Im Sprachumfang von ABAP gibt es Sprachelemente, die reser- Reservierte


vierte Wrter sind. Hierunter zhlen Wrter wie SELECT, FIELD- Sprachwrter

SYMBOL und ADD. Diese Sprachelemente verweisen auf eine Funk-


tion in ABAP oder ein Objekt aus dem Repository im SAP Net-
Weaver AS ABAP. Die Sprachelemente werden im ABAP-Spra-
chumgang (Code Style) zur besseren Lesbarkeit immer in
Grobuchstaben geschrieben.

In Kleinbuchstaben werden die technischen Bezeichner fr die refe- Technische


renzierten Objekte geschrieben. Diese beschreiben die Funktionali- Bezeichner

tt einer Anwendung. Sie werden im ABAP-Code in Kombination


mit den reservierten Wrtern verwendet.

Abbildung 2.10 Interface-Klasse im Class Builder


Parameterdefinitionen
Im Gegensatz zu den Funktionen von Interfaces besteht bei einer Um die in den Methoden enthaltenen Parameter genauer definieren
vererbten Methode immer ein Zusammenhang zur Superklasse. zu knnen, knnen Sie die folgende Formel anwenden:
Wenn die Unterklassen der Superklasse nicht die Methode imple-
mentieren, wird die Implementierung der Superklasse verwendet. <Ausfhrungsrichtung>_<Type>_<Erluterung>

50 51
2 Umgang mit Entwurfsmustern Grundlagen der objektorientierten Programmierung mit ABAP 2.2

Ausfhrungs- Mit der Ausfhrungsrichtung wird die Richtung definiert, die die bereits im ABAP Dictionary definiert worden sind. Domnen sind
richtung Daten in dem Programm nehmen, wie z.B. in den Parametern E_ Wertebereiche, die zentral im SAP-System definiert worden sind.
AUFTRAG oder I_AUFTRAGSNR (siehe auch Tabelle 2.2). Mit der Angabe eines Datentyps wird der Wertebereich bestimmt,
der mit einem ENUM-Typ in Java zu vergleichen ist. Im ABAP Dictio-
Ausfhrungsrichtung Bedeutung der Parameter fr Methoden nary knnen Sie den Wertebereich oder Beschreibungen von Wer-
I_ Importparameter, um Werte, Strukturen oder ten definieren.
Tabellen der Methode zu bergeben. Dieser Typ
kann in jeder Funktion mehrfach verwendet Das ABAP Dictionary ist eine zentrale Datentypen-Datenbank. Hier Wiederverwend-
werden. werden alle Definitionen zentral gespeichert. Diese knnen in jedem bare Objekte

E_ Exportparameter, um Werte, Strukturen oder anderen Projekt oder anderen Klassen verwendet werden. Wird ein
Tabellen der Methode zu erhalten. Dieser Typ Objekt gendert, wird diese nderung automatisch auf alle anderen
kann in jeder Funktion mehrfach verwendet Elemente angewendet, ohne dass der Entwickler sich darum km-
werden. mern muss. Dadurch werden Redundanzen im System verhindert
R_ Der Returning-Parameter ist equivalent zum und die Wiederverwendung von Objekten gefrdert.
Exportparameter, kann jedoch nur einmal verwen-
det werden. Zu jedem Dictionary-Element geben Sie immer auch eine Bezeich- Mehrsprachigkeit

MC_ Der Changing-Parameter ist eine Arbeitsvariable. nung an. Diese wird bei der Darstellung des Elements z.B. in Spal-
Dieser Parameter wird oft in Kombination mit tenberschriften automatisch verwendet. Daher gibt es auch die
Tabellen verwendet. Mglichkeit, diese Bezeichnungen in weitere Sprachen zu berset-
zen. Um eine Multi-Language-Anwendung zu erstellen, ist die Ver-
Tabelle 2.2 Ausfhrungsrichtung bei der Parameterdefinition
wendung von Dictionary-Elementen daher essentiell.

Parametertypen Als zweiter Teil des Parameters wird definiert, um welchen Typ es Wenn nderungen an den Elementen durchgefhrt werden sollen, nderbarkeit
sich handelt. Hierbei wird unterschieden zwischen Variablen und ist dies jederzeit mglich. Diese nderungen haben keine Auswir-
Konstanten sowie zwischen Strukturen und Tabellen. kung auf die Laufzeitanwendung, d.h. es werden keine nderungen
auf die bereits aktivierten Dictionary-Elemente angewendet. Die
Parametertyp Bedeutung des Elements nderungen wirken sich erst aus, wenn die Elemente durch den
0 einfache Variable, mit der als Element des ABAP ABAP-Prozessor aktiviert werden.
Dictionarys oder als integrierter Typ ein Wert
bergeben wird Strukturen
S Struktur, mit der eine Reihe von Variablen in einer Strukturen sind logische Kombinationen von Datenelementen, die in
geordneten Reihenfolge bergeben wird, die im einer flachen Liste zusammengesetzt werden knnen. Eine Struktur
ABAP Dictionary definiert wurde
kann eine Tabellenzeile reprsentieren. Neben den Datenelementen
T bergabe einer Tabelle, die auf der Basis von wird auch ein Primrschlssel (eindeutiger Schlssel) definiert, der
Strukturzeilen im ABAP Dictionary definiert wurde
spter den Index der Tabellen definiert. Der Index ermglicht einen
Tabelle 2.3 Parametertypen fr Namenskonvention schnellen Zugriff auf die Tabelle, da ihm bekannt ist, wo ein Daten-
satz zu finden ist. Dies fhrt zu einer erheblichen Performancesteige-
rung beim Auslesen der Tabelle. Entwurfsmuster geben meistens
ABAP Dictionary
Strukturen anstelle einfacher Variablen zurck.
Um in ABAP verschiedene Datentypen zu verwenden, mssen diese
Es gibt zwei Arten von Strukturen, globale und lokale Strukturen. Globale Strukturen
definiert werden. Dies findet im ABAP Dictionary statt. Diese Defini-
Globale Strukturen legen Sie ber Transaktion SE11 im ABAP Dictio-
tionen sind allgemeingltig und basieren auf den Domnen, die

52 53
2 Umgang mit Entwurfsmustern Grundlagen der objektorientierten Programmierung mit ABAP 2.2

nary an. Hierbei geben Sie mithilfe eines vorgegebenen Assistenten Tabellentypen
alle notwendigen Elemente ein. Sie werden in SAP-Anwendungen Es gibt auch verschiedene Typen von Tabellen, die sehr wichtig wer-
zum groen Teil verwendet. den, wenn Sie mithilfe von Entwurfsmustern viele Daten verarbeiten
mchten. Hier knnen Sie groe Performancesteigerungen durch
Lokale Strukturen Lokale Strukturen sind technische Strukturen, die direkt in ABAP-
einfache Tricks erzielen. Dies zu beachten ist vor allem dann wesent-
Klassen und -Methoden definiert werden knnen. Diese werden oft
lich, wenn Sie grere Datenmengen in internen Tabellen verwen-
in Kombination mit Extraktoren, d.h. bestimmten Elementen aus
den mchten.
SAP Business Warehouse (BW), verwendet. Zur Definition lokaler
Strukturen gibt es in ABAP-Klassen-Definitionen den Bereich TYPES. Eine Hash-Tabelle erzeugt neben der normalen Tabelle noch eine Hash-Tabelle
Hier knnen Sie lokale Strukturen im Programm anlegen, wie es Lis- weitere interne Tabelle, die den Hash-Algorithmus beinhaltet. Der
ting 2.3 exemplarisch zeigt. Hash-Algorithmus ist ein standardisiertes Verfahren, das die Pro-
gramme bei einer effizienten Verarbeitung der Tabellenzugriffe
TYPES:
BEGIN OF ZMS_S_TEST, untersttzt. Dies hat den Vorteil, dass alle Lesezugriffe auf diese
Element1 TYPE char10, Tabelle identisch sind und dadurch unabhngig von der Gre der
Element2 TYPE char10, internen Tabelle. Daher ist die Verwendung dieses Tabellentyps bei
Element3 TYPE char10, groen internen Tabellen mit vielen Lesezugriffen ber den Schls-
Element4 TYPE char10,
sel zu empfehlen. Um ihn verwenden zu knnen, muss ein eindeuti-
Element5 TYPE char10,
END OF ZMS_S_TEST. ger Schlssel vorhanden sein. Neue Elemente knnen nur durch
INSERT und DELETE bearbeitet werden. Listing 2.5 zeigt die Defini-
Listing 2.3 Typendefinition fr eigene Strukturen
tion einer Hash-Tabelle.
Tabellenstrukturen Tabellenstrukturen sind logische Tabellen, die auf einer Struktur oder it_tabelle1 TYPE HASHED TABLE OF zms_s_test01
einem Standarddatentyp basieren. Basiert die Tabelle auf einer WITH UNIQUE KEY /bic/0zms01 /bic/0zms01
Struktur, geben Sie diese in Transaktion SE11 beim Anlegen an. Hier- Listing 2.5 Typendefinition fr eigene Hash-Tabellen
bei wird der Primrschlssel der Struktur als primrer Index defi-
niert. Dieser kann durch weitere Indexe als Sekundrschlssel ange- Eine Standardtabelle ist die Tabelle, die standardmig bei der Ent- Standardtabelle
legt werden. Wenn Sie den Primrschlssel in ABAP ansprechen wicklung in SAP verwendet wird. Bei dieser Tabelle knnen Sie sehr
mchten, mssen Sie beim READ <Table> den Zusatz WITH <Sekundr- einfach durch das Schlsselwort APPEND neue Elemente hinzufgen
schlsselname> verwenden. und ber READ TABLE INDEX 1 auslesen. Die Zugriffzeiten sind propor-
tional abhngig zu der Elementanzahl. Bei geringen Datenmengen ist
Ist keine Struktur vorhanden, knnen Sie definieren, wie oft welcher
die Standardtabelle schneller als die Hash-Tabelle oder sortierte
Datentyp in der Tabelle vorkommen soll. Diese Verwendung ist aber
Tabelle. Die Schlsselwrter TYPE STANDARD OF und TYPE TABLE OF
nicht zu empfehlen. Die Tabellenstrukturen knnen Sie in Trans-
sind quivalent. Sie werden verwendet, um Variablen zu definieren.
aktion SE11 oder auch wieder ber den Programmcode in ABAP-
INITIAL SIZE 0 ist immer als Standard vorgegeben. Es bedeutet, dass
Klassen definieren. Letzteres wird wie in Listing 2.4 durchgefhrt.
die initiale Gre der Tabelle keine Elemente enthlt, auch wenn
TYPES: dies nicht angegeben wird. Listing 2.6 zeigt die Definition einer Stan-
zms_t_test TYPE STANDARD TABLE OF zms_s_test dardtabelle.
WITH NON-UNIQUE DEFAULT KEY.
it_tabelle2 TYPE STANDARD OF zms_s_test01
Listing 2.4 Typendefinition fr eigene Tabellenstrukturen
INITIAL SIZE 0,
it_tabelle2 TYPE TABLE OF zms_s_test01.
Listing 2.6 Typdefinition fr eigene Standardtabellen

54 55
2 Umgang mit Entwurfsmustern

Sortierte Tabelle Sortierte Tabellen knnen mit einem eindeutigen oder nicht eindeuti-
gen Schlssel definiert werden. Die Zugriffzeiten auf sortierte Tabel-
len sind schneller als bei einer Standardtabelle, aber langsamer als
bei einer Hash-Tabelle. Des Weiteren erlaubt eine sortierte Tabelle
einen BINARY SEARCH. Dieses Schlsselwort wird verwendet, um eine
zeichenbasierte Suche durchzufhren. Wenn sortierte Tabellen ein-
gesetzt werden, knnen Sie mit den gleichen Elementen wie bei
einer Standardtabelle arbeiten.

Verwendung von sortierten Tabellen

Bei einer kleinen Datenmenge ist die Standardtabelle zu empfehlen, da


die sortierte Tabelle auch weitere Indexe anlegt, wodurch der Zugriff bei
geringen Datenmengen viel langsamer ist.

Datenbanktabelle Die Datenbanktabelle ist ein Tabellentyp, der einer physischen


Tabelle auf dem Datenbankserver entspricht. Logisch wird diese
ber eine Struktur oder in verschiedenen Datenbanksystemen simul-
tan aufgebaut. In Datenbanktabellen knnen die Daten physisch
gespeichert und auch wieder ausgelesen werden. Lesen Sie in diesem
Zusammenhang auch die Informationen zu persistenten Klassen in
Abschnitt 2.2.2, Klassen in ABAP.

56
Inhalt

Einleitung .................................................................................. 13

1 Einfhrung ............................................................... 17

1.1 Was sind Entwurfsmuster? ...................................... 17


1.1.1 Entwurfsmuster in der Software-
entwicklung ............................................... 19
1.1.2 Softwaredesign mithilfe von Entwurfs-
mustern ..................................................... 22
1.2 Vorteile einer entwurfsmusterbasierten
Architektur ............................................................. 29
1.2.1 Flexibilitt bei Neuanforderungen .............. 29
1.2.2 Zeitersparnis bei der Umsetzung ................ 30
1.2.3 Mglichkeiten der Parallelentwicklung ...... 32
1.2.4 Wartbarkeit der Entwicklung ..................... 33

TEIL I Entwurfsmuster in ABAP implementieren

2 Umgang mit Entwurfsmustern ............................... 37

2.1 UML-Grafiken erstellen ........................................... 37


2.1.1 Klassendiagramm ...................................... 39
2.1.2 Anwendungsfalldiagramm ......................... 41
2.1.3 Sequenzdiagramm ..................................... 42
2.2 Grundlagen der objektorientierten
Programmierung mit ABAP ..................................... 43
2.2.1 ABAP Objects ............................................ 43
2.2.2 Klassen in ABAP ........................................ 45
2.2.3 Programmelemente, Interfaces und
Klassen verwenden .................................... 51

3 Erzeugungsmuster ................................................... 57

3.1 Builder Pattern ....................................................... 59


3.1.1 Problem .................................................... 60
3.1.2 Ansatz und Lsung .................................... 60
3.1.3 Umsetzung in ABAP .................................. 62

7
Inhalt Inhalt

3.1.4 Einsatzbeispiel ........................................... 68 4.4 Faade Pattern ........................................................ 126


3.1.5 Evaluation .................................................. 69 4.4.1 Problem .................................................... 126
3.2 Factory Pattern ........................................................ 70 4.4.2 Ansatz und Lsung .................................... 128
3.2.1 Problem ..................................................... 71 4.4.3 Einsatzbeispiele ......................................... 130
3.2.2 Ansatz und Lsung ..................................... 72 4.4.4 Umsetzung in ABAP .................................. 134
3.2.3 Einsatzbeispiel ........................................... 75 4.4.5 Evaluation ................................................. 138
3.2.4 Umsetzung in ABAP ................................... 76
3.2.5 Evaluation .................................................. 80 5 Verhaltensmuster .................................................... 139
3.3 Singleton Pattern ..................................................... 82
3.3.1 Problem ..................................................... 82 5.1 Command Pattern ................................................... 141
3.3.2 Ansatz und Lsung ..................................... 83 5.1.1 Problem .................................................... 141
3.3.3 Einsatzbeispiele .......................................... 84 5.1.2 Ansatz und Lsung .................................... 142
3.3.4 Umsetzung in ABAP ................................... 86 5.1.3 Einsatzbeispiele ......................................... 144
3.3.5 Evaluation .................................................. 88 5.1.4 Umsetzung in ABAP .................................. 145
3.4 Prototype Pattern .................................................... 90 5.1.5 Evaluation ................................................. 149
3.4.1 Problem ..................................................... 90 5.2 Interpreter Pattern .................................................. 150
3.4.2 Ansatz und Lsung ..................................... 90 5.2.1 Problem .................................................... 150
3.4.3 Einsatzbeispiele .......................................... 92 5.2.2 Ansatz und Lsung .................................... 151
3.4.4 Umsetzung in ABAP ................................... 92 5.2.3 Einsatzbeispiele ......................................... 154
3.4.5 Evaluation .................................................. 95 5.2.4 Umsetzung in ABAP .................................. 156
5.2.5 Evaluation ................................................. 162
4 Strukturmuster ........................................................ 97 5.3 Iterator Pattern ....................................................... 163
5.3.1 Problem .................................................... 163
4.1 Model View Controller ............................................ 98 5.3.2 Ansatz und Lsung .................................... 163
4.1.1 Problem ..................................................... 98 5.3.3 Einsatzbeispiele ......................................... 166
4.1.2 Ansatz und Lsung ..................................... 99 5.3.4 Umsetzung in ABAP .................................. 167
4.1.3 Einsatzbeispiele .......................................... 102 5.3.5 Evaluation ................................................. 173
4.1.4 Umsetzung in ABAP ................................... 103 5.4 Mediator Pattern .................................................... 174
4.1.5 Evaluation .................................................. 106 5.4.1 Problem .................................................... 174
4.2 Adapter Pattern ....................................................... 107 5.4.2 Ansatz und Lsung .................................... 174
4.2.1 Problem ..................................................... 107 5.4.3 Einsatzbeispiele ......................................... 176
4.2.2 Ansatz und Lsung ..................................... 108 5.4.4 Umsetzung in ABAP .................................. 177
4.2.3 Einsatzbeispiele .......................................... 111 5.4.5 Evaluation ................................................. 182
4.2.4 Umsetzung in ABAP ................................... 112 5.5 Observer Pattern .................................................... 183
4.2.5 Evaluation .................................................. 114 5.5.1 Problem .................................................... 183
4.3 Composite Pattern ................................................... 115 5.5.2 Ansatz und Lsung .................................... 184
4.3.1 Problem ..................................................... 115 5.5.3 Einsatzbeispiele ......................................... 186
4.3.2 Ansatz und Lsung ..................................... 115 5.5.4 Umsetzung in ABAP .................................. 186
4.3.3 Einsatzbeispiele .......................................... 117 5.5.5 Evaluation ................................................. 190
4.3.4 Umsetzung in ABAP ................................... 119 5.6 State Pattern ........................................................... 191
4.3.5 Evaluation .................................................. 125 5.6.1 Problem .................................................... 191

8 9
Inhalt Inhalt

5.6.2 Ansatz und Lsung ..................................... 192


7 Flexible Entwicklung einer Beispielanwendung ..... 267
5.6.3 Einsatzbeispiele .......................................... 194
5.6.4 Umsetzung in ABAP ................................... 196 7.1 Planung und Konzipierung der Beispiel-
5.6.5 Evaluation .................................................. 201 anwendung ............................................................. 268
5.7 Strategy Pattern ....................................................... 202 7.1.1 Berechtigungen ......................................... 268
5.7.1 Problem ..................................................... 202 7.1.2 Anwendungsarchitektur ............................. 270
5.7.2 Ansatz und Lsung ..................................... 203 7.2 Implementierung der Beispielanwendung ............... 273
5.7.3 Einsatzbeispiele .......................................... 204 7.2.1 Allgemeine Elemente fr die
5.7.4 Umsetzung in ABAP ................................... 205 Beispielanwendung ................................... 274
5.7.5 Evaluation .................................................. 208 7.2.2 Schichtenmodell (Model View Controller) . 278
5.8 Template Pattern ..................................................... 210 7.2.3 Auftragserzeugung (Factory Pattern) .......... 292
5.8.1 Problem ..................................................... 210 7.2.4 Layoutsteuerung (Faade und Singleton
5.8.2 Ansatz und Lsung ..................................... 210 Patterns) .................................................... 304
5.8.3 Einsatzbeispiele .......................................... 212 7.2.5 Berechtigungssteuerung (Command Pattern) 312
5.8.4 Umsetzung in ABAP ................................... 213 7.2.6 Sperrverfahren (Model View Controller) .... 323
5.8.5 Evaluation .................................................. 218 7.2.7 Plausibilittsprfungen
5.9 Visitor Pattern ......................................................... 219 (Faade und Composite Patterns) .............. 335
5.9.1 Problem ..................................................... 219 7.2.8 Anwendungslog (Composite Pattern) ......... 345
5.9.2 Ansatz und Lsung ..................................... 219
5.9.3 Einsatzbeispiele .......................................... 222 Die Autoren ............................................................................. 349
5.9.4 Umsetzung in ABAP ................................... 223
5.9.5 Evaluation .................................................. 230 Index ........................................................................................ 351

TEIL II Anwendungsentwicklung mithilfe von


Entwurfsmustern

6 Entwurfsmuster im Entwicklungsprojekt
einsetzen ................................................................. 235

6.1 Vor Projektstart ....................................................... 235


6.2 Aufbau einer ganzheitlichen Architektur .................. 241
6.3 Umsetzungsmethoden ............................................. 244
6.3.1 Wasserfall-Methode ................................... 244
6.3.2 Scrum-Methode ......................................... 248
6.3.3 Kanban-Methode ....................................... 259
6.4 Review-Verfahren .................................................... 263

10 11
Index

A Attribut (Forts.)
Konstanzattribut 48
ABAP Dictionary 46, 52, 54 statisches 48
ABAP Object Services 289 UML 39
ABAP Objects 43, 44 Aufrufer 142
ABAP-Prozessor 53 Auftragsnummer 268, 292
Abnahmetest 246 Ausfhrungsrichtung 52
Abstract Factory Pattern 58
abstract_factory 73
Adapter 109, 290 B
Adapter Pattern 28, 32, 97, 107,
291, 306 Backlog 250, 252
Agent 300 Beck, Kent 17, 19
Aggregat 164, 166 Befehl 143, 284, 298, 313
Aggregat, konkretes 164 gruppieren 149
Aggregation 25 kapseln 141
Agilitt 248 Klasse 143
Akteur 41 Makro-Befehl 149
Aktion rckgngig machen 144 Befehlsmuster Command Pattern
Alexander, Christopher 17 Beispielanwendung 268
Algorithmus 202, 210 Benutzeroberflche 281, 304
Alias 169 Benutzeroberflchenelement
ALV 105, 283 UI-Element
Analysephase 238 Benutzertyp 270
Anforderung 245 Beobachter-Muster 140, 183
Anforderungsspezifikation Berechtigungsobjekt 321
Lastenheft Berechtigungsprfung 288
Anti Pattern 21, 85 Berechtigungsprfung, zentrale 302
Anwendungsentwurf 238 Berechtigungssteuerung 287, 313
Anwendungsfalldiagramm 41 Best Practices 20
Anwendungslog 345 Besucher 219
Anwendungslogik 284 Besucher-Muster 140, 219
Anwendungsschicht 284 BINARY SEARCH 56
APPEND 55 BPMN 38
Application Layer 242 Bug 253
Arbeitsfluss 263 Bugfixing 253
Arbeitsvorrat 283 Builder Pattern 58, 59
Architektur 17, 241 Burndown Chart 254
Architekturentwurf 238 Business Key 300
Architekturmodell 238 Business Layer 242
Artefakt 252 Business Process Model and
Assoziation 25 Notation 38
Attribut 48 BW-Hierarchie 117
Instanzattribut 48
internes 86

351
Index Index

C E Factory-Klasse, abstrakte 71 Instanziierung 28


Factory-Methode 71 Instanzmethode 49
Callback 141 Earned-Value-Analyse 253 Feature 250, 252 Integrationstest 246
Chain Manager 335 Einschubmethode 211 Fehler 253 Interface 50, 109, 168, 287, 289
Chain Pattern 335 Einzelstck-Entwurfsmuster Fehlerbehebung 253 Interpreter 150
Change Management, evolutio- Singleton Pattern Feinentwurf 239 Interpreter Pattern 139, 150
nres 259 Empfnger 142 Flaschenhalsprinzip 90 Iteration 166
Changing-Parameter 52 Endlosschleife 191 Flexibilitt 29 Iterator 163, 164
Class Builder 46 Entwicklungsansatz 18 Fliegengewicht-Muster 162 externer 166
Client 61, 66, 142 Entwicklungsprojekt 235 Flow 263 interner 166
Command Pattern 140, 141, 230, Entwicklungsumfang 235 Flow-Prinzip 260 Klasse 168
269, 313 Entwurf 238 Flyweight Pattern 162 konkreter 165
Command-Klasse 141, 299 Entwurfsmuster 17 Framework 18 polymorpher 173
Commitment 252 Gruppe 24 Funktionsbaustein 277 Iterator Pattern 140, 162, 163, 230
Component-Controller 279 Historie 18 Funktionstest 246 IT-Spezifikation 239, 246
Composite Pattern 97, 115, 149, 162, Katalog 27
285, 318, 346 Kategorie 24
concrete_factory 73 klassenbasierte 57 G J
Connector 291 objektbasierte 57
Context (Web Dynpro) 274, 278 Gamma, Erich 18 Java 43
Typ 24
Context-Mapping 279 Gang of Four 18 Johnson, Ralph 18
bersicht 26
Controller 100, 101, 279, 281, 284, Geschftslogikschicht 289
Voraussetzungen 22
286, 313 Getter-Methode 28
Erbauer
CREATE OBJECT 105 Implementierung 64
GoF 18 K
Cunningham, Ward 17, 19 GoF-Muster 18, 27
Klasse 61 Kanban-Methode 259
Cursor Iterator Grobentwurf 238, 241
konkreter 61 Kanban-Tafel 261
Customizing-Tabelle 291 Erbauermuster 59 Kapsel-Entwurfsmuster Faade
Ereignisbehandler 298 H Pattern
Erweiterungsanforderung 243 Klasse
D Erzeugungsmuster 24, 25, 57 Hash-Tabelle 55 abstrakte 40, 50
Erzeugungsprozess 59 Helm, Richard 18 Attribut 48
Daily Scrum 256
Evolutionres Change Manage- Hierarchy plus Input Process Diagrammdarstellung 39
Data Store Object 85
ment 259 Output 44 globale 46
Datenbankschlssel 300
Exportparameter 52 HIPO 44 Instanziierung 47
Datenbanktabelle 56, 305
Extraktor 54 Hllenklasse Adapter Pattern lokale 45
Datenbankzugriff 290
Datensynchronitt 90 persistente 49, 325
Datentyp statische 48
F I typkompatible 45
definieren 52
UML 40 Fabrik-Entwurfsmuster Factory UML 39
iDoc 109
Dead-Lock 202 Pattern Klassenakteur 300
Impediment Backlog 251, 255, 257
Design 246 Faade Pattern 126, 313 Klassendiagramm 39
Implementierung 246
Design Pattern Entwurfsmuster abstrakte Klasse 128 Importparameter 47, 52, 57
Klassenkonstruktor 48
Designphase 241 eine Schnittstelle 128 Klassenmuster 25, 57
Inbound-Plug 283
Dialogbenutzer 270 Fachbereich 236 Klonen 91
Index 53, 300
Direktor 61, 66 Fachkonzept 29 Kommando 288
Indirektionsstufe 138
Domne 52 Fachkonzept Lastenheft Kommando Befehl
Infrastrukturschicht 242, 290
Dreischichtenmodell 102 Factory Pattern 57, 70, 80, 82, Kompilieren 32
INITIAL SIZE 55
218, 270 Kompositionsansatz 25, 139
Injection 69
Factory-Klasse 71, 289 Kompositionsmuster Composite
Instanzattribut 48
Pattern

352 353
Index Index

Konkreter Erbauer implemen- N Pflichtenheft 239, 246 S


tieren 65 Plausibilittsprfung 30, 243, 335
Konstante 31, 52 Nachrichten-ID 277 Polymorphismus 51 SAP List Viewer 283
Konstanzattribut 48 Nachrichtenklasse 275, 277 Prsentationsschicht 99, 281 Schablonenklasse 214
Konstruktionsprozess 59 Nachrichtentyp 277 Primrschlssel 53, 54, 300 Schablonenmethode 140, 210, 211
Konstruktor 47 Namenskonvention 51 private 47 Schichtenarchitektur 242, 279
Kontextobjekt 28 Navigation 281 Product Backlog 250, 252 Schichtenmodell 102
Kontrollfluss 25, 139 Null-Referenz 86 Product Backlogs 250 Schnittstelle 271
Nummernkreisintervall 292 Product Owner 249 Scrum Master 250
Nummernkreisobjekt 292 Produkt 61 Scrum Team 251
L Produkt implementieren 63 Scrum-Methode 248
Programmieransatz Artefakte 252
Lastenheft 238, 239, 241, 245 O datengetrieben 44 Rituale 255
Laufzeitnderung 25 dynamischer 49 Rollen 249
Layout Object Management Group 37 funktionsgetrieben 44 Security Manager 320
flexible Steuerung 269 Object Services 49, 289, 299 objektorientierter 19, 43 Select-Anweisung 85
Manager 304 Objects for State 140, 191 prozeduraler 43, 44 Select-Option 47
Steuerung 304 Objekt Projektmanagement 235 Sequenzdiagramm 42, 239
Lazy Loading 89 aktivieren 32 Projektphase 238 Setter-Methode 28
Logical Unit of Work 325 erzeugen 25 Projektplan 235 Sichtbarkeit 40, 47
Logistik 268 instanziieren 28 protected 47 Singleton Pattern 58, 82, 83, 89
Lsungsentwurf 238 persistentes 289 Prototyp 90 Singleton-Klasse 86
LUW 325 primitives 116 Prototype Pattern 58, 90 Software
zusammengesetztes 116 Prozess 268 Qualitt 24, 29
Objektklasse 140 Prfobjekt 336 Verhalten 139
M Objektmuster 25, 58 Prfung 336 Softwaredesign
Objektorientierung 19, 43 public 47 Vorgehensmodell 22
Makro-Befehl 149
Observer Pattern 140, 183 Publish-Subscribe-Schnittstelle 183 Vorgehensweise 237
Management Board 255
Online Text Repository 277 Pull-Prinzip 260 Softwareentwicklung
Mapping 300
Open SQL 290 Pull-Verfahren 185 Methodik 17
Mediator Pattern 140, 174, 190
Operation Push-Verfahren 185 Vorgehensmodell 22
Mehrfachinstanz 86
ausfhren 141 Sperrobjekt 325
Mehrsprachigkeit 276
primitive 212 Sperrtabelle 326
Meldung 277
Memento Pattern 150
rckgngig machen 144 R Sperrverfahren 323
OTR 277 Implementierung 331
Message Manager 277 Rapid Deployment 95
Out of Scope 240 optimistisches 324
Methode 49 READ TABLE INDEX 55
create_command() 289 pessimistisches 324
Redo 144
Einschubmethode 211 Spezifikation, technische 236
P Redundanz 18, 31, 243
Sprachuntersttzung 276
Instanzmethode 49 Remote Function Call 45
statische 49 Sprint 256
PAL-Editor 282 Remote-Funktionsbaustein 45
Model 99, 278 Backlog 253
Parallelentwicklung 32 Report 62
Model View Controller 98, 270, Planung 255
Parallelisierung 18 Repository Browser 274
278, 324 Retrospektive 257
Parameter Retest 262
Mustersprache 17 Ausfhrungsrichtung 52 Review 257
Retrospektive 257
MVC 184 definieren 51 Ziel 255
Returning-Parameter 52
MVC Model View Controller Typ 52 Standardtabelle 55
Review 257
Stapelverarbeitung 116
Parser 154 RFC 45
State Pattern 140, 191
Parser-Generator 154 RFC-Aufruf 290
Strategiemuster 140, 202
Persistenz-Mapping 300 RFC-Destination 291
Strategy Pattern 140, 202
PFCG-Rolle 270

354 355
Index Index

Struktur 52, 53, 274 Unique-Index 300 Z Zustandsautomat 192


globale 53 URL 281 hierarchischer 192
lokale 54 Use-Case-Diagramm 41 Zeiger Iterator Zustandshierarchie 193
Strukturmuster 24, 25, 97 User Interface 242 Zentralisierung 29 Zustandsklasse 196
klassenbasiertes 98 User Story 250 Zustand Zustandsmuster 140, 191
objektbasiertes 97 Abhngigkeit 191 Zustandsobjekt 28
Superklasse 73 nderung 191
Syntaxbaum 151 V
Variable 52
T Variable, globale 83, 89
Variante 61, 188
Tabelle 52 VBA 43
Hash 55 Verarbeitungsklasse 63
kundeneigene 299 Vererbung 25
sortierte 56 Verhaltensmuster 24, 25, 139
Standardtabelle 55 klassenbasiertes 139
T100 277 objektbasiertes 140
Typen 55 Vermittler-Entwurfsmuster
Tabellenstruktur 54 Mediator Pattern
Template Pattern 140, 210 Viererbande 17, 18
Test 246 View 99, 101, 278
Test, Nachtest 262 View-Controller 279, 305, 306
Testphase 236 Visitor 219
Toolkit 71 Visitor Pattern 140, 219
Top-Level-Transaktion 331 Vlissides, John 18
Transaktion Vorlage 210
SE11 53
SE24 46
SE38 62 W
SE80 274
Wartbarkeit 33
SGL1 348
Warteschlange 144
SPRO 292
Wasserfallmodell 244
SU21 321
Wasserfallmodell nach Royce 246
SU53 321
Web-Dynpro-Anwendung 279, 281
Traversierung, polymorphe 174
Web-Dynpro-Component 279, 281
Traversierungsschnittstelle 173
eingebettete 281
TYPE STANDARD OF 55
zentrale 281
TYPE TABLE OF 55
Web-Dynpro-Context 274, 278
Wiederherstellung 144
Wiederverwendbarkeit 44
U
Wildwuchs 98
bergabeparameter 28 Window 278, 283
bersetzung 276 Window-Controller 279
UI-Element 144 Work in Process 260, 263
UML 37, 39 Workflow 260
UML-Diagramm 39 Wrapper 110
Umsetzungsmethode, agile 248 Wrapper Adapter Pattern
Undo 144
Unified Message Language 37, 39

356 357
Wissen aus erster Hand.

Nurgl Atilgan ist seit 2007 Mitarbeiterin der T-Systems GEI


GmbH und arbeitet als SAP BI/BO Consultant im Automotive-
Sektor. Sie verfgt ber langjhrige Erfahrung in der konzep-
tionellen Ausarbeitung von Anwendungen und Architekturen
sowie in der Implementierung von SAP-BI-Lsungen.

Markus Straub ist Mitarbeiter der T-Systems International


GmbH. Er arbeitet als BI-Architekt und -Berater in der Auto-
mobilindustrie. Sein Fokus liegt auf der Konzeptionierung und
Implementierung von SAP-BW-/BusinessObjects-Anwendun-
gen. Als Mit-Geschftsfhrer von IT-Service Dienstleistungen
Straub kennt er die Kunden- und IT-Prozesse sehr genau.

Wir hoffen sehr, dass Ihnen diese Leseprobe gefallen hat. Sie drfen sie gerne emp-
fehlen und weitergeben, allerdings nur vollstndig mit allen Seiten. Bitte beachten
Sie, dass der Funktionsumfang dieser Leseprobe sowie ihre Darstellung von der
Nurgl Atilgan, Markus Straub E-Book-Fassung des vorgestellten Buches abweichen knnen. Diese Leseprobe ist
in all ihren Teilen urheberrechtlich geschtzt. Alle Nutzungs- und Verwertungs-
Entwurfsmuster in ABAP rechte liegen beim Autor und beim Verlag.
357 Seiten, gebunden, Januar 2015
69,90 Euro, ISBN 978-3-8362-2833-6
Teilen Sie Ihre Leseerfahrung mit uns!

www.sap-press.de/3579