Abap Entwicklung in Eclipse (German)

SAP PRESS ist eine gemeinschaftliche Initiative von SAP SE und der Rheinwerk Verlag GmbH. Ziel ist es, Anwendern qualifiziertes SAP-Wissen zur Verfügung zu stellen. SAP PRESS vereint das fachliche Know-how der SAP und die verlegerische Kompetenz von Rheinwerk. Die Bücher bieten Expertenwissen zu technischen wie auch zu betriebswirtschaftlichen SAP-Themen. Arlitt, Dunz, Gahm, Majer, Westenberger Besseres ABAP – Schnell, sicher, robust 2015, 497 Seiten, geb. ISBN 978-3-8362-2939-5 Miroslav Antolovic Einführung in SAPUI5 2014, 446 S., geb. ISBN 978-3-8362-2753-7 Schneider, Westenberger, Gahm ABAP-Entwicklung für SAP HANA 2013, 602 S., geb. ISBN 978-3-8362-1996-9 Wulff, Haubitz, Goerke, Seegebarth, Tönges Das ABAP-Kochbuch Erfolgsrezepte für Entwickler 2013, 656 Seiten, geb. ISBN 978-3-8362-2108-5 Roland Schwaiger, Dominik Ofenloch Web Dynpro ABAP Das umfassende Handbuch 2., aktualisierte und erweiterte Auflage 2014, 1.145 Seiten, geb. ISBN 978-3-8362-2751-3 Aktuelle Angaben zum gesamten SAP PRESS-Programm finden Sie unter www.sap-press.de.

Daniel Schön

ABAP -Entwicklung in Eclipse ®

Liebe Leserin, lieber Leser, vielen Dank, dass Sie sich für ein Buch von SAP PRESS entschieden haben. Eine neue Entwicklungsumgebung für das gute alte ABAP. Was hat sie zu bieten? Wie groß ist der Umstellungsaufwand? Sind alle lieb gewonnenen Funktionen enthalten? Dieses Buch habe ich mit besonderer Spannung erwartet – und ich bin mir sicher, dass es Ihnen ähnlich ging. Unser Autor Daniel Schön nimmt Sie darin mit auf eine Entdeckungsreise durch die Eclipse-Umgebung und macht Sie mit allen Funktionen vertraut. Nützliche Abkürzungen wie Quick Fix und Shortcuts werden Ihnen schon bald unentbehrliche Helfer bei der ABAP-Programmierung sein. Und vielleicht entdecken Sie ganz nebenbei sogar die eine oder andere Funktion der ABAP Workbench neu – denn viele Funktionen wurden zuerst in Eclipse entwickelt und erst kürzlich in die Workbench übertragen. Wir freuen uns stets über Lob, aber auch über kritische Anmerkungen, die uns helfen, unsere Bücher zu verbessern. Scheuen Sie sich nicht, mich zu kontaktieren. Ihre Fragen und Anmerkungen sind jederzeit willkommen.

Ihre Janina Schweitzer Lektorat SAP PRESS

Rheinwerk Verlag Rheinwerkallee 4 53227 Bonn [email protected] www.sap-press.de

Hinweise zur Benutzung Dieses E-Book ist urheberrechtlich geschützt. Mit dem Erwerb des E-Books haben Sie sich verpflichtet, die Urheberrechte anzuerkennen und einzuhalten. Sie sind berechtigt, dieses E-Book für persönliche Zwecke zu nutzen. Sie dürfen es auch ausdrucken und kopieren, aber auch dies nur für den persönlichen Gebrauch. Die Weitergabe einer elektronischen oder gedruckten Kopie an Dritte ist dagegen nicht erlaubt, weder ganz noch in Teilen. Und auch nicht eine Veröffentlichung im Internet oder in einem Firmennetzwerk. Die ausführlichen und rechtlich verbindlichen Nutzungsbedingungen lesen Sie im Abschnitt Rechtliche Hinweise. Dieses E-Book-Exemplar ist mit einem digitalen Wasserzeichen versehen, einem Vermerk, der kenntlich macht, welche Person dieses Exemplar nutzen darf:

Impressum Dieses E-Book ist ein Verlagsprodukt, an dem viele mitgewirkt haben, insbesondere: Lektorat  Janina Schweitzer Korrektorat  Alexandra Müller, Olfen Herstellung E-Book  Melanie Zinsler Covergestaltung  Nadine Kohl Coverbild  Shutterstock_149065532 © solarseven Satz E-Book  Typographie & Computer, Krefeld Wir hoffen sehr, dass Ihnen dieses Buch gefallen hat. Bitte teilen Sie uns doch Ihre Meinung mit und lesen Sie weiter auf den Serviceseiten.

Bibliografische Information der Deutschen Nationalbibliothek: Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. ISBN 978-3-8362-3040-7 (Buch) ISBN 978-3-8362-3041-4 (E-Book)

1. Auflage 2015 © Rheinwerk Verlag GmbH, Bonn 2015

Inhalt Vorwort ..................................................................................................

11

Einleitung ................................................................................................

13

1

Die ersten Schritte – »Hallo ADT« ....................................... 21 1.1

1.2

1.3

1.4

2

Backend-System .................................................................... 1.1.1 Den SAP NetWeaver Application Server einrichten ................................................................ 1.1.2 Amazon Web Services .............................................. Installation und Einrichtung der Entwicklungsumgebung ....... 1.2.1 Java Runtime Environment ....................................... 1.2.2 Eclipse ..................................................................... 1.2.3 ABAP Development Tools ........................................ Eclipse Workbench ................................................................ 1.3.1 Workspaces ............................................................. 1.3.2 Projekte ................................................................... 1.3.3 Views ....................................................................... 1.3.4 Perspektiven ............................................................ Das erste Programm .............................................................. 1.4.1 ABAP-Projekt anlegen .............................................. 1.4.2 »Hallo Welt« ............................................................ 1.4.3 Feature Explorer ......................................................

21 22 27 52 52 53 54 58 58 59 62 62 63 63 66 69

Funktionen der ABAP Development Tools .......................... 71 2.1 2.2

2.3

2.4

Demoszenario ....................................................................... 71 Mit Entwicklungsobjekten arbeiten ....................................... 73 2.2.1 Pakete anlegen ........................................................ 74 2.2.2 ABAP-Dictionary-Objekte anlegen ........................... 77 2.2.3 Funktionsbausteine anlegen ..................................... 82 2.2.4 Klassen .................................................................... 86 2.2.5 ABAP-Programme erstellen ...................................... 92 Code-Vervollständigung ........................................................ 96 2.3.1 Einfache Code-Vervollständigung ............................. 97 2.3.2 Code-Vorlagen ......................................................... 98 Quelltext-Editor .................................................................... 104 2.4.1 Aufbau ..................................................................... 105 2.4.2 Lokale Änderungshistorie ......................................... 108

7

Inhalt

2.5 2.6 2.7

2.8

2.9

3

3.2

3.3 3.4

Testen ................................................................................... 3.1.1 ABAP-Testklassen .................................................... 3.1.2 Code Coverage ......................................................... 3.1.3 ABAP Test Cockpit ................................................... 3.1.4 Laufzeitanalyse ......................................................... Debugging ............................................................................. 3.2.1 Breakpoints setzen ................................................... 3.2.2 Debugger ................................................................. Systemmeldungen abonnieren ............................................... Refactoring ............................................................................

162 162 169 172 179 181 182 183 189 192

Web Dynpro ABAP in Eclipse .............................................. 199 4.1

8

109 112 114 117 118 124 126 127 134 137 137 143 145 147 150 153 153 156 158 160

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben .................................................... 161 3.1

4

2.4.3 Lineale und Markierungen ....................................... 2.4.4 Navigation ............................................................... 2.4.5 Textbearbeitung ....................................................... 2.4.6 Quelltext formatieren ............................................... Mit mehreren Ressourcen arbeiten ........................................ Verwendungsnachweis .......................................................... Quick Fix und Quick Assist .................................................... 2.7.1 Quick Fix ................................................................. 2.7.2 Quick Assist ............................................................. Arbeitsvorrat organisieren ...................................................... 2.8.1 Objekte finden ......................................................... 2.8.2 Lesezeichen ............................................................. 2.8.3 Aufgaben verwalten ................................................. 2.8.4 Quellcode-Links ....................................................... 2.8.5 Aufgabenverwaltung mit Mylyn ............................... Dokumentation ..................................................................... 2.9.1 Objekte dokumentieren ........................................... 2.9.2 Dokumentation anzeigen ......................................... 2.9.3 Dokumentation importieren ..................................... 2.9.4 ABAP Language Help ...............................................

Controller-Programmierung ................................................... 4.1.1 Kontext-Editor ......................................................... 4.1.2 Attribute .................................................................. 4.1.3 Methoden ................................................................

199 202 206 206

Inhalt

4.2

4.3 4.4

5

214 214 229 229 231

Datenbankzugriffe ............................................................... 235 5.1 5.2 5.3

6

Views und Windows .............................................................. 4.2.1 Views ....................................................................... 4.2.2 Windows ................................................................. Web-Dynpro-Applikationen .................................................. Floorplan Manager ................................................................

Data Preview ......................................................................... 235 SQL-Konsole ......................................................................... 239 Core Data Services ................................................................. 242

Erweiterungen der ABAP Development Tools .................... 249 6.1

6.2 6.3 6.4

6.5

6.6

Eclipse Rich Client Platform ................................................... 6.1.1 Plug-in-System in Eclipse ......................................... 6.1.2 Anatomie eines Plug-ins ........................................... Server-Komponente der ABAP Development Tools ................ Entwicklungsumgebung für Erweiterungen vorbereiten .......... Implementierungen im Backend (SAP NetWeaver AS ABAP) .................................................... 6.4.1 Resource Controller ................................................. 6.4.2 Resource-Application-Klasse .................................... Implementierungen im Frontend (Eclipse) ............................. 6.5.1 Abhängigkeiten ........................................................ 6.5.2 Verbindung zum Backend ........................................ 6.5.3 Datenaustausch ....................................................... Discovery Service ...................................................................

250 251 251 254 256 258 259 263 267 271 274 279 285

Anhang ...................................................................................... 289 A B C

Wegweiser durch die ABAP Development Tools ............................... 291 Literatur und weiterführende Informationsquellen ........................... 299 Autor ............................................................................................... 303

Index ...................................................................................................... 305

9

Vorwort 2

»Party with your code« – das war das Motto, mit dem im Juni 2012 eine neue Ära für die ABAP-Entwicklergemeinde begann. ABAP in Eclipse, die neue Entwicklungsumgebung für ABAP, stand nun endlich als Download zur Verfügung. Die Idee dazu wurde schon sehr viel früher geboren. Als ich 1999 bei SAP in der Basisentwicklung angefangen habe, war die Welt für den SAPEntwickler noch sehr überschaubar. Man hatte mit ABAP ein Programmierwerkzeug zur Hand, mit dem man auf recht einfache Art und Weise betriebswirtschaftliche Software erstellen konnte. Das Datenmodell wurde im Data Dictionary definiert. Im ABAP-Code programmierte man die betriebswirtschaftliche Logik und erstellte mittels Dynpro-Technologie das User Interface. Das alles war sehr gut integriert in der ABAP Workbench – oder der SE80, wie die meisten Entwickler diese Transaktion nennen. Die Anforderungen an betriebswirtschaftliche Anwendungen haben sich jedoch in den letzten Jahren sehr stark geändert. Der Anwender erwartet heute, dass er seine Anwendungen zusätzlich zum Browser auch auf seinem Smartphone und Tablet-PC bedienen kann. Ein weiterer Trend ist, dass analytische und transaktionale Anwendungen immer mehr zusammenwachsen. Dadurch entstehen im Falle von Massendaten ganz neue Herausforderungen an die Software. Zudem werden immer mehr Anwendungen durch cloudbasierte Services und Anwendungen ergänzt. Was bedeutet das für das Programmiermodell, mit dem die Anwendungen erstellt werden? Moderne Benutzeroberflächen werden mittels HTML5 und JavaScript erstellt. Um performante Anwendungen mit Massendaten zu entwickeln, verwendet man die In-Memory-Datendank SAP HANA und programmiert die Logik zur Datenbeschaffung mit Hilfe der nativen Datenbanksprache SQLScript. Zudem möchte man die SAP-Anwendungen mit CloudLösungen kombinieren, die zu einem Großteil in Java codiert sind. Für den Anwendungsentwickler bedeutet dies, dass er eine Vielzahl neuer Technologien und Softwareparadigmen verstehen und einsetzen muss. Jedoch wird ABAP weiterhin als zentrale Programmiersprache für die betriebswirtschaftliche Anwendungslogik dominieren. Wie wäre es, wenn all diese neuen Paradigmen zusammen mit ABAP in einer einheitlichen Entwicklungsumge-

11

Vorwort

bung angeboten würden? Mit Eclipse stellen wir Ihnen genau diese einheitliche Entwicklungsumgebung zur Verfügung. Worin aber liegen die Vorteile von Eclipse gegenüber der ABAP Workbench, und was müssen Sie als alter ABAP-Hase wissen, um in der neuen Welt zurechtzukommen? Genau auf diese Fragen wird Ihnen dieses Buch die Antworten geben. So bringt Eclipse eine gewisse Arbeitsweise mit sich, die für den erfahrenen SE80-Experten zuerst einmal etwas Umstellungsaufwand bedeutet. Aber nach kurzer Zeit werden Sie sehen, dass der Aufwand sich lohnt und sich Ihre Entwicklereffizienz steigern wird. Daher richtet sich dieses Buch auch speziell an die Umsteiger von der SE80 zu Eclipse. Ich wünsche Ihnen nun viel Spaß beim Lesen dieses Buches und beim Erkunden der neuen ABAP-Entwicklungswerkzeuge. Glauben Sie mir, Sie werden den Umstieg nicht bereuen. Thomas Fiedler Product Owner ABAP in Eclipse

12

Einleitung 3

Jede Reise beginnt mit einem einzigen Schritt. Meistens ist dieser Schritt oder vielmehr die Entscheidung zu diesem Schritt das eigentlich Beschwerliche. Die Entscheidung, den ersten Schritt in Richtung ABAP-Entwicklung in Eclipse zu tun, haben Sie mit dem Erwerb dieses Buches bereits getroffen. Ich will versuchen, Sie auf Ihrem Weg ein Stück zu begleiten und Ihnen zu helfen, den einen oder anderen Stein aus dem Weg zu räumen, damit Sie nicht schon zu Beginn ins Straucheln geraten. Der Einstieg in eine neue Technologie oder ein neues Werkzeug kann mitunter mühselig sein, angefangen beim Einrichten der Umgebung über die ersten kleinen Tests bis hin zur produktiven Nutzung. Beim Verfassen dieses Buches habe ich versucht, möglichst praxisnah vorzugehen, d. h., ein Entwicklungsprojekt-Beispiel wird Sie durch das komplette Buch begleiten und Ihnen die wichtigsten Aspekte der ABAP Development Tools for SAP NetWeaver (ADT) vorstellen. In Schritt-für-Schritt-Anleitungen führe ich Sie dabei durch die Menüs und Einstellungen von Eclipse, möchte Ihnen allerdings nicht nur das reine Vorgehen vermitteln, sondern Ihnen auch die Bedienkonzepte von Eclipse erläutern, denn schließlich lautet das Motto der ADT Develop like never before und nicht The same procedure as every year. Die ABAP Workbench ist seit Jahren das Werkzeug, um Programme in ABAP zu entwickeln. Sie ist das tägliche Handwerkszeug und vielen ABAP-Entwicklern mittlerweile ans Herz gewachsen. In der großen weiten Welt der Softwareentwicklung dominieren allerdings Entwicklungsumgebungen wie Microsoft Visual Studio, NetBeans IDE oder Eclipse. Sie glänzen mit ausgefeilten Refactoring-Funktionen, Code Assistance oder der Integration von Ticket- und Versionierungssystemen. Auch wenn sich in den letzten Jahren viel getan hat und die ABAP Workbench um viele Funktionen – wie die Code-Vervollständigung – reicher geworden ist, wird die ABAP Workbench von vielen Nicht-ABAP-Entwicklern eher belächelt und nicht als moderne Entwicklungsumgebung angesehen. Warum ist das so? Und warum fühlen sich IDEs (Integrierte Entwicklungsumgebungen/Integrated Development Environments) wie Eclipse, die inzwischen ebenfalls bereits über zehn Jahre auf dem Buckel haben, moderner an?

13

Einleitung

Zum einen liegt das sicherlich am Bedienparadigma des SAP GUIs, das der ABAP Workbench zugrunde liegt. Die ABAP Workbench existiert nur im Rahmen der Grenzen, die das SAP GUI vorgibt. Was für warenwirtschaftliche Transaktionen durchaus Sinn ergibt, ist für eine Entwicklungsumgebung eher unpraktisch. Wenn Sie glücklicher Besitzer eines hochauflösenden Monitors sind, wissen Sie wahrscheinlich, was ich meine. Sie haben zwar sehr viel Platz, können in der ABAP Workbench jedoch trotzdem nicht mehr anzeigen. Ich bin zeitweise dazu übergegangen, meinen Monitor hochkant zu verwenden, um dadurch zumindest einen größeren Quelltextausschnitt betrachten zu können. Eclipse als Entwicklungsumgebung wurde von der SAP SE lange Zeit nur in Form des SAP NetWeaver Developer Studiosverwendet. Allerdings wird das Developer Studio eher dazu genutzt, auf Java basierende Anwendungen zu entwickeln, z. B. in den Bereichen Web Dynpro Java, Portal-Entwicklung oder Business Process Management. Im Jahr 2009 begann die SAP SE damit, auch die ABAP-Entwicklung auf die Eclipse-Plattform zu bringen, das erste Release der ABAP Development Tools erblickte 2012 das Licht der Welt. Im Gegensatz zum Developer Studio wurde damit kein eigenständiges, losgelöstes Produkt erstellt, sondern die ADT wurden als Plug-ins (Erweiterung) für die Eclipse-Plattform entwickelt. Aus diesem Grund profitiert die Entwicklungsumgebung nach wie vor von offiziellen Updates der Eclipse Foundation und droht nicht, nach und nach zu veralten. Die ADT unterstützen immer die aktuelle und die letzte Version von Eclipse (siehe auch SAP-Hinweis 1856565), d. h. derzeit Eclipse 4.4 und 4.3. Zudem macht das Plug-in-System von Eclipse ein Update der ADT sehr einfach. Derzeit werden regelmäßig neue Versionen veröffentlicht, die neue Features und Verbesserungen mitbringen. Die Verbindung von den ADT-Plug-ins zum Application Server wird über eine RFC-Schnittstelle hergestellt. Diese Schnittstelle basiert auf dem RESTArchitekturprinzip, das in Abschnitt 6.2, »Server-Komponente der ABAP Development Tools«, näher erläutert wird. Entwicklungsobjekte werden demnach wie Ressourcen betrachtet, die auf dem Server abgelegt und wieder abgerufen werden können. Durch die lose Kopplung zwischen Eclipse-Client und Backend müssen die Versionen der ADT und des SAP NetWeaver AS ABAP nicht genau aufeinander abgestimmt sein. Erfüllt der Server die Mindestvoraussetzung, können die ADT auch in höheren Versionen verwendet werden. Gegebenenfalls stehen dann einige Funktionen nicht zur Verfügung, es kommt aber nicht zu Inkonsistenzen, die schlimmstenfalls zu spät

14

Einleitung

bemerkt werden könnten. Diese lose Kopplung zwischen den Systemen sorgt zudem dafür, dass Innovationen aufseiten des Clients viel einfacher umzusetzen sind, denn das Frontend ist prinzipiell austauschbar. Eclipse ist nur für die Aufbereitung der Anzeige zuständig. In welcher Form dies geschieht, spielt für die Funktionalität im Backend keine Rolle. Beim Arbeiten mit ABAP-Quellcode müssen Sie sich um die Details, etwa die Schnittstellen und REST-Services, allerdings keine Gedanken machen. Entwicklungsobjekte werden im Eclipse-Client angezeigt, als arbeiteten Sie mit lokalen Daten.

Eclipse-Plattform ABAP Development Tools

UI Development Toolkit for HTML5

SAP Mobile Platform Tools

SAP HANA Tools

ABAP-Plattform

SAP NetWeaver AS ABAP

Datenbank Relationale Datenbank

SAP HANA

Abbildung 1 Einordnung der ABAP Development Tools in die Eclipse-Werkzeuge von SAP

Die ABAP Development Tools befinden sich auf der Eclipse-Plattform in guter Gesellschaft. Viele der neueren Technologien, die von der SAP SE in den letzten Jahren veröffentlicht wurden, werden nicht mehr direkt im SAP GUI entwickelt. Dies betrifft vor allem Tools, deren Entwicklungsobjekte nicht unmittelbar durch den ABAP-Server verwaltet werden. In vielen dieser Fälle ist Eclipse die Entwicklungsumgebung. Dies betrifft z. B. das UI Development Toolkit for HTML5 (SAPUI5), die SAP Mobile Platform Tools und die SAP HANA Tools. Alle diese Werkzeuge wurden als Plug-ins für die Eclipse-Umgebung umgesetzt, d. h., Sie greifen nur bei Bedarf auf den SAP NetWeaver Application Server bzw. die Datenbank zu (siehe Abbildung 1). Praktischerweise können diese Werkzeuge alle parallel in derselben Eclipse-

15

Einleitung

Installation betrieben und gleichzeitig genutzt werden, Sie benötigen also keine unterschiedlichen Entwicklungstools in Ihrem System. Aktuell decken die ABAP Development Tools einen großen Teil des Funktionsumfangs der ABAP Workbench und damit verbundener Transaktionen ab. Es ist möglich, ABAP-Programme, Funktionsbausteine und Klassen in Eclipse zu entwickeln, außerdem bieten die ADT auch Unterstützung bei der Web-Dynpro-ABAP-Entwicklung. Aufgrund der riesigen Menge der Entwicklungsobjekte wurden jedoch noch nicht alle Entwicklungswerkzeuge der ABAP Workbench in Eclipse umgesetzt. Teilweise beruht diese Entscheidung auf dem geringen Mehrwert einer bestimmten Umsetzung in Eclipse, etwa bei Aktionen, die Sie nur einmalig ausführen (wie das Anlegen eines Pakets). Langfristig werden diese Funktionen aber wohl auch durch Assistenten in Eclipse abgebildet werden. Ebenfalls nicht in Eclipse umgesetzt ist der Screen Painter. Dies ist auch bis auf Weiteres nicht geplant, da die klassischen Dynpro-Transaktionen nicht mehr als Schlüsseltechnologie eingestuft werden. Neue Oberflächen sollten stattdessen in Web Dynpro ABAP oder SAPUI5 umgesetzt werden (http:// scn.sap.com/docs/DOC-41321). Auch fehlt derzeit noch die Unterstützung der Anlage von ABAP-DictionaryObjekten. Dieses Manko soll allerdings in nächster Zeit behoben werden. ABAP-Dictionary-Objekte sollen zukünftig mit einer eigenen Sprache (Data Definition Language, DDL) angelegt werden. Derzeit bieten die ADT schon die Möglichkeit, Views (im Kontext von Core Data Services) auf diese Weise zu definieren (siehe Abschnitt 5.3). Als nächster Meilenstein ist die Anlage von Strukturen über DDL geplant. Dass die Anlage von Dictionary-Objekten noch nicht in Eclipse erfolgt, heißt allerdings nicht, dass Sie keine Möglichkeit haben, aus Eclipse heraus z. B. eine Domäne anzulegen. Die ABAP Development Tools verfügen über eine SAP-GUI-Integration innerhalb des Eclipse-Clients, über die Sie wie gewohnt die althergebrachten Werkzeuge einsetzen können. Warum sollten Sie als Entwickler sich mit den ABAP Development Tools beschäftigen, auch wenn diese noch nicht den kompletten Funktionsumfang der ABAP Workbench bieten? Dafür gibt es mehrere Gründe: Der vielleicht unbefriedigendste ist: Die Strategie der SAP SE sieht vor, Eclipse als Entwicklungsplattform weiter zu forcieren. In den vergangenen Jahren wurde bereits sehr viel in die Entwicklung Eclipse-basierter Tools investiert, und es ist abzusehen, dass dies auch in nächster Zeit so bleiben wird. Zwar wird die

16

Einleitung

ABAP Workbench auch in Zukunft weiterhin unterstützt werden, der Treiber für Innovationen wird allerdings in Eclipse liegen. Dies hängt sicherlich auch damit zusammen, dass Eclipse eine größere Flexibilität bei der Implementierung von Benutzeroberflächen für Entwicklungszwecke bietet, d. h., Ihnen als Anwender kann eine viel bessere Handhabung (User Experience) geboten werden. Das SAP GUI ist dazu gedacht, Geschäftsanwendungen abzubilden, und zusätzlich können Sie damit Anwendungen entwickeln. Eclipse hingegen ist auf die Entwicklungsaufgaben ausgelegt. Richtig eingesetzt, erlaubt dieses Tool, sehr fokussiert und effektiv zu arbeiten. Dies erfordert allerdings, dass Sie sich auf die Bedienkonzepte von Eclipse einlassen und nicht versuchten, Dinge genauso anzugehen wie bisher. Dieses Buch soll Ihnen dabei helfen, genau dies zu tun. Ein weiterer Grund für die Erfolgsgeschichte von Eclipse ist die Erweiterbarkeit, für die die Plattform von Grund auf gestaltet ist. Die Erweiterungsmöglichkeiten beginnen mit dem Hinzufügen einer eigenen Funktion ins Hauptmenü und können über die Erstellung eigener grafischer Editoren bis hin zur Erstellung einer vollkommen neuen Applikation reichen (siehe auch Kapitel 6, »Erweiterungen der ABAP Development Tools«). Es ist zu hoffen, dass über die Jahre eine Vielzahl interessanter Projekte, wie etwa SAPlink (http:// eclipse.saplink.org), entstehen, die neue Erweiterungen für die SAP-Entwicklung bereitstellen und helfen, den Entwickleralltag zu vereinfachen. Dieser Entwicklung ist sicherlich die gute Community sehr zuträglich. Sowohl im Umfeld des Eclipse-Ökosystems (https://eclipse.org/community/) als auch im Umfeld der ABAP Development Tools (http://scn.sap.com/ community/abap/eclipse) gibt es eine Vielzahl engagierter Entwickler. Abseits der offiziellen Dokumentationen finden sich im SAP Community Network (SCN) regelmäßig Blogs und Tutorials zu allen möglichen ADT-Themen. Neue Funktionen der aktuellen Releases werden in der Community als Blog veröffentlicht und können dort kommentiert und diskutiert werden. Damit ist es jedem ABAP-Entwickler möglich, auf die Weiterentwicklung und Verbesserung der ADT aktiv einzuwirken oder Hilfe zu finden, falls es Probleme gibt.

Voraussetzungen Auch wenn Sie bisher keinen Zugriff auf die notwendige Backend-Infrastruktur (SAP NetWeaver Application Server ABAP) haben, müssen Sie dieses Buch nicht enttäuscht beiseitelegen. Über Cloud Services ist es relativ ein-

17

Einleitung

fach, einen eigenen Server aufzusetzen und zu Testzwecken zu nutzen. Damit können Sie den Beispielen im Buch von Anfang bis Ende folgen, ohne auf zusätzliche Hardware angewiesen zu sein. Sie benötigen lediglich Ihren Rechner und einen Internetzugang.

Zielgruppe Das Buch richtet sich primär an Umsteiger und Neugierige, die bisher in der Welt der ABAP Workbench unterwegs waren und nun die Welt der ABAPEntwicklung in Eclipse kennenlernen möchten (oder müssen). In den Beispielen werden daher keine ABAP-Sprachkonstrukte besprochen, wenn es sich nicht um eine Besonderheit in den ADT handelt. Alle Beispiele sind vollständig und leicht verdaulich. Daher kann dieses Buch für Sie auch interessant sein, wenn Sie den umgekehrten Weg gehen und den Einstieg in die ABAP-Welt über Eclipse suchen. Allerdings würde ich Ihnen in diesem Fall parallel die Lektüre einer Einführung in ABAP empfehlen (siehe Anhang B, »Literatur und weiterführende Informationsquellen«). Aufbau dieses Buches Je nach Ihren Anforderungen und Ihrer Ausgangssituation kann es sinnvoll sein, gezielt bestimmte Teile des Buches zu lesen. Kapitel 1, »Die ersten Schritte – »›Hallo ADT‹«, behandelt die Einrichtung der Entwicklungsumgebung. Starten Sie auf der grünen Wiese und haben weder die ADT auf Ihrem Rechner installiert noch einen passenden Server zur Verfügung, sollten Sie dieses Kapitel von Anfang an lesen. Abschnitt 1.1 behandelt das Einrichten des Backend-Systems. Verfügen Sie über einen Zugang zum AS ABAP, brauchen Sie nur Abschnitt 1.1.1 zu lesen. Wenn Sie eine solche Instanz in der Amazon Cloud anlegen möchten, sollten Sie Abschnitt 1.1.2, »Amazon Web Services«, studieren. Die Installation und Einrichtung von Eclipse auf Ihrem eigenen Rechner wird in Abschnitt 1.2 beschrieben. Anschließend werden Sie an das erste »Hallo-Welt«-Beispiel herangeführt. Verfügen Sie über eine voll eingerichtete Landschaft, inklusive Eclipse mit installierten ADT, sind Abschnitt 1.3, »Eclipse Workbench«, und Abschnitt 1.4, »Das erste Programm«, der richtige Einstieg für Sie. Nach der erfolgreichen Einrichtung der ADT möchten Sie wahrscheinlich etwas mehr tun können, als nur ein »Hallo Welt« auf den Bildschirm zu zaubern. Kapitel 2, »Funktionen der ABAP Development Tools«, beschreibt, wie Sie Entwicklungsobjekte anlegen und bearbeiten können, und führt Sie

18

Einleitung

in die Funktionen der Development Tools ein. Dabei werden sowohl Funktionen beschrieben, die Sie wahrscheinlich aus der ABAP Workbench kennen, als auch Funktionen, die neu durch Eclipse hinzugekommen sind. Qualitätssicherung, Fehlerbehebung und kontinuierliche Verbesserung spielen bei der Softwareentwicklung eine große Rolle. Kapitel 3, »Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben«, liefert daher Informationen über die wichtigsten Werkzeuge und Funktionen in diesem Bereich. ABAP-Unit-Tests und Profiling Tools sind in die ADT hervorragend integriert. Auch das – relativ neue – ABAP Test Cockpit steht Ihnen in Eclipse zur Verfügung. Informationen zum Debugging finden Sie in Abschnitt 3.2. Wenn Sie bisher Refactoring-Funktionen in der ABAP Workbench vermisst haben, sollte Abschnitt 3.3, »Systemmeldungen abonnieren«, für Sie interessant sein. Hier wird beschrieben, welche Funktionen die ADT in diesem Bereich bieten und wie Sie diese anwenden können. Sprach man von Web Dynpro und Eclipse, war bisher meist von Web Dynpro Java die Rede. Mit den ABAP Development Tools ist es nun auch endlich möglich, Web Dynpro ABAP in Eclipse zu entwickeln. Kapitel 4 gibt einen Überblick darüber, was hier möglich ist und wie es geht. Die Datenbank ist zentraler Bestandteil eines SAP-Systems. Daher verbringen viele Entwickler fast genauso viel Zeit mit dem Data Browser wie mit dem Quelltext-Editor. In Kapitel 5, »Datenbankzugriffe«, lernen Sie, wie Sie die Data Preview in Eclipse nutzen und über die SQL-Konsole Anfragen an die Datenbank stellen können. Das Kapitel gibt Ihnen zudem eine Antwort auf die Frage, was sich hinter dem Begriff Core Data Services verbirgt und was Sie damit in Eclipse tun können. Ein sehr spannendes Thema ist die Erweiterbarkeit von Eclipse. Die ADT wurden mit einem öffentlich verfügbaren Software Development Kit (SDK) ausgestattet, dessen Verwendung zur Erstellung eines Plug-ins in Kapitel 6, »Erweiterungen der ABAP Development Tools«, anhand eines Beispiels beschrieben wird. Im Anhang finden Sie neben einer Liste mit weiterführender Literatur auch einen Funktionswegweiser. Vermissen Sie eine bestimmte Funktion aus der ABAP Workbench in den Development Tools, dann schauen Sie doch einmal hier nach! Außerdem habe ich hier alle relevanten Shortcuts und Funktionen zusammengetragen und beschrieben. In hervorgehobenen Informationskästen sind in diesem Buch Inhalte zu finden, die wissenswert und hilfreich sind, aber etwas außerhalb der eigentli-

19

Einleitung

chen Erläuterung stehen. Damit Sie die Informationen in den Kästen sofort einordnen können, haben wir die Kästen mit Symbolen gekennzeichnet: Die mit diesem Symbol gekennzeichneten Tipps geben Ihnen spezielle Empfehlungen, die Ihnen die Arbeit erleichtern können. In Kästen, die mit dem Pfeilsymbol gekennzeichnet sind, finden Sie Informationen zu weiterführenden Themen oder wichtigen Inhalten, die Sie sich merken sollten. Dieses Symbol weist Sie auf Besonderheiten hin, die Sie beachten sollten. Es warnt Sie außerdem vor häufig gemachten Fehlern oder Problemen, die auftreten können. Nun bleibt mir nicht viel mehr übrig, als Ihnen viel Spaß auf Ihrer Entdeckungsreise zu wünschen. Daniel Schön

20

Aller Anfang ist schwer. Die erste Hürde bei der Verwendung einer neuen Anwendung oder eines neuen Werkzeugs ist meist bereits die Einrichtung. Dieses Kapitel soll Ihnen über diese erste Hürde hinweghelfen, sodass der ABAP-Entwicklung mit Eclipse nichts mehr im Wege steht.

1

Die ersten Schritte – »Hallo ADT«

Der erste große Brocken, der sich Ihnen bei der Entwicklung mit den ABAP Development Tools for SAP NetWeaver (ABAP in Eclipse) in den Weg stellt, ist das Einrichten einer lauffähigen Umgebung. In diesem Kapitel erfahren Sie, welche Voraussetzungen erfüllt sein müssen, damit Sie ABAP in Eclipse nutzen können. Danach führe ich Sie – abhängig von Ihrer Systemlandschaft – durch den Einrichtungsprozess. Abschließend implementieren wir ein kurzes ABAP-Testprogramm in der neuen Umgebung, um den Erfolg unserer Arbeit zu verifizieren. Als Belohnung sollte dann am Ende ein freundliches »Hallo Welt« auf Ihrem Bildschirm erscheinen.

1.1

Backend-System

Sie fragen sich vielleicht, weshalb ein Buch zur ABAP-Entwicklung in Eclipse mit einem Abschnitt über die Backend-Systeme beginnt. Das liegt daran, dass ABAP eine serverseitig ausgeführte Sprache ist, woran sich auch mit den ABAP Development Tools for SAP NetWeaver (im Folgenden kurz ADT) nichts ändert. Zwar entwickeln wir mit einem Werkzeug, das lokal auf dem Rechner installiert ist, das ABAP-Coding wird aber nach wie vor auf dem Server ausgeführt. Falls Sie hoffen, mit der Installation des Tools wäre seine Einrichtung erledigt, muss ich Sie leider enttäuschen: Das ist leider nicht so. Um ABAP in Eclipse einsetzen zu können, wird mindestens SAP NetWeaver 7.3/7.31 SP 4 oder höher benötigt. Einige Features sind sogar erst ab SAP NetWeaver Release 7.4 verfügbar. Wenn dies der Fall ist, mache ich Sie in diesem Buch mit einem entsprechenden Hinweis darauf aufmerksam. Eine Übersicht über die Verfügbarkeit der verschiedenen Features finden Sie unter:

21

1

Die ersten Schritte – »Hallo ADT«

http://scn.sap.com/community/abap/eclipse/blog/2013/06/05/adt-featureavailability-matrix-for-as-abap-releases. Sollten Sie nicht über den Zugang zu solch einem System verfügen, müssen Sie dieses Buch nicht enttäuscht beiseitelegen und Ihre Ambitionen, Eclipse einzusetzen, bis zum nächsten Upgrade begraben. Stattdessen empfehle ich Ihnen, Abschnitt 1.1.2, »Amazon Web Services«, zu lesen. Dort wird beschrieben, wie Sie Ihren eigenen Test-Server einrichten und betreiben können, ohne zusätzliche Hardware oder neue Lizenzen erwerben zu müssen. Sollten Sie jedoch einen aktuellen SAP NetWeaver Application Server (AS) zur Verfügung haben, beginnen Sie damit, die Erfüllung der Systemvoraussetzungen zu prüfen. Folgendes muss gegeben sein, damit Sie mit den ADT arbeiten können: 왘 Alle Benutzer, die die ADT nutzen wollen, haben die entsprechenden Rollen und Berechtigungen. 왘 Alle benötigten Services des Internet Communication Frameworks (ICF) sind aktiv. Es kann auch notwendig sein, bestimmte Profilparameter zu pflegen, um etwa Logon-Tickets für das Single Sign-on verarbeiten zu können. Sollten diese für Sie eine Rolle spielen, finden Sie die Beschreibung der entsprechenden Einstellungen unter: http://help.sap.com/download/netweaver/adt/SAP_ADT_Configuration_Guide_ Backend_en.pdf Prüfen wir nun schrittweise das System und richten die erforderlichen Rollen und Services ein.

1.1.1

Den SAP NetWeaver Application Server einrichten

Es bedarf einiger Vorbereitung, bevor die ABAP Development Tools mit dem SAP NetWeaver AS kommunizieren können und Sie in der Lage sind, ABAP in Eclipse zu erforschen. Doch keine Angst; die Anpassungen, die Sie vornehmen müssen, halten sich in Grenzen. Sicherheitsrelevante Einstellungen Im Folgenden werden Rollen angepasst und Services auf dem AS aktiviert. Dies sind sicherheitsrelevante Einstellungen. Sollten Sie sich unsicher sein, ob Sie diese Einstellungen vornehmen dürfen oder die Rechte dazu besitzen, nehmen Sie mit Ihrer Basisadministration Kontakt auf.

22

Backend-System

Benutzerrollen pflegen Ihr SAP-Benutzer benötigt die entsprechenden Berechtigungen, um die ADT nutzen zu können, also um ADT-Ressourcen aufzurufen, bestimmte Transaktionen zu starten und den Server per Remote Function Call (RFC) kontaktieren zu dürfen. Die dafür erforderlichen Berechtigungsobjekte sind in Tabelle 1.1 aufgeführt. Rolle

Beschreibung

S_ADT_RES

Zugriff auf ADT-Ressourcen

S_RFC

RFC-Zugriff auf den Server

S_TCODE

Transaktionscodes ausführen

Tabelle 1.1 Berechtigungsobjekte zu den ADT

Die genaue Konfiguration dieser Berechtigungsobjekte können Sie bei Bedarf dem genannten Configuration Guide entnehmen. Sie müssen diese Berechtigungen zum Glück nicht von Hand pflegen. Um einen Benutzer für ABAP in Eclipse freizuschalten, genügt es, ihm eine Rolle zuzuordnen. Die Rolle SAP_BC_DWB_ABAPDEVELOPER beinhaltet alle notwendigen Berechtigungen für einen ABAP-Entwickler (sowohl für das SAP GUI als auch für ABAP in Eclipse). Die Rolle SAP_BC_DWB_WBDISPLAY enthält die gleichen Berechtigungsobjekte. Allerdings erhalten Sie damit nur Leseberechtigungen, ohne die Möglichkeit, Objekte zu bearbeiten. Statten wir nun einen Benutzer mit den entsprechenden Berechtigungen aus: 1. Melden Sie sich über das SAP-Logon (

) an Ihrem SAP NetWeaver AS an.

2. Wechseln Sie in die Benutzerpflege (Transaktion SU01). 3. Geben Sie den Benutzernamen ein, dem Sie die Berechtigungen zuordnen möchten, und starten Sie die Benutzerpflege im Ändern-Modus. 4. Wechseln Sie auf die Registerkarte Rollen, und prüfen Sie die zugeordneten Rollen (siehe Abbildung 1.1). Falls noch nicht geschehen, ordnen Sie dem Benutzer die Rolle SAP_BC_DWB_ABAPDEVELOPER zu. Tragen Sie dazu den Rollennamen in die Spalte Rolle ein, und bestätigen Sie mit (¢). Profile Prüfen Sie auf der Registerkarte Profile, ob dem Benutzer schon (höherwertige) Berechtigungen wie SAP_ALL zugeordnet wurden. In diesem Fall ist es nicht notwendig, die Rolle SAP_BC_DWB_ABAPDEVELOPER zuzuordnen.

23

1.1

1

Die ersten Schritte – »Hallo ADT«

Abbildung 1.1 Benutzerrollen pflegen

Damit verfügt Ihr Benutzer über ausreichende Berechtigungen, um die ABAP Development Tools verwenden zu können.

Services aktivieren Wäre der SAP NetWeaver AS ein vollständig abgekapseltes System, wäre es für externe Tools wie Browser, Smartphones oder Entwicklungsumgebungen wie Eclipse problematisch, mit dem System zu kommunizieren. Zum Glück gibt es aber Mechanismen, die eine Kommunikation über externe Funktionsaufrufe oder Standard-Internet-Protokolle wie HTTP, HTTPS oder SMPT ermöglichen. Das Internet Communication Framework (ICF) ist der zentrale Dreh- und Angelpunkt, wenn es um die Kommunikation über die Internet-Protokolle geht. Die ADT machen sowohl vom ICF als auch von Remote Function Calls Gebrauch. Zugriffe über das ICF werden über sogenannte ICF-Services an einen Service-Handler weitergeleitet. Diese Services kanalisieren die Anfragen, die aus dem Netzwerk an den SAP-Server gestellt werden. Aus Sicherheitsgründen ist es (gerade bei einem Produktivsystem) empfehlenswert, nur Services aktiv zu schalten, die auch wirklich in Benutzung sind. Daher werden Services zunächst inaktiv ausgeliefert und müssen nachträglich manuell aktiviert werden. ABAP in Eclipse benötigt das ICF unter anderem zur Anzeige von Hilfetexten. Auch bei der Entwicklung von Komponenten in Web Dynpro ABAP sollten bestimmte Services aktiv sein. Um die Dokumentation für ABAP in Eclipse verfügbar zu machen, sind folgende Schritte notwendig: 1. Melden Sie sich über das SAP-Logon ( 2. Wechseln Sie in Transaktion SICF.

24

) an Ihrem System an.

Backend-System

3. Überspringen Sie den ersten Bildschirm mit (F8), um in die Servicehierarchie zu gelangen. Alternativ können Sie über die in Abbildung 1.2 dargestellte Maske auch nach einem Service bzw. einem Servicepfad suchen.

Abbildung 1.2 Suche nach ICF-Services in Transaktion SICF

4. Navigieren Sie durch die Servicehierarchie zum Knoten /default_host/sap/ bc/abap.

Abbildung 1.3 ICF-Service aktivieren

25

1.1

1

Die ersten Schritte – »Hallo ADT«

5. Aktivieren Sie hier die beiden Services docu und toolsdocu. Klicken Sie dazu mit der rechten Maustaste auf den jeweiligen Service, und wählen Sie Service aktivieren aus dem Kontextmenü (siehe Abbildung 1.3). 6. Wiederholen Sie die Schritte 4 und 5 für die Services docu bzw. toolsdocu unter dem SICF-Pfad /default_host/sap/public/bc/abap. Damit stehen die Dokumentationsservices zur Verfügung. Planen Sie, später auch in Web Dynpro ABAP zu entwickeln, empfiehlt es sich, die dazu benötigten Services ebenfalls direkt zu aktivieren. Web-Dynpro-Services Die Web-Dynpro-Services werden – mit einer Ausnahme – nicht nur von den ADT genutzt. Sie benötigen diese Services auch, wenn Sie Web Dynpro ABAP in der ABAP Workbench entwickeln.

Gehen Sie beim Aktivieren der Web-Dynpro-Services genauso vor wie bei der Aktivierung der Dokumentationsservices. Starten Sie Transaktion SICF, und wechseln Sie in die Servicehierarchie. Aktivieren Sie nacheinander folgende Services und Knoten: 왘 /default_host/sap/bc/webdynpro (Aktivieren Sie nur den Knoten selbst, nicht die Unterknoten!) 왘 /default_host/sap/public/bc/ur 왘 /default_host/sap/public/bc/icons 왘 /default_host/sap/public/bc/icons_rtl 왘 /default_host/sap/public/bc/webicons 왘 /default_host/sap/public/bc/pictograms 왘 /default_host/sap/public/bc/webdynpro/* (Aktivieren Sie sämtliche Unterknoten über den Button

.)

왘 /default_host/sap/public/myssocntl Zu Entwicklungszwecken werden zusätzlich folgende Services benötigt: 왘 /default_host/sap/public/bc/webdynpro/viewdesigner 왘 /default_host/sap/bc/wdvd/ Darüber hinaus aktivieren Sie zu Konfigurations- und Analysezwecken folgende Services. Diese Services sollten nur im Entwicklungssystem aktiv sein: 왘 /default_host/sap/bc/webdynpro/sap/configure_application 왘 /default_host/sap/bc/webdynpro/sap/configure_component

26

Backend-System

왘 /default_host/sap/bc/webdynpro/sap/wd_analyze_config_appl 왘 /default_host/sap/bc/webdynpro/sap/wd_analyze_config_comp 왘 /default_host/sap/bc/webdynpro/sap/wd_analyze_config_user Weitere Informationen Eine aktuelle Liste der notwendigen Services finden Sie auch im SAP-Hinweis 1088717 und in der SAP-Hilfe unter: http://help.sap.com/saphelp_nw70ehp1/ helpdata/de/46/d28dfa34bb12bee10000000a1553f7/content.htm

Zu guter Letzt fehlt nur noch der Service für den View Designer in Eclipse: /default_host/sap/bc/webdynpro/sap/wdy_aie_vd_preview Dieser sollte ebenfalls nur im Entwicklungssystem aktiv geschaltet werden. Damit ist die Konfiguration des Backends abgeschlossen. Sie können nun mit der Einrichtung von Eclipse beginnen. Wie Sie dazu vorgehen, ist in Abschnitt 1.2, »Installation und Einrichtung der Entwicklungsumgebung«, beschrieben.

1.1.2

Amazon Web Services

Nicht jeder Entwickler kann sich glücklich schätzen, Zugriff auf einen brandneuen SAP NetWeaver AS 7.4 und eine SAP-HANA-Datenbank zu haben. Und die wenigsten Unternehmen werden diese Investition tätigen, um den »Spieltrieb« eines einzelnen Technikpioniers zu befriedigen. Zum Glück gibt es im Zeitalter des Cloud Computings eine flexible und kostengünstige Alternative zu einem On-Premise-System. Cloud-Lösungen bieten eine einfache Möglichkeit, ohne Hardware und ohne großen administrativen Aufwand Rechenleistung bei Bedarf abzurufen. Voraussetzung ist, dass Sie Zugriff auf die entsprechende Software haben bzw. dass der Cloud-Anbieter fertige Lösungen bereithält. On-Premise und On-Demand Beim Betreiben eines Servers gibt es Unterschiede hinsichtlich des Nutzungsmodells. Im Umfeld von SAP-Systemen tauchen dabei häufig die Begriffe On-Demand und On-Premise auf. 왘 On-Demand-Server werden meistens von Dienstleistern angeboten. Sie werden nur bei Bedarf aktiviert. Das den Service in Anspruch nehmende Unternehmen hat in der Regel keinen direkten Zugriff auf die Hardware. 왘 Von On-Premise spricht man, wenn das System mit eigener Hardware im Unternehmen betrieben wird. Die Software, die auf dem System läuft, wird entweder gekauft oder entsprechend lizenziert.

27

1.1

1

Die ersten Schritte – »Hallo ADT«

Die SAP SE stellt glücklicherweise kostenlos eine Reihe von Test- und Evaluierungssystemen bereit. Damit ist es Unternehmen oder Einzelpersonen möglich, die neusten Entwicklungen zu testen, ohne unmittelbar Lizenzen erwerben zu müssen. Diese Systeme werden allerdings nicht mehr als Download angeboten. Stattdessen werden sie als Cloud-Lösung in der SAP Cloud Appliance Library (CAL, https://cal.sap.com) bereitgestellt. So kann jeder Entwickler auch ohne hauseigenes System ABAP in Eclipse oder andere neue Features ausgiebig testen. Die SAP SE übernimmt das Hosting der Systeme nicht selbst. Stattdessen wird ein externer Cloud-Provider hinzugezogen. Derzeit werden nur Amazon und Microsoft (Azure) unterstützt. Im Folgenden betrachten wir lediglich die Verwendung der Amazon Web Services (AWS). Das beschriebene Vorgehen lässt sich aber auch auf die Microsoft-Lösung anwenden. Zusätzliche Kosten Die SAP SE stellt die Testsysteme kostenlos zur Verfügung, allerdings fallen durch die Amazon Web Services Gebühren an. Diese variieren je nach Systemanforderungen, Verfügbarkeit und Zugriffszone. Eine Preisliste finden Sie auf der Homepage der AWS unter https://aws.amazon.com/de/pricing/.

Der Amazon Web Service, den wir nutzen, heißt Amazon Elastic Compute Cloud (Amazon EC2). Amazon EC2 bietet die Möglichkeit, virtuelle Rechnerumgebungen – sogenannte Instanzen – im Handumdrehen zu erstellen und zu betreiben. Es steht bereits eine große Anzahl an Vorlagen (Templates) für Instanzen zur Verfügung. Diese Amazon Machine Images (AMIs) beinhalten das Betriebssystem für die neue Instanz sowie zusätzliche Software. Hardwareparameter wie die Anzahl der Prozessoren, die Größe des Hauptspeichers oder die Netzwerkanbindung können je nach Bedarf und Anforderung des AMIs gewählt werden. Instanzen können in verschiedenen Regionen betrieben werden. Für unser Szenario spielen diese Regionen erst mal eine untergeordnete Rolle. Versuchen Sie für den Moment, immer in einer Region zu arbeiten. Dies vereinfacht Ihnen die Entwicklung anfangs ungemein. Amazon stellt eine Webkonsole zur Verwaltung der Web Services bereit (siehe Abbildung 1.4). Diese ist über https://console.aws.amazon.com erreichbar. Zudem gibt es die Möglichkeit, den AWS-Account über Kommandozeilen-Tools (Command-Line Interface, CLI) zu administrieren. Für unsere Zwecke reicht die Weboberfläche allerdings vollkommen aus.

28

Backend-System

Abbildung 1.4 AWS-Management-Konsole

Leider ist das Einrichten eines SAP NetWeaver AS auch als virtuelle AWS-Instanz nicht mit einem Klick erledigt. Damit dem Start mit ABAP in Eclipse trotzdem nichts im Weg steht, nehmen wir die notwendigen Schritte gemeinsam vor. Es gibt mehrere Wege, eine eigene Instanz (Virtual Appliance) in der Cloud einzurichten. Wundern Sie sich daher nicht, wenn Sie beim Stöbern im Netz Tutorials finden, die einen gänzlich anderen Ansatz verfolgen. Ich habe versucht, einen pragmatischen Ansatz zu wählen, um eine sichere und trotzdem einfache Lösung aufzubauen. Ich möchte Sie an dieser Stelle aber auf die sehr gute und ausführliche Dokumentation zur SAP Cloud Appliance (https://cal.sap.com/res/doc_de/frameset.htm) sowie zu den Amazon Web Services (http://docs.aws.amazon.com/gettingstarted/latest/ awsgsg-intro/gsg-aws-tutorials.html#getstarted-account) verweisen.

29

1.1

1

Die ersten Schritte – »Hallo ADT«

AWS-Account Im Folgenden wird davon ausgegangen, dass Sie über einen AWS-Account verfügen. Falls dies nicht der Fall ist, können Sie diesen einfach unter https://aws.amazon.de anlegen. Zur Registrierung wird zwingend eine gültige Kreditkarte benötigt, über die später die Abrechnung erfolgen wird. Durch die Registrierung selbst entstehen zunächst noch keine Kosten.

Um den SAP NetWeaver AS in der Cloud verfügbar zu machen, sind drei Schritte notwendig, die in den folgenden Abschnitten erläutert werden.

Erstellen eines Benutzers für die Amazon Web Services Die AWS liefern nur die Infrastruktur, um ein Image des SAP-Systems zu betreiben. Die Inbetriebsetzung (Deployment) erfolgt durch die SAP Cloud Appliance Library (CAL). Damit die CAL für Sie die Arbeit des Aufsetzens übernehmen kann, benötigt sie Zugriff auf die AWS-Schnittstellen (APIs). Dieser Zugriff erfolgt über einen AWS-Benutzer, der über die entsprechenden Berechtigungen verfügt. Sie fragen sich jetzt vielleicht, wozu wir noch mal einen Benutzer anlegen müssen, denn im Rahmen der Anmeldung für die AWS haben Sie ja schon einen AWS-Benutzer erstellt, Ihre Daten angegeben und sogar Ihre Kreditkartennummer hinterlegt. Genau aus diesem Grund benötigen wir noch einen weiteren Benutzer, der nicht alles über Sie weiß. Sie geben ja auch nicht einfach dem Nachbarsjungen Ihre Kreditkarte, damit er für Sie eine Tüte Chips kaufen geht. Bestenfalls geben Sie ihm den passenden Betrag in bar. Genauso wenig sollten Sie Ihren AWS-Benutzer angeben, wenn Sie sich über einen Drittanbieter für die AWS-Schnittstellen authentifizieren wollen. Stattdessen verwenden Sie das AWS Identity and Access Management (IAM), über das Sie einen IAM-Benutzer anlegen und ihn mit den passenden Rechten ausstatten können. Führen Sie folgende Schritte aus, um einen neuen IAM-Benutzer zu erstellen: 1. Rufen Sie die URL https://console.aws.amazon.com/iam/ in einem Browser auf, um direkt zur IAM-Konsole zu gelangen. 2. Wählen Sie aus dem Menü Groups und dann Create New Group, um eine neue Benutzergruppe anzulegen (siehe Abbildung 1.5). 3. Vergeben Sie einen Namen für die neue Gruppe (z. B. ADT_Developers), und bestätigen Sie mit Next Step (siehe Abbildung 1.6).

30

Backend-System

Abbildung 1.5 Neue Benutzergruppe in der IAM-Konsole anlegen

Abbildung 1.6 Gruppennamen vergeben

4. Wählen Sie unter Select Policy Template die Berechtigung Amazon EC2 Full Access (siehe Abbildung 1.7). Bestätigen Sie Ihre Auswahl mit Select. 5. Sie haben nun noch die Möglichkeit, die Policy anzupassen. Dies ist aber nicht notwendig. Fahren Sie mit Next Step fort.

31

1.1

1

Die ersten Schritte – »Hallo ADT«

6. Sie bekommen nun noch einmal die Zusammenfassung Ihrer neuen Gruppe. Legen Sie diese mit Create Group an.

Abbildung 1.7 Berechtigung wählen

Zusätzlich zur Gruppe müssen wir nun noch einen Benutzer anlegen: 1. Wählen Sie in der IAM-Management-Konsole den Eintrag Users in der Navigationsleiste auf der linken Seite (siehe Abbildung 1.5) und anschließend Create New User, um den Anlage-Prozess zu starten. 2. Geben Sie den Namen Ihres neuen Benutzers (ADT_Developer) an. An dieser Stelle könnten auch mehrere Benutzer erstellt werden. Bestätigen Sie mit Create. 3. Nun haben Sie die Möglichkeit, sich die Zugangsdaten Ihres Benutzers anzeigen zu lassen. Mit Show User Credentials werden Ihnen die Access Key ID sowie der Secret Access Key (siehe Abbildung 1.8) angezeigt. Merken Sie sich diese Daten. Beides benötigen Sie später noch.

32

Backend-System

Abbildung 1.8 Zugangsdaten des neuen IAM-Benutzers

Access Key ID und Secret Access Key Mittels Access Key ID und Secret Access Key ist es möglich, sich gegenüber der AWSSchnittstelle zu authentifizieren. Mit den Rechten, die Sie dem neuen Benutzer zuteilen, kann dieser so EC2-Instanzen erstellen und starten. Dies kann Kosten verursachen. Sorgen Sie also dafür, dass Ihre Zugangsdaten nicht in falsche Hände geraten!

4. Wählen Sie den Button Download Credentials (siehe Abbildung 1.8), um ein Schlüsselpaar herunterzuladen. Das Schlüsselpaar benötigen Sie, falls Sie sich direkt an Ihrem SAP-Server anmelden möchten. 5. Beenden Sie den Anlage-Prozess mit Close. Schlüsseldatei sicher aufbewahren Bewahren Sie die Schlüsseldatei gut und sicher auf. Sie können sie nicht noch einmal herunterladen. Es ist nur möglich, ein neues Schlüsselpaar zu generieren. Seien Sie sich zudem dessen bewusst, dass diese Datei einem Passwort entspricht. Behandeln Sie sie deshalb auch so.

Damit haben Sie eine neue Benutzergruppe mit einem neuen Benutzer angelegt. Darüber hinaus haben Sie die Zugangsdaten für diesen Benutzer erhalten. Der Benutzer muss nun noch der Gruppe hinzugefügt werden. Zudem konnten Sie im Assistenten nur eine Berechtigung auswählen. Sie benötigen aber noch drei weitere, die wir nun der Benutzergruppe hinterlegen. 1. Navigieren Sie in der IAM-Konsole über Groups zur Gruppenübersicht (siehe Abbildung 1.9).

33

1.1

1

Die ersten Schritte – »Hallo ADT«

Abbildung 1.9 Navigation zur Gruppenübersicht

2. Klicken Sie auf die Gruppe ADT_Developers und anschließend auf den Button Add User to Group (siehe Abbildung 1.10).

Abbildung 1.10 Die Gruppe ADT_Developers

3. Sie erhalten eine Liste aller verfügbaren Benutzer. Setzen Sie eine Markierung bei dem Benutzer, den Sie zuvor angelegt haben, und klicken Sie auf Add Users, um diesen Benutzer hinzuzufügen.

34

Backend-System

4. Klicken Sie nun in der Gruppenübersicht auf den Button Attach Another Policy. Sie gelangen zu einer Auswahlliste. Wählen Sie hier nacheinander: 왘 Read Only Access 왘 Amazon VPC Full Access 왘 AWS Account Usage Report Access Damit ist der IAM-Benutzer eingerichtet und mit den notwendigen Berechtigungen ausgestattet.

Einrichten des Kontos für die SAP Cloud Appliance Als Nächstes kümmern wir uns um ein Konto für die SAP Cloud Appliance Library (CAL). Zunächst benötigen Sie dazu einen CAL-Benutzer. Anschließend müssen Sie Ihr CAL-Konto mit Ihrem AWS-Konto verknüpfen. 1. Rufen Sie die Seite http://cal.sap.com auf, und klicken Sie auf Anmelden. Falls Sie schon über einen CAL-Benutzer verfügen, geben Sie hier Ihre Zugangsdaten an. Andernfalls legen Sie über die Schaltfläche Jetzt registrieren einen neuen Benutzer an. Für die nächsten Schritte gehe ich davon aus, dass Sie über einen Benutzer verfügen und sich erfolgreich anmelden konnten. 2. Wechseln Sie auf die Registerkarte Konten (siehe Abbildung 1.11). Hier finden Sie eine Übersicht aller bereits angelegten Konten. Über ein Konto stellen Sie die Assoziation zum Cloud-Anbieter her – in unserem Fall Amazon. Wählen Sie Konto Anlegen, um fortzufahren.

Abbildung 1.11 Kontoübersicht der SAP Cloud Appliance

3. Vergeben Sie zunächst einen Namen und eine (optionale) Beschreibung für das neue Konto (siehe Abbildung 1.12). Fahren Sie mit Weiter fort.

35

1.1

1

Die ersten Schritte – »Hallo ADT«

Abbildung 1.12 Allgemeine Kontoinformationen

4. Als Nächstes wird die Anbindung zum Cloud-Anbieter konfiguriert. Wählen Sie Amazon Web Services aus. Dann benötigen Sie nämlich die Access Key ID und den Secret Access Key Ihres IAM-Benutzers. Diese geben Sie in die Felder Zugriffsschlüssel und Secret Key ein (siehe Abbildung 1.13). Das Feld Kostenzuordnung müssen Sie nicht ausfüllen. (Oder Sie treffen sich mit Ihrem Controller auf einen Kaffee, um zu erörtern, was Sie dort eintragen können.) 5. Springen Sie mit Weiter zur nächsten Seite.

Abbildung 1.13 Zugangsdaten zum Cloud-Anbieter angeben

6. Nun können Sie dem neuen Konto einen Benutzer zuordnen (siehe Abbildung 1.14). Falls Sie den CAL-Account gerade erst erstellt haben und diesen allein verwenden, müssen Sie hier nicht tätig werden. Ihr neu angeleg-

36

Backend-System

ter Benutzer ist automatisch Inhaber des Kontos und damit auch berechtigt, dieses zu verwenden. Bestätigen Sie mit Weiter.

Abbildung 1.14 Kontobenutzer dem Konto zuordnen

7. Sie können sich optional eine Kostenprognose erstellen lassen (siehe Abbildung 1.15). Dadurch können Sie in etwa abschätzen, wie teuer es sein wird, eine Instanz in der Cloud zu betreiben. Der hier errechnete Wert ist allerdings nur eine grobe Richtschnur. Mit Weiter gelangen Sie zur letzten Seite.

Abbildung 1.15 Kostenprognose

8. Zuletzt wird Ihnen die Zusammenfassung Ihrer Einstellungen präsentiert. Überprüfen Sie die Richtigkeit Ihrer Angaben, und bestätigen Sie die Anlage des Kontos mit Fertigstellen.

37

1.1

1

Die ersten Schritte – »Hallo ADT«

Kostengünstigste Regionen Die Kosten einer Cloud-Instanz hängen stark von der Region ab, in der sie betrieben wird. Da es sich bei unserer Cloud-Nutzung nicht um ein Hochverfügbarkeitsszenario handelt, bei dem niedrige Latenzzeiten eine wichtige Rolle spielen, empfehle ich Ihnen, sich bei der Auswahl der Region primär nach den Preisen zu richten. Derzeit gehört die Region us-east-1 zu den preisgünstigsten Regionen. Über die Preisprognose können Sie sich aber selbst einen Eindruck davon verschaffen, welche aktuell die günstigste Alternative ist.

In der Liste der Konten sollte nun Ihr neu erstelltes Konto auftauchen. Damit sind wir nun so weit, eine Lösungskonfiguration auszuwählen und in die Cloud zu bringen.

Auswahl und Aktivierung der virtuellen Umgebung SAP CAL stellt eine Bibliothek sogenannter Lösungen bereit. Bei einer Lösung handelt es sich um ein fertiges Paket, das aus einem oder mehreren Amazon Machine Images besteht. Diese beinhalten verschiedene SAP-Komponenten, z. B. einen SAP NetWeaver AS ABAP, die als Instanz in der Amazon Cloud betrieben werden können. Die notwendigen Schritte zur Installation und Konfiguration der Instanzen nimmt Ihnen SAP CAL dabei größtenteils ab. Eine vollständige Liste der verfügbaren Lösungen finden Sie unter https:// cal.sap.com auf der Registerkarte Lösungen. In der Liste finden Sie sowohl kostenlose als auch kostenpflichtige Lösungen. Über die Auswahlbox Ansicht können Sie die Auswahl auf die kostenlosen Einträge eingrenzen. Alternativ erhalten Sie auf der Seite des SAP Community Networks (SCN, http:// scn.sap.com/docs/DOC-41566) eine gekürzte Liste mit Entwicklungs- bzw. Evaluierungssystemen sowie einigen Links zu ergänzenden Informationen. Verfügbare Lösungen Die folgende Anleitung bezieht sich auf die Lösungen, die zum Zeitpunkt der Veröffentlichung dieses Buches zur Verfügung standen. Die Bezeichnung der Lösungen kann sich durch Aktualisierungen ändern. Sie benötigen in jedem Fall eine Lösung mit SAP NetWeaver Application Server ABAP. SAP HANA als Datenbank ist nicht zwingend erforderlich, eine SAP-MaxDB-basierte Lösung kommt mit einer deutlich kleiner dimensionierten und damit günstigeren Amazon-Instanz aus. Allerdings können Sie damit unter Umständen einige der hier besprochenen Funktionen nicht in vollem Umfang nutzen.

Beginnen wir mit dem Einrichten unseres SAP NetWeaver Application Servers.

38

Backend-System

1. Suchen Sie in der Liste der Lösungen z. B. den Eintrag SAP Application Server ABAP 7.4 SP8 & Business Warehouse on SAP HANA 1.0 SP07 [Developer Edition], und wählen Sie Jetzt testen (siehe Abbildung 1.16).

Abbildung 1.16 Übersicht der verfügbaren Lösungen

Aufbau der Lösung Die gewählte Lösung besteht aus zwei Instanzen, die in der Amazon Cloud installiert werden: 왘 der Backend-Instanz, die den Server inklusive SAP HANA beinhaltet 왘 einer (deutlich kleiner dimensionierten) Microsoft-Windows-Frontend-Instanz. Dabei handelt es sich um einen vorkonfigurierten Arbeitsplatz, mit dem Sie sofort loslegen können, zu arbeiten. Verwenden Sie eine andere Lösung, kann es sein, dass die Frontend-Instanz fehlt. Der Anleitung sollten Sie trotzdem folgen können.

2. Lesen und bestätigen Sie die allgemeinen Geschäftsbedingungen. Die Anzeige vor dem Eintrag sollte nun auf Grün springen, und die Aktionstaste ändert ihren Text in Aktivieren. Aktivieren nicht möglich Sollte die Schaltfläche Aktivieren wie in Abbildung 1.16 grau bleiben, gibt es Probleme mit dem Konto, bzw. es wurde gar kein Konto angelegt. Sobald die entsprechenden Informationen hinterlegt wurden, können Sie fortfahren.

39

1.1

1

Die ersten Schritte – »Hallo ADT«

3. Wählen Sie Aktivieren, um die Instanz mit dem Konto zu verknüpfen und den Deployment-Prozess freizuschalten. Die Bezeichnung des Links ändert sich in Instanz anlegen. Klicken Sie auf den Link, um mit der Anlage zu beginnen. 4. Hinterlegen Sie für Ihre Lösung wie in Abbildung 1.17 einen Namen und eine Beschreibung. Anschließend wählen Sie das Konto und die Region aus, in der die Instanzen betrieben werden sollen.

Abbildung 1.17 Allgemeine Eigenschaften definieren

5. Im Auswahlfeld Zugriff aus stehen Ihnen die Optionen Öffentliches Netzwerk und Unternehmensnetzwerk zur Verfügung. Der Einfachheit halber wählen Sie hier Öffentliches Netzwerk. Damit steht Ihr System allerdings offen im Internet. Über die Auswahl Statische IP-Adresse sorgen Sie zudem dafür, dass die Systeme immer über die gleiche Adresse erreichbar sind. Statische IP-Adresse Bei der Verwendung des öffentlichen Netzwerks ist es in unserem Fall zwingend notwendig, statische IP-Adressen zu verwenden. Das liegt daran, dass unsere Lösung aus zwei Instanzen besteht. Diese beiden Instanzen (genauer gesagt, die Frontend-Instanz mit dem Server) müssen miteinander kommunizieren. Würde sich die IP-Adresse bei jedem Neustart der Lösung ändern, müssten auf der FrontendInstanz auch jedes Mal verschiedene Einstellungen angepasst werden. Für die Reservierung einer statischen IP fallen allerdings zusätzliche Kosten bei Amazon an.

40

Backend-System

Virtual Private Cloud Grundsätzlich spricht nichts dagegen, einen Server öffentlich ins Netz zu stellen. Das macht viele Dinge gerade zu Anfang sehr viel einfacher. Allerdings sollten Sie sich darüber im Klaren sein, dass damit jeder diesen Server aus dem Internet erreichen kann. Das macht den Server zu einem potenziellen Angriffsziel. Alternativ können Sie eine Virtual Private Cloud (VPC) erstellen. Damit können Instanzen in einem privaten Bereich (ähnlich einem internen Netzwerk) betrieben werden, der von außen nicht direkt erreichbar ist. Der Zugriff erfolgt dann über einen VPN-Server mit einer einzelnen IP über einen einzelnen Port (einen sogenannten VPN-Tunnel). Die eigentlichen Server werden erst sichtbar, wenn man sich im VPN bzw. in der VPC befindet. Eine ausführliche Anleitung zum Betreiben der Lösungsinstanzen in einer VPC finden Sie unter http://scn.sap.com/docs/DOC-46629.

6. Im Schritt Virtual Machine konfigurieren haben Sie die Möglichkeit, die Parameter der zu erstellenden Instanzen anzupassen (siehe Abbildung 1.18). Zunächst können Sie die Dimensionierung der Maschine wählen. Für das Frontend steht nur die Größe m1.medium zur Verfügung. Für das Backend wählen wir die empfohlene Größe m2.4xlarge. Den Volume-Typ belassen wir für unser Entwicklungssystem ebenfalls auf Standard.

Abbildung 1.18 Virtuelle Maschine konfigurieren

41

1.1

1

Die ersten Schritte – »Hallo ADT«

7. Anschließend können Sie die Zugriffspunkte zu Ihren Systemen konfigurieren. Dies sind die Ports, die für die Instanzen nach außen freigegeben werden. Da wir uns im öffentlichen Netz bewegen, empfehle ich Ihnen, so wenige Ports wie möglich freizugeben. Zwangsläufig benötigt werden Port 3389 für das Frontend (Remote Desktop Port) sowie Port 22 (SSH) für den Server. Wechseln Sie mit Weiter zum nächsten Schritt. 8. Wählen Sie nun ein Lösungspasswort. Dieses Passwort dient später dazu, eine Verbindung zur Lösung herzustellen, und ist das (Initial-)Passwort für den SAP NetWeaver AS. Merken Sie sich daher auch dieses Passwort gut. Geben Sie das gewählte Passwort zweimal ein, und fahren Sie mit Weiter fort. 9. Sie können nun auswählen, ob die Instanz automatisch gestartet und gestoppt werden soll. Das ist insbesondere dann sinnvoll, wenn der Server täglich genutzt wird. In unserem Beispiel wählen wir aber die manuelle Variante. Kosten durch laufende Instanzen Vergessen Sie nicht, die Instanz zu stoppen, wenn sie nicht benötigt wird. Amazon rechnet die Instanzen nach Betriebsdauer ab, nicht nach tatsächlicher Benutzung. Eine laufende Instanz kostet auch laufend Geld.

10. Sie erhalten noch einmal eine (unverbindliche) Hochrechnung der Kosten pro Stunde und Woche (basierend auf der Annahme, dass die Lösungsinstanz nicht gestoppt wird). Fahren Sie mit Weiter fort. 11. Sie erhalten nun eine Zusammenfassung Ihrer Angaben. Mit einem Klick auf Fertigstellen starten Sie die Installation der Lösungsinstanz. Der Initialisierungsprozess der Instanzen wird durch ein kleines grünes Symbol ( ) in der Liste der Lösungsinstanzen angezeigt. Dieser Prozess kann ca. 40 Minuten in Anspruch nehmen – genug Zeit, um die angebotene Dokumentation zu studieren oder den versprochenen Kaffee mit dem Controller trinken zu gehen. Sobald die Lösungsinstanz bereit ist, verschwindet die kleine Uhr auf dem grünen Statussymbol. Sie können nun am Frontend testen, ob die Einrichtung funktioniert hat.

Virtual Appliance einrichten und testen Auf unserer Frontend-Instanz läuft Windows als Betriebssystem. Zudem sind das SAP Logon Pad sowie das SAP HANA Studio bereits vorinstalliert und

42

Backend-System

eingerichtet. Auf die Instanz kann per Remote Desktop zugegriffen werden. Sollten Sie sich von einem Windows-System aus anmelden, können Sie einfach die mitgelieferte Remote Desktop Connection ( ) verwenden, um sich mit der Frontend-Instanz zu verbinden. Sie finden sie im Startmenü unter Zubehör bei Ausführung der Datei mstsc.exe ((œ) + (R)). Für Mac OS X steht im Mac App Store die Verbindung Microsoft Remote Desktop gratis zur Verfügung. Linux bietet mehrere Open-Source-Varianten wie rdesktop (http:// www.rdesktop.org/) oder FreeRDP (http://www.freerdp.com/). Lösungen ohne Frontend-Instanz Einige der kleineren Lösungen werden ohne Frontend-Instanz ausgeliefert. In diesem Fall steht Ihnen leider auch keine vorinstallierte Arbeitsumgebung zur Verfügung, sondern Sie können nur lokal auf Ihrem Rechner arbeiten. Wie Sie Ihren Rechner einrichten müssen, wird im Abschnitt »Entwicklungssystem lokal verwenden« beschrieben. Die hier aufgelisteten Schritte können Sie auch mit einer lokalen SAP-GUI-Installation ausführen. Lesen Sie dazu zuerst den Abschnitt »Entwicklungssystem lokal verwenden«.

Verbinden wir uns nun mit unserer Lösungsinstanz: 1. Stellen Sie sicher, dass Server und Frontend aktiviert wurden. Dies ist der Fall, wenn das grüne Symbol ( ) vor dem Eintrag in der Instanzliste erscheint. 2. Klicken Sie auf den Namen der Lösungsinstanz, um zur Detailseite zu wechseln. Notieren Sie sich die IP-Adresse Ihrer Frontend-Instanz (siehe Abbildung 1.19).

Abbildung 1.19 Frontend-IP ermitteln (IPs wurden ausgetauscht)

43

1.1

1

Die ersten Schritte – »Hallo ADT«

3. Starten Sie Ihren Remote-Desktop-Client, und geben Sie die IP-Adresse des SAP-Frontends ein. Starten Sie die Sitzung, indem Sie auf den Button Verbinden klicken. 4. Geben Sie folgende Zugangsdaten ein: 왘 Benutzer: Administrator 왘 Passwort: Bei dem Lösungspasswort handelt es sich um das Passwort, das Sie bei der Anlage der Instanz in der SAP CAL vergeben haben. Sie sollten nun den Desktop Ihrer SAP-Frontend-Instanz sehen. Als Nächstes überprüfen Sie die Verbindung zum Backend-Server und installieren eine Mini-SAP-Lizenz, um den SAP NetWeaver AS nutzen zu können. Registrierung als SAP-Entwickler Sollten Sie vor der Installation der Lizenz versuchen, mit dem Entwicklungsbenutzer ein Objekt anzulegen, werden Sie gebeten, den Benutzer als Entwickler bei SAP zu registrieren. Nachdem Sie die Lizenz eingespielt haben, ändert sich die Installationsnummer des Servers. Für diese Installationsnummer ist der Benutzer DEVELOPER bereits registriert, sodass Sie direkt mit der Entwicklung loslegen können.

1. Starten Sie das SAP Logon Pad ( ) auf der Frontend-Instanz. Wählen Sie den Eintrag A4H – Developer Edition, und starten Sie die Verbindung per Doppelklick. 2. Auf dem Logon-Bildschirm geben Sie folgende Anmeldedaten ein: 왘 Mandant: 000 왘 Benutzer: DDIC 왘 Passwort: Starten Sie Transaktion SLICENSE. 3. Markieren und kopieren Sie den Hardwareschlüssel mit (Strg) + (C) aus dem Feld Active Hardware Key (siehe Abbildung 1.20). 4. Öffnen Sie die URL http://www.sap.com/minisap in Ihrem Browser, und füllen Sie das Formular aus (siehe Abbildung 1.21). Sie benötigen einen gültigen SCN-Benutzer, um eine Lizenz zu beantragen. Falls Sie nicht über einen Benutzer verfügen, registrieren Sie sich unter http://scn.sap.com/.

44

Backend-System

Abbildung 1.20 Transaktion SLICENSE

5. Im Bereich Systeminfo wählen Sie zuerst die System-ID des Systems, das Sie registrieren möchten, aus. In unserem Fall ist dies das System A4H. Anschließend geben Sie den Hardwareschlüssel ein, den Sie aus Transaktion SLICENSE kopiert haben. 6. Schließlich beantragen Sie den Lizenzschlüssel, indem Sie auf Senden klicken. Der Lizenzschlüssel wird an die angegebene E-Mail-Adresse gesendet. Dies kann einige Minuten dauern. 7. Haben Sie den Lizenzschlüssel erhalten, können Sie ihn auf dem Backend einspielen. Laden Sie dazu die Lizenzdatei auf die Frontend-Instanz. 8. Wechseln Sie dann wieder in das SAP GUI, und starten Sie Transaktion SLICENSE (siehe Abbildung 1.20). Klicken Sie auf die Schaltfläche Install, und wählen Sie die Lizenzdatei. Der Server sollte die Installation mit der Erfolgsmeldung 1 SAP license key(s) successfully installed. quittieren. 9. Überprüfen Sie nun, ob das System korrekt freigeschaltet wurde. Wechseln Sie dazu in Transaktion SECSTORE, und nehmen Sie einen Check vor, indem Sie die Taste (F8) drücken.

45

1.1

1

Die ersten Schritte – »Hallo ADT«

Abbildung 1.21 Beantragen einer Mini-SAP-Lizenz

10. Ihnen wird eine Liste mit den Ergebnissen des Laufs angezeigt. Alle Einträge sollten nun wie in Abbildung 1.22 mit einer grünen Ampel gekennzeichnet sein. 11. Sie können sich nun vom SAP GUI abmelden oder sich weiter im System umschauen. Auf dem Server sind die in Tabelle 1.2 aufgelisteten Mandanten und Benutzer vorhanden. Alle Benutzer sind initial mit dem Lösungspasswort angelegt worden. Sie sollten dieses Passwort aus Sicherheitsgründen für alle Benutzer ändern.

46

Backend-System

Abbildung 1.22 Ergebnis der Systemprüfung in Transaktion SECSTORE

Mandant

Benutzer

000

SAP* DDIC

001

SAP* DDIC DEVELOPER (BWDEVELOPER)

Tabelle 1.2 Benutzer des Testsystems

Der Benutzer DEVELOPER ist so eingerichtet, dass Sie mit ihm sofort auf dem Mandanten 001 entwickeln können, d. h., es ist keine weitere Registrierung oder Ähnliches notwendig. Er verfügt zudem über das Profil SAP_ALL, er ist auf dem Server also mit vollen Berechtigungen ausgestattet.

Entwicklungssystem lokal verwenden Zwar ist es sehr praktisch, dass bei der Developer Edition des SAP NetWeaver AS auch eine Frontend-Instanz angelegt wird, da Sie so einfach ohne Installationen auf dem eigenen Rechner loslegen können. Allerdings ist es oft angenehmer, direkt auf dem eigenen PC – mit allen installierten Programmen und ohne durch die Remote-Verbindung begründete Verzögerung – zu arbeiten. Daher kümmern wir uns in diesem Abschnitt darum, das Entwicklungssystem für unseren lokalen Rechner einzurichten. Dieser Schritt ist

47

1.1

1

Die ersten Schritte – »Hallo ADT«

optional, prinzipiell können Sie auf der Frontend-Instanz auch weiter per Remote Desktop arbeiten. Frontend-Instanz beenden Sollten Sie sich dazu entscheiden, lokal zu arbeiten, können Sie die Frontend-Instanz zukünftig nach dem Start direkt wieder über die Elastic Cloud Computing Console (https://console.aws.amazon.com/ec2) beenden oder nur den BackendServer in der AWS-Konsole starten.

Zunächst benötigen Sie ein SAP GUI auf Ihrem Rechner. Sollten Sie noch nicht über eine solche Installation verfügen, finden Sie die notwendigen Installationsdateien auf der Frontend-Instanz auf dem Laufwerk D:/. Sie können diese z. B. über die Remote-Desktop-Verbindung herunterladen. Im Folgenden gehe ich davon aus, dass Sie ein funktionsfähiges SAP GUI zur Verfügung haben. Lösungen ohne Frontend-Instanz Sollten Sie als Lösung SAP NetWeaver AS 7.4 on SAP MaxDB gewählt haben, wurde nur das Linux-Image initialisiert. In diesem Fall finden Sie die Installationsdateien des SAP GUIs im Verzeichnis /sapmnt//custom/. Um an die Daten zu gelangen, können Sie WinSCP (http://winscp.net/) oder ein vergleichbares Programm verwenden. Alternativ steht die aktuelle Version des SAP GUIs auch im SAP Marketplace zum Download zur Verfügung.

Nun müssen Sie sich darum kümmern, dass die Backend-Instanz von Ihrem lokalen Rechner aus erreichbar ist. Derzeit ist der allgemeine Zugriff auf den SAP-Server nur auf den SSH-Port 22 beschränkt. Vollen Zugriff hat nur die Frontend-Instanz. Eine Übersicht über die freigegebenen Ports erhalten Sie in der SAP Cloud Appliance Library in den Details zu Ihrer Lösungsinstanz auf der Registerkarte Virtual Machine. Der Eintrag 0.0.0.0/0 in der Spalte IPBereich gibt übrigens an, dass alle IP-Adressen Zugriff auf das System haben. Eine vergleichbare Übersicht steht Ihnen auch in der EC2-Konsole der Amazon Web Services zur Verfügung. Es wäre möglich, den SAP-Server vollständig nach außen hin zu öffnen. Allerdings ist dies aus sicherheitstechnischen Gründen bei einer öffentlich verfügbaren Instanz nicht sinnvoll. Daher geben wir nur die Ports frei, die wir benötigen, um den SAP NetWeaver AS in vollem Umfang nutzen zu können (siehe Abbildung 1.23).

48

Backend-System

Abbildung 1.23 Freigegebene Backend-/Frontend-Ports

VPC-Zugriff Sollten Sie den Server in einer Virtual Private Cloud betreiben, können Sie auch alle TCP-Ports (TCP = Transmission Transport Protocol) innerhalb dieser privaten Cloud freigeben. Der Zugriff von außen ist dann nur möglich, wenn eine Verbindung zum privaten Netz besteht.

Um den SAP NetWeaver AS auch von Ihrem lokalen Frontend aus erreichen zu können, konfigurieren Sie nun die entsprechenden Zugriffspunkte. 1. Öffnen Sie unter http://cal.sap.com die Übersicht Ihrer Instanzen, und wechseln Sie in den Detailbereich Ihrer ADT-Entwicklungsinstanz. 2. Wählen Sie Bearbeiten, um die Einstellungen Ihrer Instanz zu ändern. Sie müssen die Instanz dazu nicht stoppen. 3. Wechseln Sie zur Registerkarte Virtual Machine. 4. Fügen Sie unter Zugriffspunkte nacheinander die Einträge aus Tabelle 1.3 ein. Im Auswahlfeld Virtual Machine geben Sie dabei immer SAP Server an (siehe Abbildung 1.24). Die HANA-bezogenen Ports sind optional und müssen nur freigegeben werden, falls Sie planen, mit dem SAP HANA Studio zu arbeiten. Eine aktuelle Liste der benötigten Ports finden Sie übri-

49

1.1

1

Die ersten Schritte – »Hallo ADT«

gens auch in der Dokumentation (verfügbar unter https://cal.sap.com über den Link Benutzerleitfaden in den Details Ihrer jeweiligen Instanz). 5. Sichern Sie Ihre Änderungen. Protokoll

Port

IP-Bereich

Beschreibung

TCP

3200

0.0.0.0/0

SAP Dispatcher

TCP

3300

0.0.0.0/0

SAP Gateway

TCP

3601

0.0.0.0/0

Message Server

HTTP

8002

0.0.0.0/0

HTTP (HANA XS)

TCP

30215

0.0.0.0/0

externes HANA-SQL-Interface

HTTP

50000

0.0.0.0/0

AS-ABAP-HTTP-Port

HTTPS

50001

0.0.0.0/0

AS-ABAP-HTTPS-Port

TCP

50213

0.0.0.0/0

HANA Instance Agent

TCP

50214

0.0.0.0/0

HANA Instance Agent (SSL)

Tabelle 1.3 Zugriffspunkte des SAP-Servers

Abbildung 1.24 Ports hinzufügen

Unautorisierten Zugriff auf den Server vermeiden Falls Sie über eine feste IP oder einen festen IP-Bereich ins Internet gehen, können Sie auch diese IP bzw. diesen Bereich anstelle von 0.0.0.0/0 angeben. Das erschwert den unautorisierten Zugriff auf Ihren Server. Mit der in Tabelle 1.3 aufgelisteten Konfiguration hat jeder aus dem Internet Zugriff auf Ihren Server. (Es sei denn, der Server befindet sich in der VPC.)

50

Backend-System

Einige Funktionen der ADT benötigen den vollqualifizierten Hostnamen des SAP NetWeaver AS. Daher empfiehlt es sich, diesen in der Datei hosts zu hinterlegen. Hier können Sie Hostnamen einer IP-Adresse zuordnen. 1. Öffnen Sie die Datei hosts unter C:\Windows\System32\drivers\etc\hosts (bzw. etc/hosts unter Linux und OS X) mit Notepad oder einem Text-Editor Ihrer Wahl. Achten Sie darauf, den Editor im Administratormodus zu starten, da Sie die Datei hosts sonst unter Umständen nicht überschreiben dürfen. 2. Fügen Sie am Ende der Datei eine neue Zeile mit folgendem Inhalt an: 255.255.255.254 abapci abapci.dummy.nodomain

Ersetzen Sie 255.255.255.254 dabei durch die IP-Adresse Ihrer BackendInstanz. 3. Sichern Sie Ihre Änderungen. Sollte das Speichern fehlschlagen, überprüfen Sie, ob Ihr Virenscanner oder ähnliche Sicherheitsprogramme die Hostdatei vor Veränderungen schützt. Nun können Sie Ihre in der Cloud betriebene Server-Instanz wie einen Server in Ihrem Firmennetz verwenden. Um sich über das SAP Logon Pad anmelden zu können, erstellen Sie als Nächstes einen Eintrag: 1. Öffnen Sie das SAP Logon Pad. 2. Wählen Sie Neu ( ), und überspringen Sie die erste Seite mit Weiter. Geben Sie die Zugangsdaten für Ihr System ein (siehe Abbildung 1.25).

Abbildung 1.25 Neuen Systemeintrag erstellen

51

1.1

1

Die ersten Schritte – »Hallo ADT«

3. Haben Sie die Datei hosts angepasst, tragen Sie im Feld Anwendungsserver »abapci« ein, haben Sie den Dateinamen nicht geändert, tragen Sie die IP-Adresse Ihres SAP-Servers ein. Die Instanznummer lautet 00 und die System-ID A4H. Je nach gewählter Lösung kann die ID abweichen. Das Feld SAProuter-String kann leer bleiben. 4. Bestätigen Sie die Anlage des Systemeintrags mit Fertig stellen. 5. Wählen Sie den neu erstellten Eintrag aus der Liste der SAP-Systeme im SAP Logon Pad. Ihnen sollte nun die Anmeldemaske angezeigt werden. Melden Sie sich mit dem anfangs vergebenen Masterpasswort als Benutzer DEVELOPER am Mandanten 001 an.

1.2

Installation und Einrichtung der Entwicklungsumgebung

Sie sollten nun einen konfigurierten SAP NetWeaver AS zur Verfügung haben, entweder als virtuelle Instanz in der Cloud oder als On-PremiseLösung, etwa bereitgestellt von der unternehmensinternen IT-Abteilung. In beiden Fällen kann Eclipse als lokale Installation verwendet werden. Für die Instanz in der Amazon Cloud sind lediglich einige Vorarbeiten zu erledigen. Voraussetzungen Möchten Sie die ADT nutzen, müssen einige Voraussetzungen erfüllt sein: 왘 Sie verfügen über eine funktionsfähige Installation des SAP GUIs 7.30 (sowohl SAP GUI for Windows als auch Java). 왘 Sie haben Java Runtime Environment (JRE) mindestens in Version 1.6 installiert. 왘 Sie verfügen über Eclipse 4.3 (Kepler) oder 4.4 (Luna). Achten Sie darauf, dass Sie durchgehend nur die 32-Bit- oder 64-Bit-Versionen nutzen.

Falls Sie noch nicht über das SAP GUI verfügen, empfehle ich Ihnen, dieses jetzt zu installieren. Unter der Überschrift »Entwicklungssystem lokal verwenden« in Abschnitt 1.1.2, »Amazon Web Services«, finden Sie eine kurze Beschreibung.

1.2.1

Java Runtime Environment

Um die ADT nutzen zu können, wird mindestens JRE 1.6 vorausgesetzt. Ob Sie JRE installiert haben und welche Version auf Ihrem System vorliegt, finden Sie in einem Windows-Betriebssystem am einfachsten wie folgt heraus:

52

Installation und Einrichtung der Entwicklungsumgebung

1. Starten Sie die Kommandozeile. Dazu drücken Sie zunächst (œ) + (R). Im sich öffnenden Dialogfenster geben Sie cmd ein und bestätigen mit (¢). 2. Geben Sie den Befehl Java –version ein. Ihnen wird die aktuell installierte Version der JRE wie in Listing 1.1 ausgegeben: C:\>java –version java version "1.8.0_20" Java(TM) SE Runtime Environment (build 1.8.0_20-b26) Java HotSpot(TM) 64-Bit Server VM (build 25.20-b23, mixed mode) Listing 1.1 Abfrage der JRE-Version

Sollten Sie eine ältere JRE-Version 1.6 installiert haben, laden Sie sich die aktuelle Version unter http://www.oracle.com/technetwork/java/javase/downloads/index.html herunter, und installieren Sie diese. Falls das System meldet, dass der Befehl Java nicht bekannt ist, haben Sie wahrscheinlich gar kein JRE installiert. In diesem Fall laden Sie sich ebenfalls einfach die aktuelle Version herunter. Die Versionen sind weitestgehend abwärtskompatibel. Eine aktuellere Version ist in unserem Fall kein Problem. Ohnehin sollten Sie Ihre JRE-Version regelmäßig aktualisieren, um potenzielle Sicherheitslücken zu schließen. Unter Linux oder Mac OS X können Sie die JRE-Version über das Terminal genauso abfragen wie unter Windows. Geben Sie einfach »Java –version« ein, und prüfen Sie die Ausgabe.

1.2.2

Eclipse

Die Installation von Eclipse gestaltet sich glücklicherweise recht einfach. Es genügt, die passende Version aus dem Internet zu laden und auf Ihre Festplatte zu kopieren. Die Entwicklungsumgebung ist ohne weitere Installationsroutinen sofort einsatzfähig. Zur Drucklegung dieses Buches waren die aktuellsten unterstützten Versionen Eclipse Kepler und Luna. Ich zeige Ihnen die Einrichtung der ADT im folgenden Abschnitt am Beispiel von Eclipse Kepler. Die Schritte lassen sich aber auch für nachfolgende Eclipse-Versionen anwenden. Eclipse ist in hohem Maße anpassbar. Es existiert eine riesige Menge an Plugins, um die Entwicklungsumgebung an die verschiedensten Aufgaben anpassen zu können. Daher steht Eclipse auch nicht nur als ein Download-Paket zur Verfügung, sondern es wird in verschiedenen Ausprägungen angeboten, die jeweils auf ein bestimmtes Anwendungsfeld abgestimmt sind.

53

1.2

1

Die ersten Schritte – »Hallo ADT«

Auch die ADT sind letztlich nichts anderes als eine Erweiterung für Eclipse. Zwar gibt es kein fertiges ADT-Eclipse-Paket, aber Sie können sich einige Arbeit ersparen, indem Sie eine passende Eclipse-Version herunterladen. Für die ABAP-Entwicklung bietet sich das Paket Eclipse IDE for Java EE Developers an. Dieses können Sie unter http://www.eclipse.org/downloads/packages/ eclipse-ide-java-ee-developers/lunar herunterladen. Dieses Paket bringt alle Komponenten mit, die von den ADT-Plug-ins benötigt werden. Die heruntergeladene Datei ist ein einfaches ZIP-Archiv. Um Eclipse nutzen zu können, genügt es, das Archiv in ein beliebiges Verzeichnis zu entpacken. Um die Eclipse Workbench zu starten, müssen Sie lediglich die Datei Eclipse.exe aus dem Hauptordner ausführen. Aktuell unterstützte Versionen Aktuelle Informationen zu den Systemvoraussetzungen und den unterstützten Eclipse-Versionen finden Sie auf der Seite: https://tools.hana.ondemand.com/#abap.

1.2.3

ABAP Development Tools

Sie sollten nun die Standard-Eclipse-Installation zur Verfügung haben. Als Nächstes können Sie die ADT installieren. Dazu nutzen Sie die entsprechende Update-Seite von SAP und müssen in Eclipse lediglich die URL zu den Installationsdateien hinterlegen: 1. Öffnen Sie die Eclipse-Entwicklungsumgebung über die Datei Eclipse.exe (Button ). 2. Sie werden aufgefordert, einen Workspace, d. h. ein leeres Verzeichnis, auszuwählen (siehe Abbildung 1.26). Am besten legen Sie ein neues Verzeichnis an, das Sie für die Arbeit mit diesem Buch verwenden. Auf die Bedeutung der Workspaces komme ich in Abschnitt 1.3.1 noch einmal zurück. 3. Sind Sie mit einem neuen Workspace eingestiegen, wird Ihnen als Nächstes die Willkommensseite angezeigt. Um die Update-Seite einzutragen, wählen Sie im Menü Help 폷 Install New Software (siehe Abbildung 1.27). 4. Im folgenden Dialogfenster klicken Sie auf den Button Add.

54

Installation und Einrichtung der Entwicklungsumgebung

Abbildung 1.26 Auswahl eines Workspaces

Abbildung 1.27 Update-Seite in Eclipse angeben

5. Tragen Sie im Feld Location die URL https://tools.hana.ondemand.com/ kepler (für Eclipse in der Version 4.3) bzw. https://tools.hana.ondemand.com/luna (für Eclipse 4.4) und im Feld Name die Bezeichnung »ADT Update Site« ein. Bestätigen Sie Ihre Eingabe mit OK (siehe Abbildung 1.28).

55

1.2

1

Die ersten Schritte – »Hallo ADT«

Abbildung 1.28 Update-Seite hinzufügen

6. Wählen Sie im Auswahlfeld Work with den Eintrag ADT Update Site, den Sie gerade angelegt haben. In der Liste der verfügbaren Updates tauchen nun die Eclipse-Entwickler-Tools von SAP auf. 7. Markieren Sie den Eintrag ABAP Development Tools for SAP NetWeaver 폷 ABAP Core Development Tools (Entwickler Edition), und bestätigen Sie Ihre Auswahl mit Next. 8. Lesen und bestätigen Sie die angezeigten Lizenzbedingungen, und starten Sie die Installation über den Button Finish. 9. Eclipse lädt nun die benötigten Daten von der Update-Seite. Dabei werden Abhängigkeiten automatisch berücksichtigt und fehlende Plug-ins nachinstalliert. Die Installation der Plug-ins können Sie auch im Hintergrund ausführen lassen, d. h., währenddessen können Sie Eclipse weiterverwenden. 10. Um die Installation abschließen zu können, verlangt Eclipse einen Neustart. Dabei wird erneut der Workspace abgefragt. Sie können die Abfrage dieses Mal einfach mit OK bestätigen. Die Vorbelegung sollte der letzten Auswahl entsprechen.

56

Installation und Einrichtung der Entwicklungsumgebung

Abbildung 1.29 Funktionen der ABAP Development Tools auswählen

Damit ist die Installation der ADT abgeschlossen. Sie können den Willkommensbildschirm nun verlassen. Klicken Sie dazu auf das Symbol in der rechten oberen Ecke. Bei Problemen mit der Installation und Einrichtung der Eclipse-Entwicklungsumgebung ist die FAQ-Seite hilfreich. Diese finden Sie unter der Adresse http://scn.sap.com/docs/DOC-28325. Sprache Eclipse wird standardmäßig nur mit dem englischen Sprachpaket ausgeliefert. Die ABAP Development Tools sind allerdings mehrsprachenfähig. Da die ADT sich an der eingestellten Systemsprache orientieren, kommt es in Eclipse teilweise zu einem amüsanten Sprachmix. Sie haben zwei Möglichkeiten, dies zu umgehen: 왘 Sie können die ADT auf die Sprache Englisch umstellen. Öffnen Sie dazu die Datei Eclipse.ini im Eclipse-Hauptverzeichnis. Am Ende der Datei fügen Sie die Zeile -Duser.language=en hinzu.

57

1.2

1

Die ersten Schritte – »Hallo ADT«

왘 Sie können ein deutsches Sprachpaket installieren. Dieses erhalten Sie über das Eclipse Babel Project (https://eclipse.org/babel/). Sie können die Update-Seite http://download.eclipse.org/technology/babel/update-site/R0.12.1/kepler/ (bzw. /luna) aufrufen, um die Pakete zu installieren. Ich empfehle Ihnen, die ADT auf Englisch zu nutzen. Viele Begriffe sind ohnehin aus dem Englischen entliehen. Zudem vereinfacht dies die Kommunikation mit der Eclipse- und ADT-Community.

1.3

Eclipse Workbench

Bevor wir uns in die ABAP-Entwicklung in Eclipse stürzen, sollten wir uns die neue Arbeitsumgebung etwas genauer ansehen. Wer bisher die ABAP Workbench im SAP GUI gewohnt war, mag sich zunächst in der Eclipse Workbench etwas verloren vorkommen. Dies liegt unter anderem daran, dass Eclipse auf ganz anderen Konzepten beruht als die ABAP Workbench. Während im ABAP-Umfeld alle Entwickler, die am gleichen System entwickeln, auf der gleichen Code-Basis arbeiten, erfolgt die Entwicklung in der Eclipse Workbench normalerweise lokal. Daher stellen sich hier ganz andere Fragen als bei der Entwicklung auf einem Server. Als Entwickler müssen Sie sich darum kümmern, Ihre Quelltexte zu organisieren und wiederauffindbar zu machen. Die Laufzeitumgebung für die Entwicklungen ist bei der Verwendung von Eclipse nicht direkt gegeben, d. h., es ist notwendig, sich darum zu kümmern, dass Code kompiliert, gegebenenfalls deployed bzw. installiert und zu guter Letzt ausgeführt wird. Die in den folgenden Abschnitten beschriebenen Bedienkonzepte mögen zunächst etwas verwirrend und kompliziert wirken. Das meiste ist in der Handhabung aber durchaus intuitiv. Nach kurzer Einarbeitungszeit wird Ihnen die Arbeit mit Eclipse sehr gut und schnell von der Hand gehen.

1.3.1

Workspaces

Schon beim ersten Start der Eclipse-Entwicklungsumgebung hatten Sie unweigerlich Kontakt mit den Workspaces. Workspaces sind die oberste Organisationseinheit in Eclipse. Einen Workspace können Sie sich als einen Arbeitsplatz vorstellen, an dem alle Dokumente und Werkzeuge liegen, die Sie für eine Aufgabe bzw. Entwicklung benötigen. Kehren Sie morgens an den Schreibtisch zurück, finden Sie ihn in der Regel genauso vor, wie Sie ihn

58

Eclipse Workbench

verlassen haben – wenn Sie Glück haben, ohne die halb leere Kaffeetasse und den Pizza-Karton vom Mittagessen. Auf ähnliche Weise speichert Eclipse den Zustand der Entwicklungsumgebung in einem Workspace ab. Beim nächsten Laden dieses Workspaces finden Sie die Entwicklungsumgebung genauso vor, wie Sie sie verlassen haben. So, wie Sie unter Umständen an mehreren Schreibtischen arbeiten, können Sie in Eclipse beliebig viele Workspaces anlegen. Technisch gesehen, handelt es sich um ein Verzeichnis auf der Festplatte. In diesem Verzeichnis speichert Eclipse verschiedene Metadaten ab. Das Anlegen eines neuen Workspaces übernimmt Eclipse für Sie. Wenn Sie beim Start von Eclipse nach dem Workspace gefragt werden, können Sie entweder das Verzeichnis eines bestehenden Workspaces oder ein neues Verzeichnis angeben. In letzterem Fall erstellt Eclipse automatisch einen neuen Workspace. Verzeichnisse für Workspaces Verwenden Sie für einen neuen Workspace immer ein eigenes, leeres Verzeichnis. Manipulieren Sie dieses Verzeichnis möglichst nicht von Hand, sondern nur über die Eclipse-Umgebung. Möchten Sie bestehende Projekte in einen neuen Workspace überführen, verwenden Sie die Importfunktion.

Nutzen Sie Eclipse ausschließlich zur ABAP-Entwicklung, benötigen Sie voraussichtlich nur einen einzigen Workspace. In diesem Fall können Sie die Abfrage beim Start von Eclipse unterdrücken. Markieren Sie dazu die Auswahlbox Use this as the default and do not ask again beim Start. Falls Sie dennoch den Workspace wechseln möchten, können Sie dies nachträglich immer noch über den Menüpfad File 폷 Switch Workspace 폷 Other tun. Sie gelangen über diesen Pfad in einen Auswahldialog, in dem Sie einen bestehenden Workspace wählen oder einen neuen anlegen können.

1.3.2

Projekte

Die Entwicklung in Eclipse ist in Projekte organisiert. Es gibt verschiedene Arten von Projekten (Java-Projekte, JavaScript-Projekte, Webprojekte etc.). Ein Projekt fasst verschiedene Dateien zusammen, die zu einer Entwicklung gehören. Auf der Ebene des Projekts wird ebenfalls definiert, wie Eclipse mit den gespeicherten Artefakten umgeht, z. B., ob und wie Dateien kompiliert werden müssen oder wie ein Code zur Ausführung gebracht werden kann.

59

1.3

1

Die ersten Schritte – »Hallo ADT«

Abbildung 1.30 zeigt den Project Explorer in Eclipse 1. Es sind drei verschiedene Projekttypen (Java, ABAP und SAPUI5) geöffnet. Abhängig vom Projekttyp bereitet Eclipse die Projektinhalte unterschiedlich auf 2. Diese Aufbereitung spiegelt nicht unbedingt die gespeicherte Struktur auf der Festplatte wider. Falls Sie sich diese Struktur ansehen wollen, können Sie dies auf der Registerkarte Navigator 3 tun. Ein Projekt kann einem oder mehreren Workspaces zugewiesen sein. Beim Start des Workspaces stehen diese Projekte zur Verfügung.

Abbildung 1.30 Project Explorer in der Eclipse Workbench

Projekte schließen Sie können Projekte, die Sie aktuell nicht benötigen, auch schließen – vor allem, wenn Sie gleichzeitig mit sehr vielen Projekten arbeiten. Nicht geöffnete Projekte lädt Eclipse nicht in den Speicher. Damit verringert sich die Ladezeit beim Starten eines Workspaces. Klicken Sie mit der rechten Maustaste auf das zu schließende Projekt, und wählen Sie close project im Kontextmenü. Auf dem gleichen Wege können Sie das Projekt über den Eintrag open project wieder öffnen. Geschlossene Projekte bleiben allerdings im aktuellen Workspace. Sollen diese ganz entfernt werden, geht das über den Eintrag Delete im Kontextmenü.

60

Eclipse Workbench

Die Eclipse Workbench ist für die Arbeit in Projekten ausgelegt. Dateien können zwar auch direkt geöffnet werden, tauchen dann aber nicht in der Projektverwaltung auf. Auch in den ADT kommen Sie nicht darum herum, mit Projekten zu arbeiten. Die Brücke zur Entwicklung auf dem SAP NetWeaver AS ABAP schlägt das ABAP-Projekt. Im ABAP-Projekt sind die Verbindungsdaten zu einem System hinterlegt. Allerdings werden keine ABAPDateien lokal auf der Festplatte gespeichert. Eine reine Offline-Entwicklung ist daher auch mit den ADT leider nicht möglich. Allerdings verkraftet Eclipse kurze Ausfälle der Verbindung zum Backend-System etwas besser als das SAP GUI. Um mit mehreren Systemen parallel zu arbeiten, können einfach mehrere ABAP-Projekte in einem Workspace angelegt werden. Projekte können auch in Working Sets organisiert werden. Damit behalten Sie gerade bei großen Workspaces leichter die Übersicht. Sie können die Working Sets im Project Explorer organisieren. Abbildung 1.31 zeigt z. B. das Working Set ADT.

Abbildung 1.31 Verwendung von Working Sets

Semantisches Dateisystem Die ABAP-Ressourcen werden über ein sogenanntes semantisches Dateisystem (Semantic File System, SFS) eingebunden. Das SFS kümmert sich darum, dass Ressourcen vom Server abgerufen und nach der Bearbeitung gespeichert werden können. In der Regel ist dieser Vorgang für den Anwender transparent.

61

1.3

1

Die ersten Schritte – »Hallo ADT«

1.3.3

Views

Informationen werden in Eclipse in Form von Sichten (Views) dargestellt. Views können zur Navigation dienen (wie z. B. der Project Explorer) oder mit einem Editor verknüpft sein, um Daten anzuzeigen und zu manipulieren. Views sind untereinander verknüpft. Klicken Sie doppelt auf eine Datei im Project Explorer, versucht Eclipse, den passenden Editor zu ermitteln und anzuzeigen. Eine Liste Ihrer zuletzt aufgerufenen Views finden Sie unter Window 폷 Show View. Unter Window 폷 Show View 폷 Others finden Sie eine Liste aller verfügbaren Views. Dieses Fenster bietet übrigens wie die meisten EclipseFenster eine Live-Suche an. Während Sie den gesuchten Begriff eingeben, grenzt Eclipse die Liste auf jene Elemente ein, die den angegebenen Begriff enthalten. Sie erreichen die View-Liste auch über Tastatureingaben, indem Sie (ª) + (Alt) + (Q) und direkt danach noch mal (Q) drücken. Views können nach Bedarf innerhalb der Eclipse Workbench verschoben und angeheftet werden. Zudem können sie »gestapelt« werden. Werden mehre Views in denselben Bildschirmbereich positioniert, zeigt Eclipse diese automatisch als Registerkarten hintereinander an. Alle Views haben zwei Kontextmenüs: 왘 Das erste Menü erreichen Sie, indem Sie mit der rechten Maustaste auf das Register eines Views klicken. Über dieses Menü können Sie den aktuellen View, alle Views im Stapel oder alle anderen Views im Stapel außer dem gerade ausgewählten schließen. 왘 Das zweite Menü erreichen Sie über den kleinen Pfeil in der rechten oberen Ecke jedes Views wie in Abbildung 1.31. Dieses Menü bietet Operationen an, die sich auf den gesamten Inhalt des Views auswirken. Einzelne Elemente eines Views (z. B. Dateien im Project Explorer) können wiederum eigene Kontextmenüs anbieten. Diese sind über einen Rechtsklick auf das Element erreichbar.

1.3.4

Perspektiven

Perspektiven bündeln Views und speichern deren Layout. Perspektiven sind oft dafür ausgelegt, bestimmte Entwicklungsaufgaben abzubilden. So gibt es für die Java-, PHP- und ABAP-Entwicklung jeweils eigene Perspektiven, die alle relevanten Views öffnen.

62

Das erste Programm

Es ist sehr wahrscheinlich, dass Sie während der Arbeit mit Eclipse oft zwischen verschiedenen Perspektiven wechseln. Die zuletzt verwendeten Perspektiven finden Sie im rechten Teil der Symbolleiste der Entwicklungsumgebung. In Abbildung 1.32 ist die Perspektive ABAP ausgewählt. Eine Übersicht über alle verfügbaren Perspektiven erhalten Sie über den Menüpfad Window 폷 Open Perspective 폷 Other.

Abbildung 1.32 Quick Access & Perspektivenauswahl

Quick Access Views und Perspektiven können auch über die Quick-Access-Funktion (siehe Abbildung 1.32) geöffnet werden. Geben Sie in dieses Feld den Namen der Perspektive ein. Eclipse stellt Ihnen dabei eine Auswahl der verfügbaren Perspektiven zur Verfügung. Über den Quick Access können Sie übrigens auch neue Objekte anlegen oder Befehle ausführen. Dies kann insbesondere dann praktisch sein, wenn Sie zwar den Namen einer Funktion kennen, aber nicht mehr wissen, wo sie zu finden ist bzw. wie das Tastaturkürzel dazu lautet. Mit der Tastenkombination (Strg) + (3) springt Ihr Cursor direkt in das Quick-Access-Feld.

1.4

Das erste Programm

Nun ist es endlich so weit, und wir beginnen mit der Aufgabe, die wir eigentlich ausführen wollen, dem Programmieren. Eine tabellarische Übersicht der wichtigsten hier vorgestellten Funktionen und Tastenkombinationen finden Sie übrigens in Anhang A, »Wegweiser durch die ABAP Development Tools«.

1.4.1

ABAP-Projekt anlegen

Wie bereits erwähnt, bilden ABAP-Projekte das Bindeglied zwischen dem Backend-System und der Entwicklungsumgebung. Daher legen wir zunächst ein solches Projekt für unser Entwicklungssystem an. Dabei spielt es keine Rolle, ob es sich um ein virtuelles System in der Cloud oder um einen Server in Ihrem Rechenzentrum handelt. 1. Starten Sie Eclipse, und öffnen Sie Ihren (leeren) Workspace. Sollte Eclipse Sie mit der Willkommensseite begrüßen, beenden Sie diese über den Button .

63

1.4

1

Die ersten Schritte – »Hallo ADT«

2. Starten Sie den Anlage-Dialog, indem Sie im Menü File 폷 New 폷 Other wählen. Alternativ erreichen Sie diesen Dialog über das Tastenkürzel (Strg) + (N). 3. Wählen Sie, wie in Abbildung 1.33 gezeigt, aus der Liste der verfügbaren Anlage-Assistenten den Assistenten ABAP Project. Alternativ können Sie auch »ABAP Project« in das Eingabefeld des Dialogs eingeben. Eclipse filtert die Auswahlliste dann dynamisch. Fahren Sie mit einem Klick auf Next fort.

Abbildung 1.33 Anlage-Assistenten für ABAP-Projekte wählen

4. Als Nächstes wählen Sie Ihr Backend-System aus. Haben Sie das System in das SAP Logon Pad aufgenommen, können Sie es über den Button Browse (oder per Eingabe des Namens in das Feld Connection) auswählen (siehe Abbildung 1.34). Seit Version 2.28 der ADT können Sie die Zugangsdaten für den Server auch manuell definieren. Mit einem Klick auf Next gelangen Sie zur Benutzereingabe. 5. Wählen Sie den Entwicklungsmandanten Ihres Systems aus. (Im Falle eines AWS-Systems ist dies in der Regel 001.) Geben Sie Benutzernamen und Passwort an. Falls Sie sich nicht in der Standardsprache des Systems anmelden möchten, können Sie die Sprache hier ebenfalls ändern. Das Ändern der Anmeldesprache ist danach für dieses Projekt nicht mehr möglich. Dazu müssen Sie ein weiteres Projekt erstellen (was allerdings sehr schnell möglich ist).

64

Das erste Programm

Abbildung 1.34 Systemverbindung wählen

6. ABAP-Projekte sind mit einer eigenen Perspektive verknüpft. Daher fragt Eclipse, ob Sie jetzt in diese Perspektive wechseln wollen. Bestätigen Sie die Abfrage aus Abbildung 1.35 mit Yes.

Abbildung 1.35 Perspektivenwechsel bestätigen

7. Als Resultat sollten Sie nun im Project Explorer ein neues Projekt vorfinden. Der Name des Projekts setzt sich aus der System-ID des Servers, dem Mandanten, dem Benutzernamen und der Anmeldesprache zusammen (siehe Abbildung 1.36).

65

1.4

1

Die ersten Schritte – »Hallo ADT«

Abbildung 1.36 Neues ABAP-Projekt im Project Explorer

Unterhalb des ABAP-Projekts sehen Sie nur zwei Knoten im Project Explorer: 왘 Favorite Packages Derzeit befindet sich nur das Paket $TMP unter den Favoriten. Sie können aber jedes beliebige Paket zu Ihren Favoriten hinzufügen, um schnell darauf zugreifen zu können. 왘 System Library Hier finden Sie eine Übersicht über alle Entwicklungsklassen auf dem Backend-System.

1.4.2

»Hallo Welt«

Mit unserem ersten Programm werden wir wohl keinen Preis für Kreativität gewinnen, aber es sollte genügen, um zu verifizieren, dass die Entwicklungsumgebung korrekt eingerichtet ist, und Ihnen ein erstes Gefühl für die Arbeit mit Eclipse geben. Am Ende der Übung sollte ein freundliches »Hallo Welt« auf dem Monitor erscheinen. Wir gehen bei unserem ersten Programm den Weg des geringsten Wiederstands, d. h., wir legen einen einfachen Report als lokales Objekt an: 1. Navigieren Sie im Project Explorer unterhalb des Knotens für das ABAPProjekt zum Eintrag Favorite Packages 폷 $TMP – , und klicken Sie mit der rechten Maustaste auf den Paketnamen.

Abbildung 1.37 Neues Programm anlegen

66

Das erste Programm

2. Wählen Sie im Kontextmenü New 폷 ABAP Programm (siehe Abbildung 1.37). 3. Im Anlage-Assistenten vergeben Sie einen Namen (z. B. »Z_HELLO_ WORLD«) und eine Beschreibung für Ihr neues Programm (siehe Abbildung 1.38). Beachten Sie, dass hier die Standardnamenskonventionen von SAP gelten.

Abbildung 1.38 ABAP-Programm anlegen

Neues Programm über Tastenkombination anlegen Sie haben auch die Möglichkeit, ein neues Objekt wie Ihr Programm mit der Tastenkombination (Strg) + (N) anzulegen und anschließend über einen Dialog das zugehörige Projekt und Paket auszuwählen. Dies ist weniger intuitiv, geht aber dafür etwas schneller.

4. Bestätigen Sie Ihre Eingabe durch einen Klick auf Next. 5. Die Auswahl des Transportauftrags können Sie in diesem Fall überspringen, da wir ein lokales Objekt anlegen. Beenden Sie den Assistenten mit dem Button Finish. Das Resultat Ihrer Bemühungen sehen Sie in Abbildung 1.39. Sollte Ihnen das neue Objekt nicht unmittelbar angezeigt werden, aktualisieren Sie den Project Explorer mit (F5).

67

1.4

1

Die ersten Schritte – »Hallo ADT«

Link with Editor Sollte Ihr neu angelegtes Programm nicht im Project Explorer angezeigt werden, aktivieren Sie die Funktion Link With Editor ( ). Diese Funktion ist bei vielen Views verfügbar und sorgt dafür, dass die Anzeige im View mit dem aktuell im Editor geöffneten Objekt verknüpft wird. Im Falle des Project Explorers wird auf diese Weise der Baum expandiert und der Cursor auf das gerade geöffnete Objekt gesetzt.

Abbildung 1.39 Ihr erstes Hallo-Welt-Programm

Nun müssen Sie nur noch etwas ABAP-Code einfügen, und Ihr erstes Programm ist lauffähig: 1. Fügen Sie den Code aus Listing 1.2 in Ihr neues Programm ein. REPORT z_hello_world. PARAMETER: p_name TYPE text30. WRITE |Hello| && p_name && |!|. Listing 1.2 Hallo-Welt-Programm

2. Aktivieren Sie das Programm mit der Tastenkombination (Strg) + (F3). 3. Nachdem das Programm aktiviert wurde, starten Sie es mit (F8). Eclipse sollte das Programm nun ordnungsgemäß ausführen. Dazu wird das SAP GUI aufgerufen und im Editor-View angezeigt. Sie können hier nun einen Namen für das Programm angeben. Geben Sie z. B. »World« im Feld P_NAME ein, und starten Sie den Report. Und siehe da: Die Aufgabe ist erfüllt (siehe Abbildung 1.40). Funktionstasten Die verwendeten Funktionen lassen sich nicht nur über Tastenkürzel aufrufen. Die meisten finden Sie auch in der Menüleiste.

68

Das erste Programm

Abbildung 1.40 Ausgabe des Hallo-Welt-Programms

Das Programm reißt sicherlich niemanden vom Hocker. Sind Sie bis hierhin gekommen, haben Sie Ihre Reise in die Welt von Eclipse jedoch erfolgreich begonnen. Ihre Sachen sind gepackt, und Sie sind dafür gewappnet, Ihre erste größere Implementierung mit den ADT zu beginnen.

1.4.3

Feature Explorer

Seit Version 2.24 bringen die ADT den sogenannten Feature Explorer mit. Dabei handelt es sich um ein interaktives Tutorial innerhalb von Eclipse. Beim ersten Start der ABAP-Perspektive finden Sie den Feature Explorer auf der rechten Seite Ihrer Entwicklungsumgebung (siehe Abbildung 1.41).

Abbildung 1.41 Feature Explorer

69

1.4

1

Die ersten Schritte – »Hallo ADT«

Der Feature Explorer ermöglicht einen sehr guten Einstieg in die Arbeit mit Eclipse. Ich empfehle Ihnen, die kurzen und einfachen Tutorials nachzuvollziehen. Allerdings ist das nicht zwingend erforderlich, um mit diesem Buch weiterzuarbeiten. Werfen Sie in diesem Zusammenhang auch einmal einen Blick in das SAP Community Network (SCN, http://scn.sap.com/community/abap/eclipse/blog/ 2014/04/15/become-an-abap-in-eclipse-feature-explorer-and-earn-the-explorerbadge). Hier finden Sie Beiträge von anderen Eclipse-Einsteigern, die Erfahrungsberichte zur Programmierung von ABAP in Eclipse beinhalten. Vielleicht sehen Sie sich ja auch dazu berufen, Ihre ersten Schritte mit dem Feature Explorer in Form eines Blog-Beitrags zu dokumentieren.

70

»Develop like never before« lautet das Werbeversprechen von SAP. In diesem Kapitel werden Sie tatsächlich Neues entdecken und Altbekanntes mit anderen Augen betrachten. Meistern Sie Ihren Programmieralltag mit den ABAP Development Tools in Eclipse.

2

Funktionen der ABAP Development Tools

In diesem Kapitel arbeiten wir uns durch die verschiedenen Grundfunktionen der Entwicklungsumgebung ABAP Development Tools für SAP NetWeaver (ADT). Wir beginnen mit dem Anlegen der gängigsten ABAP-Entwicklungsobjekte in Eclipse. Später sehen wir uns verschiedene Komfortfunktionen an. Diese sind teilweise exklusiv in Eclipse verfügbar, teilweise handelt es sich auch um Funktionen, die im SAP GUI ebenfalls zur Verfügung stehen, dort aber neu eingeführt wurden oder bisher ein Schattendasein fristeten. Abschließend sehen wir uns genauer an, an welchen Stellen sich die neue Entwicklungsumgebung grundsätzlich von der ABAP Workbench unterscheidet und wie Sie – auch als erfahrener ABAP-Entwickler – Ihren Arbeitsablauf mit dem neuen Werkzeug noch optimieren können.

2.1

Demoszenario

Damit Sie nicht im luftleeren Raum ausprobieren müssen, bauen wir zunächst ein Demoszenario auf. Dieses Szenario wird uns als Beispiel in den folgenden Kapiteln dieses Buches begleiten. Es ist bewusst so einfach gehalten, dass Sie nicht zu viel Zeit aufwenden müssen, um es zu implementieren, und auch mittendrin einsteigen können. Gleichzeitig ist es aber komplex genug, um die wichtigsten Entwicklungsarbeiten demonstrieren zu können. Bei unserem Beispielprojekt handelt es sich um die Entwicklung einer Aufgabenliste (Issue List). Die Entwicklung ist unabhängig von spezifischen SAPKomponenten. Daher kann sie auch auf einem SAP NetWeaver AS ABAP implementiert werden, auf dem keine weiteren Module verfügbar sind.

71

2

Funktionen der ABAP Development Tools

ISSUE_LIST STATUS +NEW +OPEN +WIP +READY_TO_TEST +IN_TEST +READY_TO_TRANSPORT +CLOSED

COMMENT

PROJECT 1 berichtet 0..*

0..*

1

Reporter

ISSUE wird zugeteilt Developer

CR

BR

DR

Abbildung 2.1 Konzeptionelle Übersicht der Aufgabenliste

Fühlen Sie sich eingeladen, Ihre eigene Implementierung beliebig auszubauen oder anzupassen. Das Design bietet genug Spielraum für Verbesserungen. Im Zentrum unserer Entwicklung steht ein Issue, d. h. einer offener Punkt oder eine Aufgabe in unserer Entwicklungsliste. Ein Issue kann entweder eine Änderungsanfrage (Change Request, CR), eine Entwicklungsanfrage (Development Request, DR) oder ein Fehlerbericht (Bug Report, BR) sein. Er wird durch Meldenden bzw. Anforderer (Reporter) gemeldet. Dieser muss die Aufgabe nicht unbedingt selbst in die Aufgabenliste eintragen, wenn er z. B. nicht über einen SAP-Zugang verfügt oder einen Fehler bei einem Support-Mitarbeiter meldet. Ein Eintrag kann einem Entwickler (Developer) zugeordnet werden, der dann für die Erledigung dieser Aufgabe verantwortlich ist. Zu einem Issue können beliebig viele Kommentare verfasst werden. Außerdem kann eine Aufgabe einen Status haben, der den Stand der Bearbeitung angibt. Es gibt außerdem die Möglichkeit, Projekte anzulegen. Ein Projekt besteht aus mehreren Issues. Abbildung 2.1 stellt die Implementierung schematisch dar. Abbildung 2.2 gibt Ihnen eine Übersicht über das grundlegende Design der Demoapplikation. Das Diagramm enthält zum einen alle Klassen, die wir im Laufe der Entwicklung anlegen werden, zum anderen sind die Tabellen definiert, in denen wir unsere Entwicklungsliste abspeichern werden. Nicht eingezeichnet sind Funktionsbausteine, Programme und Web-Dynpro-

72

Mit Entwicklungsobjekten arbeiten

2.2

Applikationen, die wir entwickeln werden. Ich werde auf die Objekte aber an entsprechender Stelle eingehen.

Z_ISSUE_LIST ZCOMMENT +ISSUE_ID: Z_ISSUE_ID +COUNTER: Z_COUNTER +REPORTER: Z_REPORTER +TIMESTAMP: TIMESTAMP +LOEVM: LOEVM +CONTENT: STRING

ZCL_PROJECT -ms_project: zproject -is_persistent: boolean +set_project(is_project: zproject) +get_project(): zproject +get_issues(): zissue_t +get_status(ef_open_items: int4, ef_finished_items: int4, ef_percentage: float) +list_projects(): z_project_t 0..1 0..*

ZCL_COMMENT -ms_comment: zcomment -is_persistent: boolean +save() +is_persistent(): boolean 0..* +delete() +get_comments(): z_comment_t +set_comment(if_comment: string, if_autor: name) +get_next_counter(): int4 +get_next_comment(): zcl_comment +has_next(): boolean +append_comment(ir_comment: zcl_comment)

ZCL_ISSUE

1

-ms_issue: ZISSUE -is_persistent: boolean +mr_comments_cl: zcl_comment_t +set_issue(is_issue: zissue) +get_issue(): zissue +get_comments(): zcl_comment +add_comment(if_comment: string, if_autor: name) +get_project(): zcl_project

ZPROJECT +PROJECT_ID: Z_PRJ_ID +NAME: Z_PRJ_NAME +BGDAT: Z_START_DATE +PLEND: Z_DUE_DATE +LOEVM: LOEVM

ZISSUE +ISSUE_ID: Z_ISSUE_ID +NAME: Z_ISSUE_NAME +DESCRIPTION: STRING +STATE: Z_ISSUE_STATE +TYPE: Z_ISSUE_TYPE +PROJECT_ID: Z_PRJ_ID +REPORTER: Z_REPORTER +ASSIGNED_TO: Z_ASSIGNED_TO +START_DATE: Z_START_DATE +DUE_DATE: Z_DUE_DATE +LOEVM: LOEVM

Abbildung 2.2 Issue List – Entwicklungsobjekte

Nachdem Sie dieses Buch durchgearbeitet haben, haben Sie die Grundlagen für eine kleine Applikation zum Aufgabenmanagement gelegt. Zudem können Sie sich eine Liste mit offenen Aufgaben und den Gesamtstatus eines Projekts anzeigen lassen. Erweiterungsmöglichkeiten Die Aufgabenliste, die wir im Laufe des Buches entwickeln, ist sehr einfach gehalten. Sie können diese Entwicklung jedoch als Grundlage nehmen, um selbst ein wenig herumzuexperimentieren. Sie können z. B. eine Funktion implementieren, um die Issues beliebig ineinanderschachteln zu können. Auch gibt es in der Grundstruktur der Anwendung keine Möglichkeit, Dateien an Kommentare oder Issues anzuhängen. Sie könnten darüber hinaus die Möglichkeit einrichten, Issues mit Transportaufträgen in SAP NetWeaver AS ABAP zu verknüpfen. Es sind unzählige solcher Erweiterungen denkbar. Inspiration finden Sie z. B. in Abschnitt 2.8.5, »Aufgabenverwaltung mit Mylyn«.

2.2

Mit Entwicklungsobjekten arbeiten

Sobald Sie Ihre Eclipse-Entwicklungsumgebung gestartet haben, können Sie auch schon loslegen. Falls Sie noch kein ABAP-Projekt angelegt haben, finden Sie in Abschnitt 1.4.1, »ABAP-Projekt anlegen«, eine Anleitung dazu.

73

2

Funktionen der ABAP Development Tools

Andernfalls öffnen Sie das Projekt zu Ihrem Entwicklungssystem und authentifizieren sich mit Ihrem Kennwort. In Anhang A, »Wegweiser durch die ABAP Development Tools«, finden Sie einige nützliche Funktionen und Tastenkombinationen, die Sie bei der Arbeit mit Entwicklungsobjekten kennen sollten.

2.2.1

Pakete anlegen

Für unser Demoprojekt genügt uns ein einfaches Paket, um alle Entwicklungsobjekte zusammenzufassen. Dieses legen Sie zunächst an. Damit Sie Ihre Arbeit später schnell wiederfinden, fügen Sie das neue Paket zudem zur Liste Ihrer Favoriten hinzu: 1. Wählen Sie im Project Explorer Ihr ABAP-Projekt. Falls die Untereinträge zu diesem Knoten noch nicht expandiert sind, klappen Sie sie mit dem kleinen Pfeil neben dem Ordnersymbol auf. 2. Klicken Sie mit der rechten Maustaste auf den Eintrag Systembibliothek, und wählen Sie im Kontextmenü den Eintrag Neu. Die Direktauswahl schlägt Ihnen die Objekte ABAP Class, ABAP Interface und ABAP Program zur Anlage vor. Da wir aber ein Paket anlegen möchten, klicken Sie auf OtherABAP Repository Object ((ª) + (Strg) + (N), siehe Abbildung 2.3).

Abbildung 2.3 Neues Entwicklungsobjekt anlegen

Direktauswahlliste anpassen Sie können die Direktauswahlliste übrigens nach Ihren Vorlieben anpassen. Wie das geht, erfahren Sie in Abschnitt 2.5, »Mit mehreren Ressourcen arbeiten«.

3. Im sich öffnenden Anlage-Dialog wählen Sie Package 폷 Package und klicken auf Next (siehe Abbildung 2.4). Achten Sie darauf, dass sie sich im Dialog ABAP Repository Object befinden, um nicht aus Versehen ein Java

74

Mit Entwicklungsobjekten arbeiten

Package anzulegen. Wie in den meisten Eclipse-Dialogen steht Ihnen auch hier eine komfortable Suche zur Verfügung. Schon während der Eingabe Ihres Suchbegriffs wird die Ergebnisliste eingeschränkt.

Abbildung 2.4 Objekttyp zur Anlage auswählen

4. Im folgenden Schritt nennen Sie Ihr neues Paket »Z_ISSUE_LIST« und fahren mit einem Klick auf Finish fort (siehe Abbildung 2.5).

Abbildung 2.5 Paketnamen angeben

5. Eclipse startet nun den Dialog zur Anlage des Pakets im SAP GUI und bettet diesen als Sicht im Editor-Bereich ein (siehe Abbildung 2.6). Hier können Sie wie gewohnt eine Beschreibung zum Paket angeben und Einstellungen wie die Softwarekomponente oder die Transportschicht ändern.

75

2.2

2

Funktionen der ABAP Development Tools

Abbildung 2.6 Beschreibung und Eigenschaften des Pakets definieren

Fehler beim Aufrufen des SAP GUIs Sollten Sie an dieser Stelle die Fehlermeldung erhalten, dass Sie keine Berechtigung haben, eine bestimmte Ressource zu öffnen, wurde Ihrem Benutzer wahrscheinlich nicht die Rolle ADT_RES zugeordnet.

SAP GUI in eigenem Fenster öffnen Möchten Sie das SAP GUI wie gewohnt in einem eigenen Fenster öffnen, können Sie dies unter Window 폷 Preferences 폷 ABAP Development 폷 SAP GUI Integration einstellen.

6. Nach der Anlage des Pakets können Sie, wie aus der ABAP Workbench gewohnt, einen Transportauftrag auswählen (siehe Abbildung 2.7). Legen Sie einen neuen Transportauftrag an, oder wählen Sie einen bestehenden Auftrag aus.

Abbildung 2.7 Transportauftrag auswählen

76

Mit Entwicklungsobjekten arbeiten

7. Nach einem Klick auf Speichern ( ) können Sie die Registerkarte des SAP GUIs schließen. Klappen Sie die Systembibliothek auf, und drücken Sie (F5), um die Sicht zu aktualisieren. Eclipse lädt daraufhin die Liste der Pakete neu. Ihr neu angelegtes Paket sollte sich nun in der Liste befinden. 8. Klicken Sie mit der rechten Maustaste auf das neue Paket, und wählen Sie Add to Favorites im Kontextmenü. 9. Ihr Paket finden Sie nun unter dem Eintrag Favorite Packages (Favoritenpakete, siehe Abbildung 2.8). Diese Zuordnung bleibt für dieses Projekt bestehen.

Abbildung 2.8 Neues Paket in den Favoriten

Das Anlegen einer Favoritenliste ist für die tägliche Arbeit nützlich. Zum einen hat die Favoritenliste eine deutlich kürzere Ladezeit als die vollständige Liste der Pakete in der Systembibliothek, und zum anderen ersparen Sie sich das Suchen Ihrer aktuell bearbeiteten Pakete. Sie können zu einem System – auch für den gleichen Benutzer und Mandanten – mehrere Projekte erstellen. Jedes dieser Projekte kann dann wiederum eine eigene Favoritenliste haben. Im Verlauf dieses Kapitels lernen Sie noch andere Möglichkeiten kennen, Ihren persönlichen Arbeitsvorrat zu organisieren.

2.2.2

ABAP-Dictionary-Objekte anlegen

Um weiterarbeiten zu können, benötigen Sie einige ABAP-DictionaryObjekte. Eclipse bietet noch keine eigenen Tools zur Erstellung von ABAPDictionary-Objekten an, das SAP GUI ist jedoch vollständig in Eclipse integriert. Durch die Tastenkombination (Strg) + (6) lässt es sich direkt aufrufen, Sie können aber auch direkt in die Anlage-Maske der entsprechenden Objekte springen: 1. Markieren Sie im Project Explorer das Paket Z_ISSUE_LIST. 2. Drücken Sie (Strg) + (N), um ein neues Objekt zu erstellen. Alternativ können Sie auch den Weg über die rechte Maustaste und das Kontextmenü gehen, den ich im vorangegangenen Abschnitt beschrieben habe.

77

2.2

2

Funktionen der ABAP Development Tools

3. Wählen Sie ABAP Repository Object aus der Liste der verfügbaren Objekte. 4. Sie gelangen nun zu einer Übersicht aller verfügbaren Repository-Objekte. Wählen Sie Dictionary 폷 Data Element aus der Liste (siehe Abbildung 2.9). Alternativ können Sie mit der Tastenkombination (ª) + (Strg) + (N) direkt in die Anlage eines neuen Repository-Objekts einsteigen.

Abbildung 2.9 Auswahl der Repository-Objekte

5. Im Editor-Bereich öffnet sich das SAP GUI mit Transaktion SE11 zur Anlage eines neuen Datenelements. Wir legen zunächst einen Datentyp (Data Element) an, um den Schlüssel unserer Aufgabenliste zu speichern. Nennen Sie dieses Datenelement Z_ISSUE_ID (siehe Abbildung 2.10). 6. Der Schlüssel soll ein einfacher achtstelliger alphanumerischer Wert sein, daher wählen Sie als Domäne CHAR8. 7. Vergeben Sie eine Beschreibung (Short Description), und ergänzen Sie auf der Registerkarte Field Label die erforderlichen Feldbezeichner. Aktivieren Sie das Objekt mit der Tastenkombination (Strg) + (F3).

78

Mit Entwicklungsobjekten arbeiten

Abbildung 2.10 In Eclipse eingebettetes Data Dictionary zur Anlage eines Datenelements

8. Im Project Explorer wird das neue Objekt erst angezeigt, wenn Sie die Liste mit (F5) aktualisieren (siehe Abbildung 2.11).

Abbildung 2.11 Objekt Z_ISSUE_ID im Project Explorer

Auf diese Weise legen Sie alle Dictionary-Objekte an, die wir im Verlauf dieses Kapitels benötigen. Tabelle 2.1 zeigt diese Objekte in der Übersicht, alle Quelltexte können Sie auch unter www.sap-press.de/3700 herunterladen. Name

Objekttyp

Datentyp/Domäne

Z_ISSUE_ID

Datenelement

CHAR8

Z_ISSUE_NAME

Datenelement

String

Z_ISSUE_DESC

Datenelement

String

Z_ISSUE_STATE

Datenelement

Z_ISSUE_STATE_D

Z_ISSUE_TYPE

Datenelement

Z_ISSUE_TYPE_D

Tabelle 2.1 Neue ABAP-Dictionary-Objekte

79

2.2

2

Funktionen der ABAP Development Tools

Name

Objekttyp

Datentyp/Domäne

Z_PROJEKT_ID

Datenelement

CHAR8

Z_REPORTER

Datenelement

NAME

Z_ASSIGNED_TO

Datenelement

NAME

Z_START_DATE

Datenelement

DATS

Z_DUE_DATE

Datenelement

DATS

Z_PRJ_NAME

Datenelement

String

Z_COUNTER

Datenelement

INT4

Z_ISSUE_STATE_D

Domäne

CHAR8

Z_ISSUE_TYPE_D

Domäne

CHAR8

Z_ISSUE_T

Tabellentyp

ZISSUE

Z_PROJECT_T

Tabellentyp

ZPROJECT

ZISSUE

Tabelle

–

ZPROJECT

Tabelle

–

Tabelle 2.1 Neue ABAP-Dictionary-Objekte (Forts.)

Bei dem Objekt ZISSUE handelt es sich um eine Datenbanktabelle, in der Sie unsere Aufgaben abspeichern können. Die Felder der Tabelle zeigt Tabelle 2.2. Legen Sie die Tabelle mit der Auslieferungsklasse Applikationstabelle an. Feld

Datentyp

MANDT

MANDT

ISSUE_ID

Z_ISSUE_ID

NAME

Z_ISSUE_NAME

DESCRIPTION

Z_ISSUE_DESC

STATE

Z_ISSUE_STATE

TYPE

Z_ISSUE_STATE

PROJECT_ID

Z_PROJECT_ID

REPORTER

Z_REPORTER

ASSIGNED_TO

Z_ASSIGNED_TO

ERDAT

ERDAT

ERNAM

ERNAM

AEDAT

AEDAT

AENAM

AENAM

Tabelle 2.2 Felder der Tabelle ZISSUE

80

Mit Entwicklungsobjekten arbeiten

Unsere Projekte werden in der Tabelle ZPROJECT abgelegt. Legen Sie die entsprechende Applikationstabelle mit den Feldern aus Tabelle 2.3 an. Feld

Datentyp

MANDT

MANDT

PROJECT_ID

Z_PROJEKT_ID

PROJECT_NAME

Z_PROJEKT_NAME

BGDAT

Z_START_DATE

PLEND

Z_DUE_DATE

LOEVM

LOEVM

ERDAT

ERDAT

ERNAM

ERNAM

AEDAT

AEDAT

AENAM

AENAM

Tabelle 2.3 Felder der Tabelle ZPROJECT

Wenn Sie mit dem Anlegen der ABAP-Dictionary-Objekte fertig sind und alle Objekte erfolgreich aktiviert haben, markieren Sie das Paket Z_ISSUE_LIST im Project Explorer und drücken (F5). Das Resultat sollte wie in Abbildung 2.12 aussehen.

Abbildung 2.12 Neu angelegte Dictionary-Objekte im Project Explorer

81

2.2

2

Funktionen der ABAP Development Tools

Die geöffneten Registerkarten mit den SAP-GUI-Dialogen benötigen wir vorerst nicht mehr. Klicken Sie mit der rechten Maustaste auf eine beliebige Registerkarte, und wählen Sie Close All (siehe Abbildung 2.13).

Abbildung 2.13 Alle Registerkarten eines Views schließen

2.2.3

Funktionsbausteine anlegen

Auch wenn Sie mit neuesten Entwicklungswerkzeugen und dem aktuellen SAP-NetWeaver-Release arbeiten, kommen Sie nicht darum herum, ab und zu einen Funktionsbaustein oder einen Report entwickeln zu müssen. Die ADT unterstützen Sie bei dieser Aufgabe. In unserem Beispiel nutzen wir Funktionsbausteine, um den Zugriff auf die Datenbank zu kapseln. Zunächst legen wir einen einfachen Baustein zum Lesen und einen zum Schreiben eines Issues an. Beginnen wir damit, eine Funktionsgruppe anzulegen: 1. Öffnen Sie den Dialog zur Anlage eines neuen Repository-Objekts im Paket Z_ISSUE_LIST ((Strg) + (N)). Wählen Sie aus der Liste ABAP Function Group aus, und fahren Sie mit Next fort. 2. Nennen Sie die neue Funktionsgruppe Z_ISSUE_LIST_DB, und vergeben Sie eine passende Beschreibung. 3. Wählen Sie den Transportauftrag, den Sie für dieses Projekt angelegt haben, und beenden Sie die Anlage mit Finish. Nach der Aktualisierung taucht die Funktionsgruppe im Project Explorer auf. Als Nächstes legen wir die Funktionsbausteine an. Beginnen wir mit dem Baustein zum Lesen der Issues. 1. Markieren Sie die Funktionsgruppe Z_ISSUE_LIST_DB im Project Explorer, und starten Sie die Anlage eines neuen Objekts ((Strg) + (N)). 2. Wählen Sie ABAP 폷 ABAP Function Module aus der Liste verfügbarer Objekte. 3. Geben Sie »Z_READ_SINGLE_ISSUE« als Namen für den neuen Funktionsbaustein ein (siehe Abbildung 2.14). An dieser Stelle können Sie auch noch einmal die Funktionsgruppe auswählen, falls Sie diese nicht schon im Pro-

82

Mit Entwicklungsobjekten arbeiten

ject Explorer gewählt hatten. Wenn Sie alle Angaben gemacht haben, fahren Sie mit Next fort.

Abbildung 2.14 Namen und Beschreibung des Funktionsbausteins angeben

4. Wählen Sie den Transportauftrag aus, und legen Sie den neuen Baustein an. Sie können an dieser Stelle nur den Transportauftrag wählen, in dem sich auch Ihre Funktionsgruppe befindet. 5. Im Editor-View sehen Sie den leeren Funktionsbaustein. Ersetzen Sie den Code durch den aus Listing 2.1. FUNCTION z_read_single_issue IMPORTING if_issue_id TYPE z_issue_id EXPORTING es_issue TYPE zissue EXCEPTIONS no_issue_found. SELECT SINGLE * FROM zissue INTO es_issue WHERE issue_id = if_issue_id. IF sy-subrc NE 0. RAISE no_issue_found. ENDIF. ENDFUNCTION. Listing 2.1 Funktionsbaustein Z_READ_SINGLE_ISSUE

83

2.2

2

Funktionen der ABAP Development Tools

6. Aktivieren Sie den neuen Funktionsbaustein mit (Strg) + (F3) oder über den Button Aktivieren ( ) in der Toolbar. 7. Legen Sie auf die gleiche Art den Baustein zum Schreiben des Issues Z_CREATE_SINGLE_ISSUE an. 8. Ersetzen Sie den Code Ihres neuen Bausteins im Editor-View durch den aus Listing 2.2. FUNCTION z_create_single_issue IMPORTING is_issue type zissue EXPORTING es_issue type zissue EXCEPTIONS duplicate_issue_id no_issue_id. es_issue = is_issue. IF es_issue-issue_id IS INITIAL. RAISE no_issue_id. ENDIF. es_issue-erdat = sy-datum. es_issue-aedat = sy-datum. es_issue-ernam = sy-uname. es_issue-aenam = sy-uname. INSERT ZISSUE FROM es_issue. IF sy-subrc = 4. RAISE duplicate_issue_id. ENDIF. ENDFUNCTION. Listing 2.2 Funktionsbaustein Z_CREATE_SINGLE_ISSUE

Aktivieren Sie den neuen Baustein. Ihre Funktionsgruppe sollte jetzt im Project Explorer wie in Abbildung 2.15 aussehen.

Abbildung 2.15 Funktionsgruppe Z_ISSUE_LIST

Nun haben Sie zwei Bausteine, um die Basisfunktionen unseres Programms auszuführen. Sie können einen Datensatz speichern und wieder von der Da-

84

Mit Entwicklungsobjekten arbeiten

tenbank lesen. Wenn Sie mögen, können Sie die neuen Funktionen ausprobieren. Wechseln Sie dazu einfach in den entsprechenden Funktionsbaustein, und starten Sie die Standard-Testumgebung im SAP GUI mit der Taste (F8). Vielleicht sind Sie über die Syntax der Funktionsbausteine irritiert. Im Function Builder, d. h. in Transaktion SE37, wird die Schnittstelle eines Funktionsbausteins formularbasiert aufgebaut. Bei ABAP in Eclipse erfolgt die Deklaration rein quelltextbasiert. Das hat den Nebeneffekt, dass sich ein Funktionsbaustein sehr einfach kopieren und an anderer Stelle wieder voll funktionsfähig einfügen lässt. Auch wenn Sie die formularbasierte Erstellung von Funktionsbausteinen gewohnt sind, dürfte Ihnen die Angabe der Parameter nicht gänzlich fremd sein. Der Function Builder fügt genau diese Signatur als Kommentar ein, wenn Sie einen Baustein anlegen. Die Syntax der Funktionsbausteindeklaration ist in Listing 2.3 noch einmal zusammengefasst: FUNCTION func. [IMPORTING parameters] [EXPORTING parameters] [CHANGING parameters] [TABLES table_parameters] [{RAISING|EXCEPTIONS} exc1 exc2 ...] Listing 2.3 Deklaration eines Funktionsbausteins

Die Parameter werden dabei wie in Listing 2.4 angegeben. * Parameter { VALUE(p1) | p1 } {TYPE [REF TO] type} | {LIKE struccomp} | {STRUCTURE struc} [OPTIONAL|{DEFAULT def1}] * table_parameter p1 {TYPE itab_type} | {STRUCTURE struc} [OPTIONAL] Listing 2.4 Parameterangabe bei Funktionsbausteinen

Diese Deklaration ähnelt sehr der Deklaration von Methoden. Obsolete TABLES-Parameter Beachten Sie, dass TABLES-Parameter obsolet sind und nach Möglichkeit nicht mehr verwendet werden sollten. Verwenden Sie stattdessen die Parameter der Kategorien IMPORTING, EXPORTING oder CHANGING mit den entsprechenden Tabellentypen. Außerdem sollten Sie, falls möglich, klassenbasierte Ausnahmen verwenden.

85

2.2

2

Funktionen der ABAP Development Tools

Die Syntax zur Erzeugung der Funktionsbausteinsignatur müssen Sie nicht auswendig lernen. Die ADT werden mit einer Vorlage für Funktionsbaustein-Parameter ausgeliefert. Sie finden diese Vorlage unter dem Namen functionModuleParameter. Näheres zu Code-Vorlagen erfahren Sie in Abschnitt 2.3, »Code-Vervollständigung«.

2.2.4

Klassen

Als Nächstes legen wir die erste Klasse unseres Projekts an. In diesem Abschnitt geht es zunächst um die grundsätzliche Vorgehensweise. In Abschnitt 2.3, »Code-Vervollständigung«, und Abschnitt 2.7, »Quick Fix und Quick Assist«, zeige ich Ihnen weitere Möglichkeiten, effektiver mit dem Quellcode zu arbeiten. Wenn Sie bereits im Class Builder der ABAP Workbench (Transaktion SE24) mit ABAP Objects gearbeitet haben, kennen Sie sicherlich die formularbasierte Anlage von Klassen (siehe Abbildung 2.16).

Abbildung 2.16 Formularbasierter Class Builder

In dieser Sicht werden die Methoden und Attribute einer Klasse tabellarisch dargestellt. Dies erleichtert die objektorientierte Entwicklung. Es ist nicht notwendig, von Anfang an die exakte Syntax einer Klasse zu kennen. Allerdings kann es beim Erstellen umfangreicher Klassen mühselig sein, die Definition zu erstellen bzw. zwischen den Ansichten für die verschiedenen Methoden hin und her zu springen. Erfahrene Entwickler sind mit einer Tastatureingabe oftmals schneller. Zudem lässt sich eine Klasse in der Formularsicht nur schwierig durchsuchen oder kopieren. Die formularbasierte Sicht wird in Eclipse nicht direkt unterstützt. Stattdessen sehen Sie hier den reinen Quelltext einer Klasse. Entwickler, die mit Sprachen wie Java, C# oder C++ vertraut sind, werden sich mit dieser Darstellung wahrscheinlich sehr schnell anfreunden können.

86

Mit Entwicklungsobjekten arbeiten

Ein quelltextbasierter Klassen-Editor steht Ihnen übrigens auch im SAP GUI zur Verfügung. Die Möglichkeit, in diese Ansicht zu wechseln, wurde bereits mit SAP NetWeaver 7.0 Enhancement Package (EHP) 2 eingebaut. Sie rufen diese Sicht im Class Builder (bzw. in der ABAP Workbench, Transaktion SE80) über einen Klick auf den Button Source Code-Based in der Funktionsleiste auf. Die im quelltextbasierten Editor verwendete Syntax ist mit der zur Anlage lokaler Klassen identisch. Ein Beispiel für eine leere Klassendefinition sehen Sie in Abbildung 2.19.

Klasse anlegen Schauen wir uns nun an, wie Sie in Eclipse ganz einfach zu einer solchen Klassenhülle kommen. Dazu erstellen wir eine Klasse ZCL_ISSUE, die die Aufgaben in unserer Aufgabenliste repräsentieren kann: 1. Klicken Sie im Project Explorer mit der rechten Maustaste auf das Paket Z_ISSUE_LIST. 2. Wählen Sie aus dem Kontextmenü Neu 폷 ABAP Class. 3. Geben Sie als Namen für die Klasse »ZCL_ISSUE« ein (siehe Abbildung 2.17).

Abbildung 2.17 Namen und Beschreibung einer Klasse angeben

Namenskonventionen beachten Es gelten die üblichen Einschränkungen und Konventionen bei der Namensvergabe. Eine kundeneigene Klasse muss mit Y oder Z, gefolgt von CL, beginnen (ausgenommen, es gibt in Ihrem Unternehmen kundeneigene Namensräume).

87

2.2

2

Funktionen der ABAP Development Tools

4. Vergeben Sie eine sinnvolle Beschreibung, und bestätigen Sie mit einem Klick auf Next. 5. Wählen Sie den Transportauftrag aus, den Sie für unser Demoprojekt angelegt haben, und schließen Sie den Anlage-Assistenten mit einem Klick auf Finish (siehe Abbildung 2.18).

Abbildung 2.18 Auswahl des Transportauftrags

Im Project Explorer finden Sie unter dem Paket Z_ISSUE_LIST nun einen neuen Eintrag Source Library und darunter wiederum den Ordner Classes. In diesem Ordner finden Sie die neu angelegte Klasse ZCL_ISSUE. Der Anlage-Assistent hat für uns die Grundstruktur der Klasse angelegt. Wie in Abbildung 2.19 dargestellt, wurden der Definitionsteil mit der Public, Protected und Private Section sowie der Implementierungsteil angelegt. Objektorientiertes ABAP Auf Details zu ABAP Objects gehe ich in diesem Buch nicht ein. Falls Sie tiefer in das Thema einsteigen möchten oder weitere Informationen benötigen, möchte ich Ihnen das Buch ABAP Objects von Horst Keller und Sascha Krüger ans Herz legen.

88

Mit Entwicklungsobjekten arbeiten

Abbildung 2.19 Rumpf einer frisch angelegten Klasse

Als Nächstes legen wir ein Feld an, in dem der Inhalt eines Issues gespeichert werden soll. Außerdem definieren wir einen Constructor, der die Klasse sauber instanziiert, sowie eine Getter- und eine Setter-Methode, um den Inhalt zu lesen bzw. zu ändern. Fügen Sie in die Private Section folgende Datendeklaration ein: DATA ms_issue TYPE zissue.

In der Public Section tragen Sie die Deklarationen für den Constructor und die beiden Methoden wie in Listing 2.5 ein. METHODS: constructor IMPORTING if_issue TYPE z_issue_id OPTIONAL, get_issue RETURNING VALUE(rs_issue) TYPE zissue, set_issue IMPORTING is_issue TYPE zissue. Listing 2.5 Public Section der Klasse ZCL_ISSUE

Damit ist der Deklarationsteil fürs Erste vollständig. Versuchen Sie, die Klasse so zu aktivieren, wird jedoch eine Fehlermeldung ausgegeben, da wir für die Methoden noch keine Implementierung angelegt haben. Im Unterschied zur ABAP Workbench zeigt Ihnen Eclipse diesen Fehler sogar schon vor dem Speichern der Klasse an. Dabei wird in der entsprechenden CodeZeile ein Marker ( , siehe Abbildung 2.20) gesetzt, und die Stelle wird rot unterstrichen, ähnlich wie moderne Textverarbeitungsprogramme es bei Rechtschreibfehlern tun. Fahren Sie mit der Maus über den Marker, wird eine kurze Fehlermeldung eingeblendet. Näheres zu dieser Funktion erfahren Sie in Abschnitt 2.4.3, »Lineale und Markierungen«, und Abschnitt 2.7, »Quick Fix und Quick Assist«).

89

2.2

2

Funktionen der ABAP Development Tools

Abbildung 2.20 Markierung einer fehlerhaften Zeile

View »Problems« Versuchen Sie testweise, die Klasse mit der Tastenkombination (Strg) + (F3) zu aktivieren. Sie erhalten die Meldung, dass Eclipse die Klasse nicht aktivieren konnte. Zudem wird der View Problems eingeblendet (siehe Abbildung 2.21). Hier finden Sie analog zum Fehlerprotokoll in der ABAP Workbench eine Liste der aktuellen Aktivierungsfehler. Ein Doppelklick auf die Fehlermeldung bringt Sie direkt zur fehlerhaften Zeile im Quellcode. Sollte Ihnen die Problemsicht nicht angezeigt werden, können Sie diese jederzeit über Window 폷 Show View 폷 Problems einblenden.

Abbildung 2.21 Problemsicht

Klasse implementieren Implementieren wir nun die fehlenden Methoden: 1. Fügen Sie im Implementierungsteil der Klasse den Quelltext aus Listing 2.6 ein. METHOD constructor. DATA: ls_issue TYPE ZISSUE. IF if_issue IS NOT INITIAL. CALL FUNCTION 'Z_READ_SINGLE_ISSUE' EXPORTING if_issue_id = if_issue IMPORTING es_issue = ls_issue EXCEPTIONS no_issue_found = 1 . IF sy-subrc 0. RAISE no_issue_found.

90

Mit Entwicklungsobjekten arbeiten

ENDIF. ENDIF. me->set_issue( ls_issue ). ENDMETHOD. METHOD GET_ISSUE. rs_issue = me->ms_issue. ENDMETHOD. METHOD SET_ISSUE. me->ms_issue = is_issue. ENDMETHOD. Listing 2.6 Implementierung der Klasse ZCL_ISSUE

2. Aktivieren Sie die Klasse mit der Tastenkombination (Strg) + (F3). Eclipse speichert alle Änderungen Ihrer Klasse vor dem Aktivieren. Drücken Sie (F8), um die Klasse zu testen. Sie landen in der gewohnten ABAP-Objects-Testumgebung im Object Builder.

View »Outline« Die quelltextbasierte Sicht kann gerade bei umfangreicheren Implementierungen leicht unübersichtlich werden. Eclipse bietet daher den View Outline (Gliederung). In dieser Sicht sehen Sie eine schematische Übersicht der inneren Struktur Ihres Entwicklungsobjekts. Im Falle unserer neuen Klasse werden Ihnen der Constructor sowie die Methoden und das Attribut MS_ ISSUE angezeigt (siehe Abbildung 2.22). Falls der Outline-View bei Ihnen nicht von Anfang an sichtbar ist, können Sie ihn mit der Tastenkombination (ª) + (Alt) + (Q), gefolgt von der Taste (O), öffnen.

Abbildung 2.22 Outline der Klasse ZCL_ISSUE

Sie können die Elemente alphabetisch sortieren ( ), nur öffentliche Elemente anzeigen lassen ( ) oder alle Elemente außer den Methoden ausblenden ( ). Abbildung 2.23 gibt Ihnen eine Übersicht über die wichtigsten Elemente, die in einer Klasse vorkommen können.

91

2.2

2

Funktionen der ABAP Development Tools

Abbildung 2.23 Verschiedene Elemente in der Outline

Mit einem Klick auf einen Eintrag in der Outline springen Sie zur entsprechenden Implementierung im Quelltext-Editor. Möchten Sie zur Definition springen, markieren Sie zunächst das gewünschte Element in der Outline und drücken anschließend (Strg) + (F3). Befinden Sie sich im Quelltext-Editor, können Sie ebenfalls zwischen Implementierung und Definition hin und her springen. Klicken Sie dazu mit gedrückter (Strg)-Taste auf den Namen eines Elements. Der Cursor springt dann von der Definition in die Implementierung oder umgekehrt. Alternativ setzen Sie den Cursor auf das Element und drücken (F3) oder nutzen das Kontextmenü über die rechte Maustaste. Verschiedene Navigationsmöglichkeiten Für viele Aktionen in Eclipse gibt es mehr als eine Möglichkeit, sie auszuführen. Es schadet nicht, mehrere davon zu kennen, damit Sie je nach Situation die effizienteste einsetzen können. Nutzen Sie am besten die Option, die für Sie am komfortabelsten bzw. einprägsamsten ist.

2.2.5

ABAP-Programme erstellen

Der Umgang mit Programmen unterscheidet sich im Grunde nicht sehr von dem mit Klassen und Funktionsbausteinen, allerdings ist es häufiger notwendig, in das SAP GUI abzuspringen. Das liegt unter anderem daran, dass das Augenmerk bei den ADT mehr auf aktuelleren Techniken wie ABAP Objects und Web Dynpro ABAP liegt. Das Programm, das wir im Folgenden erstellen, dient dazu, eine Liste von Issues anzuzeigen: 1. Markieren Sie das Paket Z_ISSUE_LIST im Project Explorer, und legen Sie mit der Tastenkombination (Strg) + (N) ein neues ABAP Program an.

92

Mit Entwicklungsobjekten arbeiten

2. Nennen Sie diesen neuen Report »Z_ISSUE_LIST«. Vergeben Sie eine aussagekräftige Beschreibung. 3. Ordnen Sie das Programm dem Transportauftrag für die Aufgabenliste zu, und beenden Sie die Anlage. 4. Öffnen Sie den neuen Report mit einen Doppelklick auf Z_ISSUE_LIST im Project Explorer. Im Editor ersetzen Sie den generierten Programmrumpf durch das Coding aus Listing 2.7. REPORT z_issue_list. DATA: gs_issue TYPE zissue, gt_issue TYPE TABLE OF zissue, gr_grid TYPE REF TO cl_gui_alv_grid. SELECT-OPTIONS: s_id FOR gs_issue-issue_id, s_prj FOR gs_issue-project_id, s_state FOR gs_issue-state NO intervals, s_erdat FOR gs_issue-erdat. START-OF-SELECTION. PERFORM select_issues TABLES gt_issue. END-OF-SELECTION. PERFORM display_issue_list. FORM select_issues TABLES t_issues STRUCTURE gs_issue. SELECT * FROM zissue INTO TABLE t_issues WHERE issue_id IN s_id AND project_id IN s_prj AND state IN s_state AND erdat IN s_erdat. ENDFORM. FORM display_issue_list. CREATE OBJECT gr_grid EXPORTING i_parent = cl_gui_container=>default_screen. GR_GRID->set_table_for_first_display( EXPORTING i_structure_name = 'ZISSUE' CHANGING it_outtab = gt_issue ). CALL SCREEN 0100. ENDFORM. Listing 2.7 Report Z_ISSUE_LIST

5. Drücken Sie (Strg) + (S), um Ihre Änderung zu sichern.

93

2.2

2

Funktionen der ABAP Development Tools

Leider ist es nicht möglich, ein Dynpro innerhalb der ADT zu erstellen, daher legen wir die Benutzeroberfläche im SAP GUI an. Klicken Sie mit der rechten Maustaste im Quelltext auf die Anweisung CALL SCREEN, und wählen Sie Open with 폷 SAP GUI im Kontextmenü. Die entsprechenden Stelle im Quelltext wird im SAP GUI geöffnet. 1. Klicken Sie doppelt auf die Dynpro-Nummer 0100 im Quelltext, um das Dynpro per Vorwärtsnavigation anzulegen. 2. Speichern Sie, und schließen Sie das SAP GUI. 3. Aktivieren Sie alle Objekte mittels (ª) + (Strg) + (F3). Nun können Sie den Report wie üblich über die Funktionstaste (F8) ausführen und testen. Wenn Sie schon Issues über die Funktionsbausteine angelegt haben, können Sie diese nun mithilfe des Reports anzeigen. Starten Sie den Report, fällt auf, dass die Bezeichner der Select Options noch fehlen. Leider können Sie diese Texte nicht direkt in Eclipse pflegen. Allerdings können Sie direkt an die Selektionstextpflege im SAP GUI springen: 1. Klicken Sie mit der rechten Maustaste auf eine Select Option im Quelltext, und wählen Sie im Kontextmenü Open others 폷 Textelements. 2. Auf der Registerkarte Selection Texts können Sie wie gewohnt die Bezeichner austauschen (siehe Abbildung 2.24). Für unsere Zwecke genügt es, die Bezeichner aus dem ABAP Dictionary zu übernehmen. Markieren Sie dazu die Checkbox in der Spalte Dictionary.

Abbildung 2.24 Selektionstexte anpassen

Als Nächstes strukturieren wir unseren Report ein wenig und lagern die Datendeklarationen in ein Top-Include aus: 1. Legen Sie ein neues Include an. Markieren Sie dazu das Paket Z_ISSUE, und verwenden Sie die Tastenkombination (Strg) + (N), bzw. wählen Sie Neu 폷 ABAP Repository Object im Kontextmenü.

94

Mit Entwicklungsobjekten arbeiten

2. Wählen Sie den Eintrag ABAP Include aus der Objektliste. 3. Nennen Sie das neue Include »Z_ISSUE_LIST_TOP«, und vergeben Sie eine aussagekräftige Beschreibung. 4. Kopieren Sie den Deklarationsteil aus dem Report Z_ISSUE_LIST im Editor-View in das neue Include, und aktivieren Sie dieses ((Strg) + (F3)). Das Include sollte nun den Code aus Listing 2.8 enthalten. REPORT z_issue_list. DATA: gs_issue TYPE zissue, gt_issue TYPE TABLE OF zissue, gr_grid TYPE REF TO cl_gui_alv_grid. Listing 2.8 Inhalt von Z_ISSUE_LIST_TOP

5. Ersetzen Sie den Deklarationsteil des Reports Z_ISSUE_LIST durch den folgenden Code, und aktivieren Sie den Report: INCLUDE zissue_list_top.

Wenn Sie den Report nun über die Funktionstaste (F8) testen, sollte er wie bisher funktionieren. Diese Methode, Includes anzulegen, ist nicht die schnellste. Im Verlauf dieses Kapitels werden Sie den Report noch weiter strukturieren und eine deutlich schnellere Methode kennenlernen, Includes zu erstellen. Die Struktur des Reports soll schließlich wie in Abbildung 2.25 aussehen. Mit einem Klick auf eines der Elemente können Sie in den zugehörigen Quelltext navigieren.

Abbildung 2.25 Struktur des Reports Z_ISSUE_LIST

95

2.2

2

Funktionen der ABAP Development Tools

2.3

Code-Vervollständigung

Es ist schon häufig passiert, dass ein Kunde oder ein Kollege mir beim Entwickeln über die Schulter geschaut hat und mich verwundert fragte, wie ich so schnell den Methodennamen eintippen konnte oder woher auf einmal die Liste aller Felder einer Struktur gekommen ist. Die Code-Vervollständigung ist eine Funktion, die in der Programmierwelt außerhalb von SAP-Systemen schon lange zum Standard gehört. Im SAP NetWeaver AS ABAP hat diese Funktion mehr oder weniger unbemerkt erst mit dem Release 7.02 und SAP GUI 7.10 Einzug gehalten. Als ich mit der ABAP-Entwicklung begonnen habe, war ich das Arbeiten mit Entwicklungsumgebungen wie Eclipse, NetBeans IDE oder Microsoft Visual Studio gewöhnt. Bei diesen Programmen ist die Code-Vervollständigung bzw. Code Assist schon seit Jahren Standard. Daher war es auch dieses Feature, das ich am schmerzlichsten vermisst habe. Dementsprechend froh war ich, als die Funktion in der SAP-Umgebung Einzug hielt. Der Vorteil der Code-Vervollständigung liegt auf der Hand. Es ist nahezu unmöglich, alle Methodennamen oder Feldnamen einer Struktur im Kopf zu behalten. Deshalb ist man immer wieder gezwungen, andere Entwicklungsobjekte zu öffnen und nachzusehen. Sind Sie nicht gerade mit einem Arbeitsplatz mit mehreren Bildschirmen gesegnet, bedeutet das viel hin- und hernavigieren bzw. viele Fensterwechsel, d. h., Sie sind gezwungen, Ihren Arbeitsrhythmus zu unterbrechen. Sie kommen aus dem Fluss (oder Flow, wie es neudeutsch heißt). Und selbst mit mehreren Monitoren oder wenn Sie ein ausgezeichnetes Gedächtnis haben, können sich immer wieder Tippfehler einschleichen. Autovervollständigung in Eingabefeldern Die Tastenkombination (Strg) + Leertaste ersetzt in Eclipse zum Teil die SuchhilfeTaste (F4) im SAP GUI. Eingabefelder, die diese Funktion bieten, sind meistens mit einer kleinen Glühbirne gekennzeichnet (siehe Abbildung 2.26). Ansonsten arbeitet diese Funktion genau wie die Code-Vervollständigung.

Abbildung 2.26 Eingabefeld mit Autovervollständigung

Obwohl diese Funktion im SAP GUI verfügbar ist, wird sie häufig nicht angewandt – entweder, weil Entwickler gar nicht wissen, dass es diese Funktion überhaupt gibt, oder aus Gewohnheit. Ich empfehle Ihnen, unabhängig

96

Code-Vervollständigung

davon, ob Sie künftig ausschließlich in Eclipse entwickeln oder der ABAP Workbench treu bleiben, die Anwendung dieser Funktion in Ihre Arbeitsabläufe zu integrieren.

2.3.1

Einfache Code-Vervollständigung

Die Code-Vervollständigung funktioniert in der ABAP Workbench und in Eclipse genau gleich. Sie verwenden die Code-Vervollständigung, indem Sie den Cursor im Quelltext positionieren und (Strg) + Leertaste drücken. Sie erhalten eine Liste von Vorschlägen, basierend auf Ihrer aktuellen Eingabe. Nehmen wir an, der Code beinhaltet eine Variable gr_grid vom Typ cl_gui_ alv_grid. Geben Sie nun »gr_grid->« ein, und drücken Sie die Tasten (Strg) + Leertaste, erhalten Sie eine Liste aller verfügbaren Methoden dieser Klasse. Sollen Ihnen nur die Setter-Methoden angezeigt werden, geben Sie »gr_grid>set« ein und drücken dann die Tasten (Strg) + Leertaste. Die Liste wird daraufhin automatisch auf Methoden eingeschränkt, die mit SET beginnen. Zudem werden Ihnen noch die Signatur und die Kurzbeschreibung der Methoden eingeblendet. Ihre Auswahl können Sie mit der (¢)- oder Tabulatortaste übernehmen. Bei Methoden- oder Funktionsbausteinaufrufen ist gerade die Signatur schwierig zu merken. Dabei hilft Ihnen ebenfalls die Code-Vervollständigung. Haben Sie eine Auswahl aus der Vorschlagsliste getroffen, übernehmen Sie diese dazu nicht einfach mit der Taste (¢), sondern mit der Tastenkombination (ª) + (¢). Neben dem Namen des Objekts wird damit dessen vollständige Signatur in den Quelltext eingefügt (siehe Abbildung 2.27). Optionale Parameter sind dabei zunächst auskommentiert. Diese Funktion ähnelt dem Einfügen über den Pfad Muster 폷 CALL FUNCTION bzw. ABAP Objects aus der ABAP Workbench, ist aber deutlich schneller anzuwenden.

Abbildung 2.27 Code-Vervollständigung in der ABAP Workbench

Funktioniert die Code-Vervollständigung bei Ihnen in der Workbench trotz passender Server-Version und passenden SAP GUIs nicht, kann es sein, dass

97

2.3

2

Funktionen der ABAP Development Tools

Sie diese noch aktivieren müssen. Die Einstellung im SAP GUI hat keinen Einfluss auf Ihre Eclipse-Entwicklungsumgebung. Wenn Sie die Code-Vervollständigung in der ABAP Workbench deaktiviert haben, können Sie diese in Eclipse daher trotzdem nutzen. Um die Funktion in Eclipse zu verwenden, müssen Sie sich nicht einmal an andere Tastenkombinationen gewöhnen, sondern können die gleichen verwenden wie in der ABAP Workbench. Abbildung 2.28 zeigt die Vorschlagsliste und eine Methodensignatur in Eclipse.

Abbildung 2.28 Code-Vervollständigung in Eclipse

2.3.2

Code-Vorlagen

Code-Vorlagen haben ebenfalls das Potenzial, Ihnen eine Menge Tipparbeit zu ersparen. Bei diesen Vorlagen handelt es sich um Quelltextschnipsel, die bei Bedarf einfach in den Programm-Code eingefügt werden können. Jedem dieser Schnipsel wird ein eindeutiges Schlüsselwort zugewiesen. Geben Sie dies im Editor ein, sorgt Eclipse dafür, dass es durch den entsprechenden Code-Schnipsel ersetzt wird. Diese Schlüsselworte tauchen in der EclipseCode-Vervollständigung auf, wenn Sie diese mit der Tastenkombination (Strg) + Leertaste aufrufen. Der einfachste Weg, Code-Vorlagen zu erstellen und zu bearbeiten, geht über den View Templates. Wie alle anderen Views finden Sie diesen View im Menü unter Window 폷 Show View 폷 Other. Die Code-Vorlagen finden Sie unter General 폷 Templates und darüber hinaus in den Einstellungen von Eclipse. Dazu wählen Sie im Hauptmenü den Pfad Window 폷 Preferences. Im Dialogfenster Preferences wechseln Sie dann in den Bereich ABAP Development 폷 Editors 폷 Source Code Editors 폷 Templates (siehe Abbildung 2.29). Hier können Sie Vorlagen (Templates) exportieren, importieren und bearbeiten.

98

Code-Vervollständigung

Abbildung 2.29 Einstellungen der Code-Vorlagen

Es wird bereits eine kleine Auswahl an Vorlagen mit den ADT ausgeliefert, Sie können aber auch sehr einfach eigene Templates anlegen und verwenden: 1. Öffnen Sie den View Templates, und wählen Sie im Menü des Views das Icon Create new Template ( , siehe Abbildung 2.30).

Abbildung 2.30 Neue Code-Vorlage anlegen

99

2.3

2

Funktionen der ABAP Development Tools

2. Als Beispiel erstellen wir ein Template mit dem Namen HELLO_WORLD. Idealerweise sollte die Beschreibung den Inhalt des Templates kurz zusammenfassen. Sie wird später in der Code-Vervollständigung angezeigt. Als Pattern geben Sie »WRITE 'Hello World'.« ein (siehe Abbildung 2.31). Bestätigen Sie die Anlage mit OK.

Abbildung 2.31 Code für die Vorlage eingeben

Sie können Ihre Vorlage jetzt überall in Ihrem ABAP-Code verwenden. Achten Sie darauf, dass es für die Web-Dynpro-Entwicklung einen eigenen Kontext gibt, den Sie bei der Anlage im Feld Context auswählen können. Öffnen Sie zum Testen der Funktion einen eigenen ABAP-Report (z. B. Ihr Programm Z_HELLO_WORLD). Geben Sie im Quelltext-Editor »HELLO« ein, und drücken Sie (Strg) + Leertaste. Ihre Code-Vorlage sollte nun in der Vorschlagsliste der Code-Vervollständigung zur Auswahl stehen (siehe Abbildung 2.32). Sie können diesen Code-Schnipsel einfach mit (¢) einfügen.

Abbildung 2.32 Code-Vervollständigung mit Template

Unser erster Code-Schnipsel wird bei Ihrer täglichen Arbeit wohl eher selten zum Einsatz kommen. Außerdem handelt es sich nur um ein statisches Stück

100

Code-Vervollständigung

Text, das in den Quelltext eingefügt wird. Schauen wir uns daher als Nächstes an, wie Sie Templates etwas nützlicher gestalten können: 1. Markieren Sie im Editor-View den neu eingefügten Quelltext WRITE 'Hello World'.

2. Suchen im View Template nach dem Standard-Template ifElse, und klicken Sie doppelt auf diesen Eintrag. Alternativ können Sie auch mit der rechten Maustaste auf den Eintrag klicken und den Kontextmenüeintrag Insert wählen (siehe Abbildung 2.33).

Abbildung 2.33 Einfügen einer Code-Vorlage über den View »Templates«

3. Ihr Code sollte nun wie in Abbildung 2.34 aussehen. Eclipse hat das Template eingefügt, das Sie ausgewählt haben. Bei diesem Template wird der markierte Text nicht überschrieben, stattdessen wird die Markierung in den Quelltext der Vorlage integriert. Zudem wurde der Ausdruck expr markiert.

Abbildung 2.34 Eingefügte Code-Vorlage

4. Geben Sie anstelle von expr einen sinnvollen Ausdruck, z. B. »sy-subrc = 0«, ein.

101

2.3

2

Funktionen der ABAP Development Tools

5. Drücken Sie die Tabulatortaste. Die Eingabemarke springt zum Text elseblock und markiert diesen vollständig. 6. Geben Sie anstelle von »elseblock« einen beliebigen Ausdruck, z. B. »WRITE 'Fehler'.«, ein. 7. Bestätigen Sie wieder mit der Tabulatortaste. Die Eingabemarke steht nun hinter dem Code-Block WRITE 'Hello World'. Um zu verstehen, wie die interaktive Code-Vorlage funktioniert, sehen Sie sich das Template ifElse einmal genauer an. Wählen Sie es dazu mit der rechten Maustaste im Template-View aus, und klicken Sie auf Edit. Sie gelangen in den Template-Editor. Das Pattern für dieses Template wird Ihnen wie in Listing 2.9 angezeigt. if ${expr}. ${word_selection}${cursor} else. ${elseblock} endif. Listing 2.9 Pattern des ifElse-Templates

Sie sehen hier zum einen syntaktisch korrektes ABAP, zum anderen Ausdrücke wie ${cursor}, die bei der Aktivierung in jedem System zu Fehlern führen würden. Bei diesen Ausdrücken handelt es sich um Variablen, die durch die Entwicklungsumgebung verarbeitet werden. Der Ausdruck ${cursor} sorgt z. B. dafür, dass der Cursor nach der Template-Bearbeitung an die Stelle positioniert wird, an der der Ausdruck steht. Tabelle 2.4 enthält eine Übersicht aller derzeit verfügbaren Variablen. Im Template-Editor finden Sie die Schaltfläche Insert Variable, über die Ihnen alle unterstützen Variablen zum Einfügen angeboten werden. Variable

Funktion

${cursor}

Markiert die Position des Cursors nach dem Einfügen des Templates.

${date}

aktuelles Datum

${dollar}

Setzt das $-Symbol. Wird dieses Symbol eingefügt, interpretiert Eclipse die Eingabe als Variable.

${enclosing_object}

Name des aktuellen Objekts. Wird das Template z. B. in eine Klasse eingefügt, enthält ${enclosing_ object} den Namen dieser Klasse.

Tabelle 2.4 Variablen für Code-Vorlagen

102

Code-Vervollständigung

Variable

Funktion

${enclosing_package}

Paket, in dem sich das aktuelle Objekt befindet

${line_selection}

aktuelle Selektion (äquivalent zu ${word_ selection})

${system_id}

aktuelle System-ID (sy-sysid)

${time}

aktuelle Systemzeit

${user}

aktuell angemeldeter Benutzer

${word_selection}

Aktuelle Selektion. Diese Variable funktioniert nur, wenn sie über den Template-View eingefügt wird.

${year}

aktuelles Jahr

Tabelle 2.4 Variablen für Code-Vorlagen (Forts.)

Das ifElse-Template enthält zudem noch die Ausdrücke ${expr} und ${elseblock}. Diese Variablen werden nicht automatisch durch Eclipse befüllt, sondern es handelt sich um benutzerdefinierte Variablen, die Sie beim Einfügen des Templates von Hand befüllen können. Diese werden im Quelltext-Editor mit einem Kasten umrahmt. Sie können, wie im Beispiel gesehen, mit der Tabulatortaste von einer Variablen zur nächsten springen und diese mit einer eigenen Eingabe belegen. Wird eine Variable mehrfach verwendet, müssen Sie diese nur einmal belegen. Überall, wo diese Variable im Template auftaucht, wird dieser Wert eingesetzt. Vergeben Sie für Variablen möglichst einen Namen, der gleichzeitig auch als Default-Wert funktionieren kann. Geben Sie beim Einfügen des Templates nämlich keinen Wert für eine Variable ein, bleibt der Name der Variablen stehen. Ist kein Default-Wert möglich, vergeben Sie einen aussagekräftigen Namen. Listing 2.10 zeigt ein Beispiel, in dem mehrfach die gleiche Variable verwendet wird. DATA: lt_${structure} TYPE TABLE OF ${structure}, ls_${structure} TYPE ${structure}. LOOP AT lt_${structure} INTO ls_${structure}. ${cursor} ENDLOOP. Listing 2.10 Loop auf Struktur

Überlegen Sie einmal, welche Code-Schnipsel Sie immer wieder in mehr oder weniger gleicher Form über die Tastatur eingeben. Dabei muss es sich

103

2.3

2

Funktionen der ABAP Development Tools

nicht unbedingt nur um Code handeln – ich nutze Code-Vorlagen z. B., um meine Programme zu dokumentieren. Dazu müssen Sie sich nur einmal ein Format für einen Kommentarkopf ausdenken und können dieses dann in eine Vorlage gießen, die immer gleich aussieht und immer die gleichen Informationen enthält. Wichtige Informationen wie das aktuelle Datum oder Ihr Benutzername werden sogar automatisch befüllt. Ein anderes Einsatzbeispiel ist das Initialisieren von ALV-Listen (SAP List Viewer). Die Grundstruktur ist dabei immer gleich, es ändern sich nur wenige Variablennamen. Mithilfe einer Code-Vorlage können Sie die nächste ALV-Liste mit nur einem Befehl anlegen. Sie können die Code-Vorlagen auch als Gedächtnisstütze verwenden. Sie haben vergessen, wie die Klasse und der Befehl zum Auslesen von OTR-Texten (OTR = Online Text Repository) heißen? Wenn Sie ein Template mit dem Namen &OTR anlegen, müssen Sie sich das nicht mehr merken. Im Downloadbereich zu diesem Buch habe ich einige Vorlagen zusammengetragen, die Ihnen bei der täglichen Arbeit helfen können. Viele davon habe ich im täglichen Einsatz und freue mich jedes Mal, wenn ich etwas Tipparbeit spare. Um einen Vorteil aus diesem Feature zu ziehen, müssen Sie es nur anwenden. Ein Template anzulegen bedeutet zunächst einmal einen gewissen Mehraufwand. Wenn Sie die Vorlagen aber konsequent verwenden – es gehört eine gewisse Disziplin dazu, dies zu tun –, vereinfachen Sie sich gerade die Durchführung immer wiederkehrender Codierungsarbeiten. Code-Vorlagen im SAP GUI Die ABAP Workbench bietet eine ähnliche Funktion zur Code-Vervollständigung. Allerdings ist die Auswahl der zur Verfügung stehenden Variablen (hier Tags genannt) etwas geringer. Sie können Ihre Vorlagen in den Optionen des Editors ( ) in der ABAP Workbench bearbeiten.

2.4

Quelltext-Editor

Bei der Entwicklung der ADT wurde viel Wert darauf gelegt, den Umstieg von der ABAP Workbench so einfach wie möglich zu gestallten. So wurden etwa viele der Tastenkombinationen aus der ABAP Workbench genauso in Eclipse übernommen und viele der Icons beibehalten. Allerdings unterscheidet sich das Bedienprinzip von Eclipse von dem des SAP GUIs. In Kapitel 1, »Die ersten Schritte – »Hallo ADT««, habe ich die grundsätzliche Funktionsweise von Eclipse bereits kurz erklärt. Nun zeige ich Ihnen, wie Sie Ihren

104

Quelltext-Editor

Programmieralltag in Eclipse meistern können. Dabei soll es nicht nur darum gehen, wie Sie lieb gewonnene Funktionen aus der ABAP Workbench in Eclipse verwenden können, sondern wir möchten auch Profit aus den geänderten Bedienkonzepten schlagen und die Arbeitsabläufe optimieren.

2.4.1

Aufbau

Auf den ersten Blick ähnelt der Eclipse-Editor dem Editor der ABAP Workbench stark. Beide zeigen im Wesentlichen Quelltext an, bieten Syntax-Highlighting und verstehen Basiskommandos wie das Kopieren, Ausschneiden und Einfügen. Darüber hinaus bieten beide Editoren teilweise unscheinbare Funktionen, die selbst erfahrenen Entwicklern erst auffallen, wenn man sie darauf aufmerksam macht. Viele davon werden Sie nicht mehr missen wollen, wenn Sie sie einmal benutzt haben. Zum Vergleich schauen wir uns erst kurz die bekannten Funktionen des SAP GUIs an. Abbildung 2.35 zeigt einige der visuellen Hilfestellungen aus dem Editor der ABAP Workbench. Als Erstes fällt auf, dass der Editor eine Zeilennummerierung bietet 1. Dies mag banal erscheinen, hilft aber ungemein dabei, sich im Quelltext zu orientieren oder mit Kollegen über bestimmte Code-Stellen zu diskutieren.

Abbildung 2.35 Visuelle Hilfestellungen im ABAP Workbench Editor

105

2.4

2

Funktionen der ABAP Development Tools

Ein unscheinbares, aber ebenfalls praktisches Feature ist die Code-Faltung (Code Folding 2). Sie erkennen sie an dem kleinen Plus- bzw. Minuszeichen am linken Rand des Quelltextes. Mit einem Klick auf dieses Symbol können Code-Abschnitte zusammen- bzw. auseinandergeklappt werden, was mit den meisten Code-Blöcken in ABAP funktioniert. Dazu gehören neben den in der Abbildung dargestellten Form-Routinen auch Methoden, Schleifen, Konditionalblöcke und mehrzeilige Kommentare. Das Code Folding ist besonders bei längeren unübersichtlichen Code-Passagen sehr praktisch, denn Code-Teile, die Sie im Augenblick nicht interessieren, können Sie einfach ausblenden. Setzen Sie den Cursor an den Beginn eines Code-Blocks, werden das einleitende und das beendende Schlüsselwort des Code-Blocks hervorgehoben. Dies ist sehr praktisch, wenn Sie sich durch stark verschachtelte Strukturen arbeiten müssen. Die aktuelle Verschachtelung an der sich der Cursor gerade befindet, wird Ihnen unter 3 angezeigt. Eine weitere Funktion, die sich erfolgreich der Wahrnehmung entzieht, ist die Markierung neuer bzw. geänderter Zeilen. Diese werden mit einem kleinen roten Dreieck gekennzeichnet 4. Haben Sie sich beim Codieren verrannt und sind sich nicht sicher, was Sie geändert haben bzw. ob Sie alle Änderungen sichern möchten, helfen Ihnen diese Markierungen (gerade bei umfangreicheren Ressourcen) bei der Orientierung. Diese kleinen Helfer können Sie auch in den ADT finden. Möglicherweise werden Ihnen im Eclipse-Quelltext-Editor zunächst die Zeilennummern (1 in Abbildung 2.35) nicht angezeigt. Sie können sie einblenden, indem Sie mit der rechten Maustaste auf die Leiste am linken Rand des Editors klicken und Show Line Numbers wählen (siehe Abbildung 2.36).

Abbildung 2.36 Zeilennummern einblenden

106

Quelltext-Editor

Abbildung 2.37 Visuelle Hilfestellungen im Eclipse-Quelltext-Editor

Genau wie in der ABAP Workbench können zusammengehörige Blöcke über das Code Folding komprimiert dargestellt werden (2 in Abbildung 2.37). Bewegen Sie die Maus über das Minuszeichen, zeigt eine dünne Linie an, welche Zeilen zum aktuellen Block gehören. Bei zusammengeklappten Code-Blöcken wird Ihnen der Inhalt kurz eingeblendet. Markieren Sie das einleitende Schlüsselwort des Code-Blocks, werden Beginn und Ende des Blocks hervorgehoben. Die Brotkrumen-Navigation (Breadcrumb 3) zeigt, in welchem Code-Block sich der Cursor derzeit befindet. Allerdings werden in Eclipse keine Schleifen oder Kontrollblöcke angezeigt, sondern nur Programme, Klassen, Methoden und Form-Routinen. Es handelt sich jedoch nicht nur um eine Anzeige wie in der ABAP Workbench, sondern um eine Navigation inklusive Suchfunktion. Diese Navigationsleiste können Sie über die Tastenkombination (ª) + (Alt) + (B) bzw. in der Menüleiste über das Icon Toggle Breadcrumb ( ) ein- und ausblenden. Die Nummern der Code-Zeilen, die Sie in der aktuellen Sitzung geändert haben, werden farblich markiert. Diese Funktion nennt sich in Eclipse Quick Diff. Sie lässt sich genau wie die Zeilennummerierung über das Kontextmenü

107

2.4

2

Funktionen der ABAP Development Tools

ein- und ausschalten. Weitere Einstellungen zu Quick Diff (z. B. die Farbe der Hinterlegung) können Sie unter Window 폷 Preferences 폷 General 폷 Editors 폷 Text Editors 폷 Quick Diff vornehmen. Sie haben hier sogar die Möglichkeit, unterschiedliche Farben für neue, geänderte und gelöschte Zeilen zu hinterlegen.

2.4.2

Lokale Änderungshistorie

Die Funktion Quick Diff ist schon recht praktisch, um eine Übersicht über Änderungen zu behalten. Was Sie während einer Arbeitssitzung geändert haben, können Sie jedoch nicht einsehen. Die ABAP Workbench erlaubt nur Vergleiche zwischen aktiver und inaktiver Version des Quelltextes sowie zu alten Versionen aus Transportaufträgen. (Dies ist in Eclipse über den View Transport Organizer ebenfalls möglich.) Eclipse sendet die durchgeführten Änderungen am Code nicht nur an das Backend-System, sondern hält sie zusätzlich lokal vor. Dabei wird nicht nur die aktuelle Version gepuffert, sondern auch eine Versionshistorie aufgebaut. Sie können diese einsehen und sogar Änderungen aus der Historie wiederherstellen. Um die Funktion aufzurufen, klicken Sie mit der rechten Maustaste in den Quelltext des entsprechenden Objekts und wählen Compare with 폷 Local History. Daraufhin öffnet sich der View History. Hier sehen sie alle Versionen, die Eclipse zu dem gewählten Objekt vorhält (siehe Abbildung 2.38). Die aktuell angezeigte Version ist fett ausgezeichnet.

Abbildung 2.38 Lokale Änderungshistorie des Funktionsbausteins Z_READ_SINGLE_ISSUE

Klicken sie doppelt auf einen Eintrag, öffnet sich ein Vergleichseditor (siehe Abbildung 2.39). Auf der linken Seite sehen Sie die aktuelle Version, auf der rechten die gesicherte Historie. Mit Verbindungslinien werden Unterschiede zwischen den Versionen angezeigt. Sie können zwischen den Änderungen hin und herspringen ( , , , ) und auch einzelne ( ) oder alle Änderungen ( ) zurücknehmen. Letzteres funktioniert allerdings nur, wenn die Rücknahme konfliktfrei möglich ist.

108

Quelltext-Editor

Abbildung 2.39 Lokaler Versionsvergleich

2.4.3

Lineale und Markierungen

Neben den Hilfestellungen, die auch in der ABAP Workbench verfügbar sind, bietet Eclipse einige weitere Funktionen, dank derer Sie sich schneller im Quelltext zurechtfinden können. Eine davon haben Sie schon in Abschnitt 2.2.4, »Klassen«, kennengelernt, die Markierung von Syntaxfehlern. Das Glühbirnen-Symbol ( ) wird in diesem Kontext als Annotation (Anmerkung) bezeichnet. Von diesen Annotationen gibt es eine ganze Reihe in Eclipse. Eine Übersicht der Symbole finden Sie in den Einstellungen unter Window 폷 Preferences 폷 General 폷 Editors 폷 Text Editors 폷 Annotations. Wie Sie in Abbildung 2.40 sehen, befinden sich auf der linken und rechten Seite neben dem Editor zwei schmale Leisten (Lineale). Das Lineal auf der linken Seite ist der sogenannte Vertical Ruler 1. Auf der rechten Seite finden Sie den Overview Ruler 2. Die Markierungen auf dem Vertical Ruler beziehen sich jeweils unmittelbar auf die Quelltextzeile, die daneben angezeigt wird. Scrollen Sie im QuelltextEditor nach oben oder unten, verschiebt sich der Vertical Ruler parallel. Standardmäßig finden Sie auf dem Vertical Ruler Annotationen 3 für Syntaxfehler ( ), Breakpoints ( ) oder Lesezeichen ( ), wie auch auf der Leiste links im Editor der ABAP Workbench. Rechts neben dem Quelltext befindet sich der Overview Ruler (Übersichtslineal). Im Gegensatz zum Vertical Ruler bewegt sich dieses Lineal nicht mit,

109

2.4

2

Funktionen der ABAP Development Tools

wenn Sie scrollen. Es repräsentiert vielmehr den Quelltext in einer komprimierten Form. Die Annotationen 4, die hier angezeigt werden, beziehen sich daher nicht auf die Quelltextzeile direkt daneben, sondern auf die relative Position der Code-Stelle im Quelltext. Der Overview Ruler bietet besonders bei sehr umfangreichen Quelltexten eine gute Möglichkeit, die Übersicht zu behalten.

Abbildung 2.40 Annotationen in Eclipse

Sie können konfigurieren, was Sie auf dem Overview Ruler sehen möchten. Öffnen Sie eine umfangreichere Klasse wie ZCL_ISSUE (oder CL_SFLIGHTAR_ HDS, wenn Sie ein komplexeres Beispiel möchten), und testen Sie die Möglichkeiten (siehe Abbildung 2.41). Sehr praktisch ist es z. B., sich Anfang und Ende des markierten Blocks anzeigen zu lassen (Annotationstyp ABAP Block Highlighting). Wenn Sie den Cursor auf einen Variablennamen setzen, werden alle Stellen, an denen diese Variable vorkommt, direkt im Quelltext sowie auf dem Overview Ruler hervorgehoben. Dies können sie unter ABAP Occurence und ABAP Write Occurences einstellen. Neben diesen Icons gibt es noch sogenannte Textannotationen 5, d. h. Markierungen, die sich direkt auf den Quelltext beziehen. Die Schlüsselwortmarkierung bei Blöcken etwa ist ein Beispiel für eine Textannotation. Eine Textannotation kann aber auch wie die Rechtschreibprüfung bei modernen Textverarbeitungsprogrammen aussehen. Eclipse unterstreicht Syntaxfehler, wenn dies nicht anders eingestellt ist.

110

Quelltext-Editor

Abbildung 2.41 Einstellungen zu Annotationen

Rechtschreibprüfung Die Textannotationen erinnern stark an Rechtschreibprüfungen. Eclipse ist nicht nur in der Lage, Markierungen bei Syntaxfehlern zu setzen, es gibt sogar eine eingebaute Rechtschreibprüfung. Die Rechtschreibregeln werden bei normalem Quelltext selbstverständlich nicht geprüft, bei Kommentaren aber schon (siehe Abbildung 2.40). Standardmäßig ist die Rechtschreibprüfung auf Englisch eingestellt. Dies können Sie unter Window 폷 Preferences 폷 General 폷 Editors 폷 Text Editors 폷 Spelling umstellen. Derzeit ist nur Englisch als Plattform-Wörterbuch verfügbar. Sie können Deutsch aber als benutzerdefiniertes Wörterbuch hinzufügen. Eclipse erwartet dazu eine einfache Wortliste. Ein freies Wörterbuch finden Sie z. B. unter http://sourceforge.net/projects/germandict/.

Viele der Annotationen, z. B. die Kennzeichnung von Fehlern, implizieren, dass Sie an dieser Code-Stelle tätig werden müssen. Sie können daher im Editor nacheinander zu den einzelnen Annotationen navigieren. Nutzen Sie dazu die Funktionen Next Annotation ( ) bzw. Previous Annotation ( ) in der Menüleiste (siehe Abbildung 2.42). Alternativ können Sie auch die Tastenkombinationen (Strg) + (.) oder (Strg) + (,) verwenden. Wie Sie in Abbildung 2.42 sehen, können Sie im Menü auch einstellen, welche Annotationsarten Sie berücksichtigen möchten. So können Sie sich z. B.

111

2.4

2

Funktionen der ABAP Development Tools

darauf konzentrieren, nur Fehler zu korrigieren, oder von Lesezeichen zu Lesezeichen springen.

Abbildung 2.42 Zur nächsten/vorangegangenen Annotation springen

2.4.4

Navigation

Eine der bekanntesten Arbeitserleichterungen in der ABAP Workbench ist vermutlich die Vorwärtsnavigation, mit der Sie per Doppelklick direkt aus dem Quelltext zur Definition eines Objekts abspringen. Klicken Sie in Eclipse doppelt auf ein Objekt, wird dieses lediglich markiert, eine Navigation stoßen Sie damit nicht an. Aber keine Angst: Dieses praktische Feature gibt es auch in Eclipse. Drücken Sie einfach die (Strg)-Taste. Wenn Sie jetzt mit der Maus über den Namen eines Repository-Objekts oder einer Variable fahren, wird dieses als Hyperlink dargestellt. Ein Klick auf diesen Link öffnet im Editor eine neue Registerkarte mit der Definition des entsprechenden Objekts. Verwirrenderweise sorgt das Drücken der (Strg)-Taste in der ABAP Workbench für das gleiche Verhalten wie der Doppelklick in Eclipse. Das angeklickte Wort wird vollständig markiert. In Abschnitt 2.2.4, »Klassen«, haben Sie bereits den View Outline kennengelernt, mit dem Sie sich in Quelltexten sehr schnell zurechtfinden und

112

Quelltext-Editor

bewegen können. Dieser View hat noch einen kleinen Bruder, die Quick Outline. Diese Funktion können Sie in einem beliebigen Editor in Eclipse mit der Tastenkombination (Strg) + (O) aufrufen. Die Quick Outline wird direkt im Editor eingeblendet und zeigt die Struktur des aktuell ausgewählten Objekts (siehe Abbildung 2.43). Sie können die Anzeige filtern und direkt zum entsprechenden Quelltext springen.

Abbildung 2.43 Quick Outline

Ähnlich wie die Zurück-Taste in Ihrem Internet-Browser ist die ZurückTaste ( bzw. (F3)) ein täglicher Begleiter bei der Arbeit in der ABAP Workbench. Natürlich bietet auch Eclipse ein Pendant zu dieser Funktion. Mit dem Zurück-Pfeil in der Toolbar von Eclipse springen Sie zum letzten EditorFenster zurück (siehe Abbildung 2.44), unabhängig davon, ob es sich um einen nativen Eclipse-Editor handelt oder um das eingebettete SAP GUI. Die Funktion ist auch über die Tastenkombination (Alt) + (æ) ausführbar. Sie haben zudem die Möglichkeit, mit (Alt) + (Æ) vorwärtszunavigieren. Für beide Richtungen können Sie über das kleine Dreieck neben dem Icon eine Navigationshistorie aufrufen und so direkt in ein bestimmtes Editor-Fenster springen.

Abbildung 2.44 Navigationsfunktionen in Eclipse

113

2.4

2

Funktionen der ABAP Development Tools

Navigiere ich durch den Quelltext einer Anwendung, kommt es oft vor, dass ich mich immer weiter in die Tiefen der verschachtelten Objekte begebe, d. h. immer weiter weg von der Stelle, an der ich eigentlich gerade arbeite. Für den Weg zurück bietet Eclipse die praktische Komfortfunktion Last Edit Location an ( ). Damit springen Sie von Ihrer aktuellen Position direkt zurück an die Stelle, die Sie zuletzt bearbeitet haben. Die Tastenkombination dazu lautet (Strg) + (Q). Mit mehreren Ressourcen arbeiten Die Navigationsfunktionen in Eclipse sind sehr nützlich, und man neigt dazu, mit ihnen zu arbeiten wie in der ABAP Workbench. Dass Sie die Navigationsfunktionen in der ABAP Workbench intensiv nutzen müssen, liegt allerdings zu einem großen Teil daran, dass im SAP GUI stets das aktuelle Fenster geschlossen wird, bevor Sie ein neues öffnen. Eclipse ist dagegen in der Lage, mehrere Editoren und SAP-GUI-Fenster gleichzeitig zu händeln, d. h., Sie verlassen Ihren Quelltext nie wirklich, sondern öffnen nur eine neue Registerkarte. Die Navigationsfunktionen lassen Sie dementsprechend nur zwischen den geöffneten Registerkarten springen, die geöffneten Fenster werden aber nicht geschlossen. In Abschnitt 2.5 besprechen wir, wie Sie mit mehreren Ressourcen gleichzeitig arbeiten können.

2.4.5

Textbearbeitung

Wer sehr viel mit (Quell-)Texten arbeitet, weiß es in der Regel zu schätzen, die Hand nicht für jede Aktion zur Maus bewegen zu müssen. Daher bieten die meisten Editoren eine Vielzahl nützlicher Funktionen, für die Sie den Nager auf Ihrem Schreibtisch nicht bemühen müssen. Die grundlegenden Tastenkombinationen wie Kopieren ((Strg) + (C)), Ausschneiden ((Strg) + (X)) oder Einfügen ((Strg) + (V)) sind Ihnen vermutlich bekannt und funktionieren in Eclipse und der ABAP Workbench gleichermaßen. Es gibt aber auch speziellere Funktionen, die das Arbeiten ungemein beschleunigen, wenn man sich deren Einsatz angeeignet hat. Leider verhalten sich diese Tastaturbefehle im SAP GUI und in Eclipse unterschiedlich. Tabelle 2.5 stellt die wichtigsten Tastenkombinationen gegenüber. Funktion

ABAP Workbench

Eclipse

Vorwärtsnavigation

Doppelklick

(Strg) + Klick; (F3)

Wort markieren

(Strg) + Klick

Doppelklick

Block markieren

(Alt) + linke Maustaste

(Alt) + (ª) + (A)

Tabelle 2.5 Tastenkürzel zum Arbeiten mit Quelltexten

114

Quelltext-Editor

Funktion

ABAP Workbench

Eclipse

Zeile duplizieren

(Strg) + (D)

(Strg) + (Alt) + (¼)/(½)

Zeile löschen

(ª) + (Strg) + (L)

(Strg) + (D)

Zeile verschieben

(Strg) + (Alt) + (¼)/(½)

(Alt) + (¼)/(½)

Auskommentieren

(Strg) + (‹)

(Strg) + (‹)

Kommentieren

(ª) + (Strg) + (‹)

(ª) + (Strg) + (‹) (Strg) + (7)

Kommentar umschalten zurückspringen

(F3)

(Alt) + (æ)

vorwärtsspringen

(Alt) + (Æ)

zur letzten Änderung springen

(Strg) + (Q)

Tabelle 2.5 Tastenkürzel zum Arbeiten mit Quelltexten (Forts.)

Tastenkombinationen einsehen Sich diese ganzen Tastenkombinationen zu merken und sie immer präsent zu haben ist schwierig. Abhilfe schafft – wie passend – ein weiteres Tastenkürzel. Sie sollten sich daher zumindest die Tastenkombination (ª) + (Strg) + (L) merken, mit der Sie eine Liste der verfügbaren Tastenkombinationen einblenden können.

Operationen, die auf ganze Zeilen angewandt werden, kommen relativ häufig vor. Dazu gehören Vorgänge wie das Löschen, Kopieren oder Verschieben einer Zeile. Sie können dies mit Maus und Tastatur tun oder die Zeile nur mit der Tastatur kopieren. Dazu benötigen Sie allerdings mehrere Arbeitsschritte: Zeile markieren, kopieren, ausschneiden oder löschen und gegebenenfalls wieder an der neuen Position einfügen. Um eine Zeile zu duplizieren, genügt es in Eclipse, den Cursor in die entsprechende Zeile zu setzen und (Strg) + (Alt) + (¼) zu drücken. Um eine Zeile zu verschieben, benutzen Sie die Tastenkombination (Alt) + (¼) bzw. (½). Das Löschen einer kompletten Zeile funktioniert mit den Tasten (Strg) + (D). Ähnliche Funktionen gibt es auch in der ABAP Workbench. Allerdings funktionieren sie hier nur mit einzelnen Zeilen, während Sie in Eclipse auch mehrere Zeilen dazu markieren können. Bildschirm drehen Bei einigen Grafikkartentreibern führt die Tastenkombination (Strg) + (Alt) + eine beliebige Pfeiltaste dazu, dass das Monitorbild gespiegelt wird. Diese Funktion können Sie in der Regel in den Einstellungen Ihres Treibers abschalten.

115

2.4

2

Funktionen der ABAP Development Tools

Ebenfalls sehr praktisch ist der Blockmodus. Normalerweise arbeiten TextEditoren zeilenorientiert, d. h., wenn Sie eine vertikale Markierung vornehmen, betrifft das immer die gesamte Zeile. In manchen Fällen möchten Sie aber vielleicht nur einen Block aus Ihrem Quelltext kopieren, z. B. eine längere Datendeklaration, aus der Sie nur die Typnamen kopieren möchten. In der ABAP Workbench können Sie eine Markierung bei gedrückter (Alt)Taste vornehmen. Dadurch ziehen Sie einen Rahmen und markieren nur die Zeichen innerhalb dieses Rahmens. Haben Sie auf diese Weise nun Typnamen kopiert, können Sie diese z. B. benutzen, um eine neue Struktur im ABAP Dictionary anzulegen und dort auf einen Schlag die Datentypen einzufügen. Seit SAP NetWeaver 7.31 funktioniert auch das blockartige Einfügen, d. h., Sie können einen kopierten Block neben Ihrem vorhandenen Quelltext einfügen. Vor diesem Release wurden kopierte Blöcke wie Zeilen behandelt, d. h., beim Einfügen wurde für jede Zeile des kopierten Blocks eine neue Zeile hinzugefügt. Eclipse verfügt über einen eigenen Modus für dieses Verhalten, den Blockmodus. Sie aktivieren diesen mit der Tastenkombination (Alt) + (ª) + (A). Solange Sie sich in diesem Modus befinden, erfolgt das Markieren, Kopieren und Einfügen blockartig (siehe Abbildung 2.45). Verlassen Sie diesen Modus, greifen diese Funktionen wieder zeilenweise (auch wenn Sie etwas einfügen, das Sie im Blockmodus markiert haben).

Abbildung 2.45 Blockmodus in Eclipse

Funktionen in den Arbeitsalltag integrieren Die meisten der in diesem Abschnitt beschriebenen Funktionen kannte ich ursprünglich aus Eclipse. Ich muss zugeben, dass ich selbst überrascht war, dass die meisten davon auch in der ABAP Workbench verfügbar sind. Auch hier gilt wieder: Diese Funktionen und die Tastenkombinationen zu kennen ist nur der erste Schritt. Um wirklich einen Mehrwert daraus zu generieren, müssen Sie diese auch wirklich anwenden, ganz gleich, ob Sie schon seit Jahren so arbeiten oder den Umstieg auf Eclipse nutzen, um Ihren Arbeitsablauf zu optimieren.

116

Quelltext-Editor

2.4.6

Quelltext formatieren

Der Pretty Printer ist in der ABAP Workbench eine der Funktionen, die ich jeden Tag wahrscheinlich am häufigsten aufrufe. Das Drücken von (ª) + (F1) vor dem Speichern oder Aktivieren eines Entwicklungsobjekts geht mir quasi automatisch von der Hand. In Eclipse fällt zunächst auf, dass die Schaltfläche Pretty Printer fehlt. Das liegt daran, dass diese Funktion hier Format heißt. Die Tastenkombination (ª) + (F1) funktioniert in Eclipse genau wie in der ABAP Workbench, ist allerdings lediglich eine Alternativbelegung. Waren Sie bereits für andere Programmiersprachen mit Eclipse vertraut, kennen Sie vielleicht die Kombination (ª) + (Strg) + (F). Bevor Sie die Code-Formatierung nutzen können, müssen Sie diese allerdings einrichten. 1. Öffnen Sie den Report Z_ISSUE_LIST, und drücken Sie im Editor die Tasten (ª) + (F1). 2. Beim ersten Aufruf des »Pretty Printers« wird Ihnen ein Pop-up-Fenster angezeigt, das Sie darauf aufmerksam macht, dass noch keine Formatierungseinstellungen konfiguriert wurden (siehe Abbildung 2.46).

Abbildung 2.46 Pop-up-Fenster beim ersten Aufruf der Quelltextformatierung

3. Wählen Sie Configure your source code formatting settings, um in den entsprechenden Einstellungsdialog zu gelangen. Alternativ klicken Sie mit der rechten Maustaste auf Ihr aktuelles ABAP-Projekt im Project Explorer und wählen Properties. 4. Im Einstellungsdialog wechseln Sie zu ABAP Development 폷 Editors 폷 Source Code Editors 폷 Formatter. Projektbezogene Einstellungen Bei den Formatierungseinstellungen handelt es sich um eine projektbezogene Einstellung, d. h., Sie können sie für jedes System (und sogar für jedes ABAP-Projekt) individuell einstellen.

117

2.4

2

Funktionen der ABAP Development Tools

5. Konfigurieren Sie die Formatierung nach Ihren Wünschen. Ich bevorzuge es z. B., die Quelltexteinrückung zu aktivieren. Zudem lasse ich Schlüsselworte groß- und Bezeichner kleinschreiben (siehe Abbildung 2.47).

Abbildung 2.47 Formatierungseinstellungen

6. Bestätigen Sie Ihre Einstellungen mit OK. Sollten Sie nicht wünschen, dass der komplette Quelltext formatiert wird, können Sie mit der Tastenkombination (ª) + (Strg) + (F1) auch nur die aktuelle Selektion formatieren. Sie finden die entsprechenden Einstellungen auch im Kontextmenü unter Source (siehe Abbildung 2.48).

Abbildung 2.48 Quellen im Kontextmenü

2.5

Mit mehreren Ressourcen arbeiten

Arbeiten Sie an größeren Projekten, passiert es schnell, dass Sie parallel vier, fünf oder mehr Entwicklungsfenster mit Quellcode, ABAP-Dictionary-Typen oder anderen Repository-Objekten geöffnet haben. Dies wird in der ABAP Workbench durch die maximale Anzahl an Modi begrenzt (die vielleicht der eine oder andere Entwickler schon häufiger erreicht hat). Abgesehen von dieser Begrenzung, wird die Arbeit mit vielen SAP-GUI-Fenstern zum Teil sehr un-

118

Mit mehreren Ressourcen arbeiten

übersichtlich. Ich kenne einige SAP-Entwickler, die ihre Taskleiste an die unmöglichsten Positionen verschieben, um genau dieses Problem zu entschärfen. Die ADT funktionieren etwas anders. Daher zunächst die gute Nachricht: So etwas wie eine maximale Anzahl an Modi gibt es nicht. Sie können beliebig viele Repository-Objekte gleichzeitig öffnen, die auch nicht in der Taskleiste auftauchen, sondern als Registerkarten im Quelltext-Editor. Während die ABAP Workbench auf die Arbeit mit nur einem Entwicklungsobjekt gleichzeitig ausgelegt ist, bietet Eclipse einige Möglichkeiten, um selbst bei einer großen Anzahl an Objekten den Überblick nicht zu verlieren. Auf einer Registerkarte wird normalerweise die aktuelle System-ID, gefolgt vom Objektnamen, angezeigt. Arbeiten Sie nur mit einem einzigen System, benötigen Sie diese Information nicht. Sie können sie in den Einstellungen unter Window 폷 Preferences 폷 ABAP Development deaktivieren (siehe 2 in Abbildung 2.49). Das System, in dem sie aktuell arbeiten, wird Ihnen in Eclipse übrigens rechts unten im Bild angezeigt. Sie finden dort die System-ID, die Mandantennummer, den Namen des Servers, den angemeldeten Benutzer sowie die Anmeldesprache.

Abbildung 2.49 Beschriftung einer Registerkarte einstellen

Arbeiten Sie mit Objekten, die wiederum Unterobjekte enthalten (wie in Web Dynpro, siehe Kapitel 4, »Web Dynpro ABAP in Eclipse«), kann der Name des

119

2.5

2

Funktionen der ABAP Development Tools

Unterobjekts (etwa ein View-Name) interessanter sein als der Objektname selbst. Daher lässt sich hier die Reihenfolge der Benennung auf dem Register anpassen (1 in Abbildung 2.49). Um welchen Objekttyp es sich handelt, sehen Sie übrigens auf einen Blick anhand des Icons auf dem Register. Das aktuell geöffnete Objekt wird auch im Project Explorer markiert, was die Orientierung noch einmal erleichtert. Voraussetzung ist, dass die Funktion Link with Editor ( ) aktiv ist. So wie in Abbildung 2.50 könnte eine typische ADT-Umgebung aussehen. Sie sehen den Quelltext-Editor 1, den Project Explorer 2 und den View Outline 3. Zudem ist am unteren Rand noch Platz für weitere Views 4, hier den View Problems.

Abbildung 2.50 Typischer Aufbau einer Eclipse-Umgebung

Sie müssen jedoch nicht so arbeiten, sondern können die verschiedenen Views anordnen, wie Sie möchten. Dabei ist es auch möglich, mehrere Quell-

120

Mit mehreren Ressourcen arbeiten

text-Editoren parallel geöffnet zu haben. Klicken Sie dazu einfach auf das Register, und ziehen Sie es an eine beliebige Stelle in der Eclipse-Umgebung. Ein grüner Rahmen zeigt an, wo die Registerkarte später platziert wird (siehe Abbildung 2.51). So können Sie sich mehrere Quelltexte gleichzeitig oder z. B. auch Dictionary-Strukturen anzeigen lassen, während Sie arbeiten.

Abbildung 2.51 Views in der Eclipse Workbench anordnen

Sie können Views nicht nur innerhalb der Eclipse Workbench andocken, sondern auch vollständig ablösen, wodurch sie in einem eigenen Fenster angezeigt werden. Dies ist z. B. praktisch, wenn Sie mit mehreren Monitoren arbeiten. Eclipse merkt sich übrigens die Anordnung der Views. Beim nächsten Start finden Sie Ihre Umgebung genauso wieder, wie Sie sie verlassen haben. Auch sämtliche Objekte sind noch geöffnet, den Inhalt sehen Sie allerdings erst nach Eingabe Ihres Kennworts. Haben Sie sich bei Ihren Umbauarbeiten in eine Sackgasse manövriert und möchten zum Ausgangspunkt zurückkehren, können Sie dies ebenfalls tun. Wählen Sie Window 폷 Reset Perspective. Daraufhin finden Sie Ihre ABAPEntwicklungsperspektive wieder jungfräulich wie am ersten Tag vor. Haben

121

2.5

2

Funktionen der ABAP Development Tools

Sie die perfekte Anordnung gefunden, können Sie auch Ihre eigene Perspektive erstellen. Wählen Sie Window 폷 Save Perspective As, und vergeben Sie einen Namen für die Perspektive, die Sie anschließend immer wieder aufrufen können. So können Sie auch für verschiedene Aufgaben jeweils eigene Perspektiven erstellen. Die zuletzt verwendeten Perspektiven finden Sie in der Schnellauswahl in der rechten oberen Ecke des Fensters. Sie können die Perspektive auch über die Tastenkombination (Strg) + (F8) wechseln. Sie können Ihre Perspektive noch weiter personalisieren. Die verfügbaren Einstellungen finden Sie unter Window 폷 Customize Perspective. In diesem Dialog können Sie anpassen, was in der Menüleiste und der Toolbar angezeigt bzw. ausgeblendet werden soll (siehe Abbildung 2.52). Sie können z. B. auch einstellen, welche Objekte Sie über den Direktzugriff unter File 폷 New vorfinden. Auch diese Einstellungen können Sie in Ihrer eigenen Perspektive sichern.

Abbildung 2.52 Perspektive personalisieren

122

Mit mehreren Ressourcen arbeiten

Selbst bei den größten Monitoren ist der Platz für neue Registerkarten irgendwann erschöpft. Eclipse zeigt dann die zuletzt genutzten Registerkarten an, alle weiteren Registerkarten werden in einer Liste zusammengefasst, die Sie in Abbildung 2.50 sehen (5). Mit der Tastenkombination (Strg) + (F6) können Sie sich zudem jederzeit alle geöffneten Editor-Fenster anzeigen lassen. Solange Sie die (Strg)-Taste gedrückt halten, bleibt die Anzeige sichtbar. Mit den Pfeiltasten können Sie dann einen Editor wählen und ohne Mausklick dorthin wechseln. Per Doppelklick auf ein Register können Sie den View vergrößern, sodass er die gesamte Workbench einnimmt. Haben Sie einmal zu viele Registerkarten geöffnet, benötigen aber nur eine, können Sie alle Registerkarten bis auf die benötigte mit der Funktion Close Others aus dem Kontextmenü schließen. Eclipse verfügt nicht über Anzeige- und Editiermodi. Sie können ein Repository-Objekt bearbeiten, sobald es geöffnet wurde. Allerdings macht auch Eclipse Gebrauch vom SAP-Sperrkonzept. Sobald Sie die erste Änderung vornehmen, wird das Objekt gesperrt. Wird ein Objekt bereits bearbeitet, quittiert Eclipse jeden Bearbeitungsversuch mit einer Fehlermeldung. Sobald ein Objekt im Quelltext-Editor gesperrt wird, zeigt Eclipse dies mit einem kleinen Schlosssymbol an (siehe Abbildung 2.53). Sollte es erforderlich sein, können Sie die Sperre mit der Tastenkombination (Strg) + (U) (Unlock) lösen. Ungesicherte Änderungen werden mit einem kleinen Sternchen (*) vor dem Namen des Objekts angezeigt. Enthält das Objekt inaktive Inhalte, wird dies durch eine kleine Raute (#) angezeigt.

Abbildung 2.53 Symbole im Quelltext-Editor

Da in der Eclipse-Umgebung mehrere Objekte geöffnet sein können, besitzt Eclipse jeweils zwei Versionen der Funktionen Speichern und Aktivieren. Über die Tastenkombination (Strg) + (S) oder das Speichern-Symbol ( ) in der Toolbar speichern Sie das aktuelle Objekt. Möchten Sie alle geänderten Objekte speichern, nutzen Sie (ª) + (Strg) + (S) oder das Icon . Ihre Objekte aktivieren Sie mit (Strg) + (F3) bzw. dem Icon . In der ABAP Workbench wird bei der Aktivierung auch immer eine Liste aller inaktiven Objekte des Benutzers angezeigt. Möchten Sie in Eclipse alle Objekte aktivieren, können Sie dies über (ª) + (Strg) + (F3) oder das Icon in der Menüleiste erledigen. Auch in Eclipse haben Sie die Wahl, welche Objekte Sie aktivieren möchten.

123

2.5

2

Funktionen der ABAP Development Tools

2.6

Verwendungsnachweis

Eine weitere nützliche Funktion ist der Verwendungsnachweis (Where-UsedList). Die aus der ABAP Workbench bekannte Tastenkombination (ª) + (Strg) + (F3) ist in Eclipse bereits anderweitig vergeben (alle Objekte aktivieren). Die neue Tastenkombination lautet (ª) + (Strg) + (G). Die Funktion findet sich aber auch im Menü mit dem Icon . Der Verwendungsnachweis funktioniert ähnlich einfach wie in der ABAP Workbench. Anders als in der ABAP Workbench werden Sie allerdings nicht gefragt, in welchen Bereichen Sie suchen möchten, sondern die Analyse erfolgt über alle Objekttypen hinweg: 1. Öffnen Sie z. B. den Include Z_ISSUE_LIST_TOP in Eclipse. 2. Positionieren Sie den Cursor auf dem Objekt ZISSUE. 3. Drücken Sie (ª) + (Strg) + (G), um die Suche zu starten. Ihnen wird ein Dialog mit einem Fortschrittsbalken angezeigt, der verschwindet, sobald die Suche beendet ist. Unter Umständen sehen Sie den Dialog nicht, falls Sie einen einfachen Verwendungsnachweis durchführen oder eine schnelle Datenbank zur Verfügung haben. 4. Das Ergebnis des Nachweises wird in einem eigenen View Search angezeigt (siehe Abbildung 2.54). Die Fundstellen sind dabei nach den enthaltenen Objekten gruppiert. Wie gewohnt, springen Sie mit einem Klick auf einen Eintrag in den Quelltext-Editor.

Abbildung 2.54 Verwendungsnachweis zu ZISSUE

In Abbildung 2.54 erkennen Sie einen der Vorteile des View-Konzepts in Eclipse. In der ABAP Workbench wird der Verwendungsnachweis in einem

124

Verwendungsnachweis

Fenster angezeigt, d. h., Sie müssen den Quelltext verlassen, um sich die Ergebnisliste anzusehen. Wollen Sie sich eine Fundstelle im Quellcode anschauen, müssen Sie aus der Liste wieder in den Quelltext springen. Mit dem Search-View können Sie dagegen flexibler arbeiten, d. h., Sie haben gleichzeitig Ihre Ergebnisliste und den Quelltext im Blick. Mit den Pfeilen in der Symbolleiste 1 springen Sie zu den einzelnen Fundstellen Ihres Verwendungsnachweises. Arbeiten Sie anschließend weiter am Quelltext und wollen noch einmal nachsehen, wo sich das gesuchte Objekt versteckt, können Sie das Ergebnis einfach aktualisieren ( , 2). Klicken Sie auf das Icon (3) in der Symbolleiste, werden Ihnen die letzten Verwendungsnachweise und Suchen angezeigt. Sie können die Ergebnisse des Verwendungsnachweises auch einschränken. Dazu steht Ihnen die Filterfunktion ( , 4) zur Verfügung. Sie können die Suche auf ein Paket einschränken, nur bestimmte Objekttypen in die Ergebnisliste aufnehmen oder nur in Objekten suchen, die von einem bestimmten Benutzer bearbeitet wurden. Version beachten Die Filterfunktionen beim Verwendungsnachweis wurden mit Version 2.31 der ABAP Development Tools neu eingeführt. In älteren Versionen fehlt der entsprechende Dialog. Zudem benötigen Sie mindestens den SAP NetWeaver AS ABAP 7.4 SP08.

Ebenfalls sehr praktisch ist es, die Suche auf Produktiv- oder Test-Code einzuschränken (siehe Abbildung 2.55). Insbesondere, wenn Sie eine funktionale Analyse durchführen wollen, sind Testklassen in der Regel eher uninteressant und verfälschen die Ergebnisliste.

Abbildung 2.55 Verwendungsnachweis filtern

125

2.6

2

Funktionen der ABAP Development Tools

Suchhilfe Ihnen wird aufgefallen sein, dass Eclipse in Dialogen wie dem Ergebnisfilter keine Suchhilfe anbietet. Stattdessen bietet Eclipse in vielen Eingabefeldern eine Autovervollständigung an. Diese aktivieren Sie mit der Tastenkombination (Strg) + Leertaste. Diese Funktion berücksichtigt auch Ihre bisherige Eingabe. Felder, die eine Autovervollständigung bieten, sind meist mit einer kleinen Glühbirne gekennzeichnet, wenn der Cursor sich darin befindet (siehe Abbildung 2.26).

Ebenfalls sehr angenehm ist die Möglichkeit, die Suche im Hintergrund durchführen zu lassen. Dies ist in Eclipse übrigens bei vielen lang laufenden Prozessen möglich. Wird Ihnen der Dialog mit dem Fortschrittsbalken angezeigt, wählen Sie einfach Run in Background. Anschließend können Sie einfach weiterarbeiten, bis die Aktion abgeschlossen ist und Ihnen das Ergebnis angezeigt wird. Der Vorteil ist, dass Sie Ihren Arbeitsfluss nicht unterbrechen müssen, wenn Sie einen ausgiebigeren Verwendungsnachweis durchführen wollen. Ich fürchte allerdings, dass Sie dadurch auch weniger Kaffeepausen haben werden – zumindest, wenn Ihr Chef dieses Feature auch kennt.

2.7

Quick Fix und Quick Assist

Stellen Sie sich vor, Sie arbeiten gerade an einer neuen Klasse. Die Funktion haben Sie schon vor Augen und müssen sie nur noch in Quelltext gießen. Sie schreiben den Code und stellen plötzlich fest, dass Sie eine neue Methode benötigen, um fortzufahren. Sie springen daher in den Implementierungsteil, deklarieren die Methode, geben die Parameter an und legen eine Implementierung an. Und schon kann es weitergehen. Doch wo waren Sie noch gleich? Schnell geraten Sie in einer solchen Situation aus dem Fluss. Wie toll wäre es da, wenn Ihnen jemand die lästigen Aufgaben abnehmen könnte, die Sie nur erledigen müssen, um den Compiler zufriedenzustellen. Finden Sie sich in dieser Szene wieder? Dann dürfte Ihr neuer LieblingsShortcut ab sofort (Strg) + (1) lauten, hinter dem sich die Funktion Quick Fix in Eclipse verbirgt. Mit deren Hilfe legen Sie eine fehlende Implementierung einer Methode schnell an oder erstellen z. B. ein Textelement für einen Report.

126

Quick Fix und Quick Assist

2.7.1

Quick Fix

Nehmen wir unsere Klasse ZCL_ISSUE als Beispiel. Bisher können wir mit dieser Klasse lediglich Issues lesen, die schon auf der Datenbank gespeichert sind. Wir wollen die Klasse darüber hinaus befähigen, ein neues Issue zu speichern bzw. ein vorhandenes Issue zu aktualisieren. Um das Speichern zu ermöglichen, erstellen wir eine neue Methode SAVE. 1. Öffnen Sie die Klasse ZCL_ISSUE im Editor-View. 2. Fügen Sie in der Public Section am Ende der Methodendeklarationen die Methode SAVE mit der Ausnahme failed_to_save hinzu (siehe Listing 2.11). PUBLIC SECTION. METHODS: constructor IMPORTING if_issue TYPE z_issue_ id EXCEPTIONS no_issue_found optional, get_issue RETURNING VALUE(rs_issue) TYPE zissue, set_issue IMPORTING is_issue TYPE zissue, save EXCEPTIONS failed_to_save. Listing 2.11 Public Section der Klasse ZCL_ISSUE

Eclipse zeigt daraufhin mit dem Icon auf dem Vertical Ruler einen Fehler an: Die Methode SAVE ist zwar deklariert, aber die Implementierung fehlt. Die kleine Glühbirne neben der Annotation weist darauf hin, dass Eclipse zu diesem Fehler auch direkt eine Lösung anbieten möchte, einen Quick Fix. Gehen Sie nun wie folgt vor: 1. Setzen Sie den Cursor in die markierte, fehlerhafte Zeile. 2. Drücken Sie die Tastenkombination (Strg) + (1), oder klicken Sie auf das Icon , um in die Quick-Fix-Auswahl zu gelangen (siehe Abbildung 2.56).

Abbildung 2.56 Verfügbare Quick Fixes

127

2.7

2

Funktionen der ABAP Development Tools

3. Wählen Sie Add implementation for save aus der Liste. Eclipse fügt automatisch eine neue Methodenimplementierung in den Quelltext ein und springt mit der Eingabemarke an die entsprechende Stelle. Wir sehen in Abbildung 2.56 auch, dass es mehrere Möglichkeiten gibt, mit dem Fehler umzugehen. Sie können die Methode entweder implementieren lassen oder die Definition entfernen. Die anderen beiden Möglichkeiten Make save private und Make save protected sind streng genommen keine Quick Fixes, da sie keinen Fehler beheben. Bei diesen Vorschlägen handelt es sich um Quick Assists, auf die ich in Abschnitt 2.7.2 noch näher eingehe. In Abschnitt 3.4, »Refactoring«, finden Sie einige praktische Beispiele zum Thema Quick Assist. Unsere neu implementierte Methode füllen wir als Nächstes ein wenig mit Leben. Die Methode SAVE soll Folgendes leisten: 왘 Wurde ein Issue bereits einmal gespeichert, soll ein Update auf der Datenbank durchgeführt werden. 왘 Wurde das Issue noch nicht gesichert, soll es entsprechend markiert und gespeichert werden. 왘 Handelt es sich um ein neues Issue, soll es mit dem Baustein Z_CREATE_ SINGLE_ISSUE gespeichert werden. Beim Schreiben des Quelltextes können Sie von den in den vorangegangenen Abschnitten erlernten Techniken sowie der Code-Vervollständigung Gebrauch machen. Fügen Sie Listing 2.12 als Implementierung der Methode SAVE ein. Lassen Sie sich beim Eingeben erst einmal nicht von den Fehlermeldungen ablenken. Sichern Sie Ihre Änderungen anschließend. METHOD save. IF me->is_persistent( ) = abap_true. CALL FUNCTION 'Z_UPDATE_SINGLE_ISSUE' EXPORTING is_issue = me->ms_issue IMPORTING es_issue = me->ms_issue EXCEPTIONS issue_not_found = 1 OTHERS = 2. IF sy-subrc = 1. me->mf_persistent = abap_false. me->save( ).

128

Quick Fix und Quick Assist

ELSEIF sy-subrc EQ 2. RAISE failed_to_save. ENDIF. ELSE. CALL FUNCTION 'Z_CREATE_SINGLE_ISSUE' EXPORTING is_issue = me->ms_issue IMPORTING es_issue = me->ms_issue EXCEPTIONS duplicate_issue_id = 1 no_issue_id = 2 OTHERS = 3. IF sy-subrc 0. RAISE failed_to_save. ENDIF. ENDIF. ENDMETHOD. Listing 2.12 Methode SAVE

Anhand von Listing 2.12 können Sie den Einsatz von Quick Fixes nachvollziehen. Schon die Zeile IF me->is_persistent( ) = abap_true. wird von Eclipse bemängelt: Die Methode is_persistent( ) wurde bislang noch nicht angelegt. Die Annotation mit Glühbirne zeigt uns aber an, dass ein Quick Fix verfügbar ist. Schauen Sie, was Eclipse als Lösung anbietet: 1. Setzen Sie den Cursor auf den Methodennamen, und drücken Sie (Strg) + (1). 2. Aus der Liste wählen Sie Create method is_persistent, um die fehlende Methode anzulegen. 3. Im daraufhin angezeigten Anlage-Dialog (siehe Abbildung 2.57) hat Eclipse bereits erkannt, dass die Methode einen Returning-Parameter beinhalten soll. Benennen Sie diesen in RF_PERSISTENT um, und geben Sie als Rückgabetyp BOOLEAN an. Deklaration und Implementierung einer neuen Methode werden erstellt. 4. Fügen Sie in die neue Methode das Coding aus Listing 2.13 ein: METHOD is_persistent. rf_persistent = me->mf_persistent. ENDMETHOD. Listing 2.13 Methode IS_PERSISTENT

129

2.7

2

Funktionen der ABAP Development Tools

Abbildung 2.57 Anlegen einer neuen Methode

Eine weitere Fehlermeldung bleibt zu bearbeiten, nämlich dass das Attribut MF_PERSISTENT noch nicht vorhanden ist: 1. Setzen Sie den Cursor auf MF_PERSISTENT (ob in der Methode SAVE oder der Methode IS_PERSISTENT, ist dabei egal). 2. Rufen Sie den Quick Fix mit (Strg) + (1) auf, und wählen Sie Declare attribute mf_persistent aus der Liste. 3. Um die Klasse konsistent zu halten, initialisieren Sie das Attribut MF_PERSISTENT noch im Constructor. Ersetzen Sie die If-Abfrage nach dem Aufruf des Funktionsbausteins Z_READ_SINGLE_ISSUE durch den Inhalt von Listing 2.14. IF sy-subrc 0. RAISE no_issue_found. ELSE. me->mf_persistent = abap_true. ENDIF. Listing 2.14 Initialisierung von mf_persistent

Die Fehlermeldung ist nun verschwunden, und in der Private Section findet sich eine neue Datendeklaration:

130

Quick Fix und Quick Assist

PRIVATE SECTION. DATA ms_issue TYPE zissue. DATA mf_persistent TYPE abap_bool.

Das System hat den Datentyp abap_bool ausgewählt. Wenn es Sie interessiert, welche Definition sich dahinter verbirgt, können Sie das mit der Taste (Strg) und einem Klick auf abap_bool herausfinden. Die automatische Typdeklaration tut ihren Dienst in der Regel sehr gut. Probieren Sie sie einfach aus, indem Sie automatisch Attribute generieren lassen, denen Sie verschiedene Daten zuweisen. Wenn Sie wie ich bei der Datendeklaration die Schreibweise als Kettensatz bevorzugen, werden Sie sich vielleicht fragen, ob man einstellen kann, wie Eclipse Datendeklarationen anlegt. Eine solche Einstellung suchen Sie vergebens, allerdings versucht Quick Fix, es Ihnen immer recht zu machen. Löschen Sie probeweise einmal die Datendeklaration von MF_PERSISTENT ((Strg) + (D)), und ändern Sie die Deklaration von MS_ISSUE, indem Sie hinter die DATA-Anweisung einen Doppelpunkt setzen: DATA: ms_issue TYPE zissue.

Führen Sie die Datendeklaration von MF_PERSISTENT nun noch einmal per Quick Fix aus, wird der folgende Code generiert: PRIVATE SECTION. DATA: ms_issue TYPE zissue, mf_persistent TYPE abap_bool.

Diese Kontextsensitivität sehen Sie an anderen Stellen. So erkennt Eclipse schon durch das Voranstellen von me, dass es sich bei der angegebenen Variable um ein Feld der Klasse handeln muss und nicht um eine lokale Variable. Erstellen wir nun die Methode GET_PROJECT. Diese Methode soll das Projekt zurückliefern, zu dem das aktuelle Issue gehört. Wir beginnen dieses Mal mit der Implementierung: 1. Fügen Sie in den Implementierungsteil von ZCL_ISSUE den Inhalt von Listing 2.15 ein. CLASS zcl_issue IMPLEMENTATION. [...] METHOD get_project. ENDMETHOD. END CLASS. Listing 2.15 Implementierung der Methode GET_PROJECT

131

2.7

2

Funktionen der ABAP Development Tools

2. Positionieren Sie den Cursor auf dem Methodenbezeichner get_project, und drücken Sie (Strg) + (1). 3. Wählen Sie die Lösung Create definition of get_project. Sie könnten die Definition auch mit einem Assistenten anlegen, um unmittelbar Parameter angeben zu können, wir wollen die Parameter in diesem Beispiel allerdings im Verlauf der Implementierung hinzufügen lassen. 4. Geben Sie den Code aus Listing 2.16 als Methodenimplementierung ein. METHOD get_project. lf_project_id = me->ms_issue-project_id. IF lf_project_id IS NOT INITIAL. CREATE OBJECT rr_project TYPE zcl_project EXPORTING if_project_id = lf_project_id EXCEPTIONS no_project_found = 1. IF sy-subrc NE 0. CLEAR rr_project. ENDIF. ENDIF. ENDMETHOD. Listing 2.16 Implementierung von get_project

5. Es werden vier Fehler wegen fehlender Deklarationen ausgegeben. Zunächst setzen Sie den Cursor auf lf_project_id und drücken die Tastenkombination (Strg) + (1). Wählen Sie Declare local variable lf_ project_id. Eclipse legt eine lokale Variable an und vergibt auch den Typ mit Z_PROJECT_ID korrekt. 6. Als Nächstes deklarieren Sie den Returning-Parameter RR_PROJECT. Setzen Sie den Cursor auf rr_returning, und drücken Sie (Strg) + (1). Wählen Sie Declare returning parameter rr_returning. Der Parameter wird der Methodendeklaration hinzugefügt. 7. Springen Sie zur Methodendeklaration, indem Sie den Cursor auf get_ project setzen und (F3) drücken. Eclipse bemängelt, dass der Typ ZCL_ PROJECT unbekannt sei. Setzen Sie den Cursor auf zcl_project, und drücken Sie (Strg) + (1). Wählen Sie Create global class zcl_project. 8. Geben Sie eine Beschreibung im Assistenten an, und fahren Sie mit Next fort (siehe Abbildung 2.58). 9. Ordnen Sie der Klasse einen Transportauftrag zu, und beenden Sie die Anlage mit Finish.

132

Quick Fix und Quick Assist

Abbildung 2.58 Klasse ZCL_PROJECT anlegen

Prüfen Sie den Code erneut mit (Strg) + (F2). Falls Sie die Fehlermeldung erhalten, dass der Constructor der Klasse noch fehlt, legen Sie ihn wie folgt an: 1. Setzen Sie den Cursor in die Definition der Klasse ZCL_PROJECT. 2. Drücken Sie (Strg) + (1), und wählen Sie den Vorschlag Generate Constructor. 3. Implementieren Sie den Constructor, wie in Listing 2.17 vorgegeben. METHOD constructor. SELECT single * from zproject into me->ms_project WHERE project_id = if_project_id. if sy-subrc ne 0. RAISE no_project_found. endif. ENDMETHOD. Listing 2.17 Constructor der Klasse ZCL_PROJECT

4. Beheben Sie die angezeigten Fehler mittels Quick Fix. Passen Sie abschließend die Deklaration der Klasse wie in Listing 2.18 an. PUBLIC SECTION. METHODS constructor IMPORTING if_project_id TYPE z_project_id OPTIONAL

133

2.7

2

Funktionen der ABAP Development Tools

EXCEPTIONS no_project_found. PROTECTED SECTION. PRIVATE SECTION. DATA ms_project TYPE zproject. Listing 2.18 Deklaration von ZCL_PROJECT

5. Aktivieren Sie Ihre Klasse ((ª) + (Strg) + (F3)). Systemvoraussetzungen für die Parameter- und Attributerstellung Die Möglichkeit, Methodenparameter zu deklarieren, Klassenattribute zu erstellen und Constructors per Quick Fix anzulegen, wurde erst mit den ABAP Development Tools 2.19 implementiert. Sie benötigen zudem ein SAP NetWeaver 7.4 SP5 oder 7.31 SP11 als Backend-System.

Sie sollten Ihre Entwicklung nun ohne Fehler aktivieren können. Allerdings werden Sie beim Ausprobieren feststellen, dass das Aktualisieren eines bestehenden Issues mit einem Programmabbruch quittiert wird. Das liegt daran, dass der Funktionsbaustein Z_UPDATE_SINGLE_ISSUE noch nicht vorhanden ist. Da der ABAP Compiler dies aber nicht bemängelt, wird an dieser Stelle kein Fehler angezeigt. Wie Sie solche Probleme identifizieren, bevor Anwender Sie verärgert anrufen, besprechen wir in Abschnitt 3.1.3, »ABAP Test Cockpit«.

2.7.2

Quick Assist

Die Funktionen Quick Assist und Quick Fix sind enge Verwandte. Der große Unterschied besteht darin, dass der Quick Fix zur Fehlerbeseitigung dient, der Quick Assist stattdessen Assistenzdienste anbietet, wenn es darum geht, den Quelltext umzustellen. Beide Funktionen werden mit der Tastenkombination (Strg) + (1) aktiviert. Testen Sie den Quick Assist, um ein Gefühl dafür zu bekommen, welche Möglichkeiten Ihnen diese Funktion bietet. Da es keinen direkten Indikator gibt, ist es allerdings manchmal schwierig, zu erkennen, an welchen Stellen Ihnen die Unterstützung zur Verfügung steht. Ein wenig Abhilfe schafft der View Quick Assist (siehe Abbildung 2.59), den Sie über den Menüpfad Window 폷 Show View 폷 Other aktivieren. Dieser View zeigt Ihnen jederzeit alle verfügbaren Quick Assists und ebenso die Quick Fixes an. Dabei bezieht sich die Anzeige immer auf die Code-Stelle, in der sich der Cursor aktuell

134

Quick Fix und Quick Assist

befindet. Zudem bietet dieser View noch eine Historie der zuletzt durchgeführten Quick Fixes und Assists.

Abbildung 2.59 View »Quick Assist«

Um dafür sorgen, dass unsere Klasse wie gewünscht funktioniert, legen wir nun den Funktionsbaustein Z_UPDATE_SINGLE_ISSUE aus der Methode SAVE an: 1. Wechseln Sie mit dem Cursor in die Methode ZCL_ISSUE->SAVE( ). Ohne Maus navigieren Haben Sie die Klasse ZCL_ISSUE bereits geöffnet, müssen Sie nicht einmal die Maus bemühen, um zum Quellcode der Methode SAVE zu gelangen. Wechseln Sie zunächst mit (Strg) + (F6) zum Editor-Fenster für Ihre Klasse. Befinden Sie sich im Klassen-Editor, können Sie mit (Strg) + (O) einen Outline-View aktivieren und in diesem über die Eingabezeile filtern, um die Methode auszuwählen. Mit der Taste (¢) springen Sie unmittelbar in die gewählte Methode.

2. Platzieren Sie den Cursor auf dem Aufruf des Funktionsbausteins Z_UPDATE_SINGLE_ISSUE, und drücken Sie (Strg) + (1). 3. Wählen Sie Create function module z_update_single_issue aus der Quick-Assist-Liste. 4. Im Dialog zur Anlage des Funktionsbausteins geben Sie »Z_ISSUE_LIST_ DB« als Funktionsgruppe ein (siehe Abbildung 2.60). Vergeben Sie zudem eine passende Beschreibung. Fahren Sie mit Next fort. 5. Ordnen Sie gegebenenfalls einen Transportauftrag zu, und schließen Sie die Anlage des Funktionsbausteins mit Finish ab.

135

2.7

2

Funktionen der ABAP Development Tools

Abbildung 2.60 Funktionsbaustein Z_UPDTE_SINGLE_ISSUE anlegen

6. Der Editor mit dem neuen Funktionsbaustein öffnet sich. Fügen Sie hier den Quelltext aus Listing 2.19 ein. FUNCTION z_update_single_issue IMPORTING VALUE(is_issue) TYPE zissue EXPORTING es_issue TYPE zissue EXCEPTIONS issue_not_found. es_issue = is_issue. IF es_issue-issue_id IS INITIAL. RAISE issue_not_found. ENDIF. es_issue-aedat = sy-datum. es_issue-aenam = sy-uname. UPDATE ZISSUE FROM es_issue. IF sy-subrc = 4. RAISE issue_not_found. ENDIF. ENDFUNCTION. Listing 2.19 Funktionsbaustein Z_UPDATE_SINGLE_ISSUE

7. Aktivieren Sie alle Änderungen mit (ª) + (Strg) + (F3).

136

Arbeitsvorrat organisieren

Funktionsbausteine und Includes anlegen Um Funktionsbausteine und Includes mittels Quick Fix bzw. Quick Assist anzulegen, benötigen Sie mindestens Version 2.19 der ABAP Development Tools. Sie benötigen zudem SAP NetWeaver 7.4 SP5 oder 7.31 SP11 als Backend-System.

Nun haben wir unsere Klasse so erweitert, dass wir Issues auch sichern und aktualisieren können. Die Funktionen Quick Fix und Quick Assist bieten noch mehr Funktionen, die Sie zum Teil in Abschnitt 3.4, »Refactoring«, noch kennenlernen werden. Das soll Sie aber nicht davon abhalten, auf eigene Faust Anwendungsgebiete für Quick Fix und Quick Assist zu erkunden. Sie könnten z. B. den Report Z_ISSUE_LIST in mehrere Includes aufteilen oder der Klasse ZCL_ISSUE eine Funktion is_dirty( ) hinzufügen, die anzeigt, ob das Issue verändert wurde. Lassen Sie Ihrer Kreativität freien Lauf. Eine Liste der verfügbaren Quick Assists finden sie auch in der ADTHilfe (Help 폷 Help Contents) unter SAP – ABAP Development User Guide 폷 Concepts 폷 Quick Assists.

2.8

Arbeitsvorrat organisieren

Selten beginnen Sie Ihre Arbeit auf der »grünen Wiese«, sodass Sie alle Objekte nach Ihrem Gutdünken neu anlegen können. Genauso selten können Sie Ihre Arbeit an einem Stück durchführen und abschließen. Oft beginnt Ihre Arbeit damit, die Klasse zu finden, in der sich eine bestimmte SELECT-Anweisung verbirgt, oder Sie sollen Ihren Report, den Sie vor zwei Monaten entwickelt haben, um ein Feld erweitern. Aber wie hieß das Programm noch gleich, und welche Objekte gehörten dazu? Können Sie diese Methode ändern, oder wird sie noch an anderer Stelle verwendet? Diese Fragen stellen sich die meisten Entwickler so oder in ähnlicher Form wohl häufiger. Bei der Beantwortung könnten Sie viel Zeit und die eine oder andere Tasse Kaffee brauchen. Darum sehen wir uns in diesem Abschnitt an, wie Sie Objekte (wieder-)finden können und wie Sie Ihre Aufgaben so organisieren, dass Sie jeden Tag möglichst reibungsfrei mit der Arbeit beginnen oder fortsetzen können. Das soll natürlich nicht heißen, dass Sie Ihren Tag nicht trotzdem mit einem frisch gebrühten Kaffee beginnen dürfen.

2.8.1

Objekte finden

Beginnen wir zunächst damit, Entwicklungsobjekte nach Namen zu suchen. Bestimmt haben Sie keine Lust, sich durch verschachtelte Paketlisten zu kli-

137

2.8

2

Funktionen der ABAP Development Tools

cken, um ein Objekt zu finden. Im SAP GUI gibt es verschiedene Transaktionen, in denen Sie nach ABAP-Dictionary-Objekten, Funktionsbausteinen, Programmen oder Klassen suchen können, sowie Transaktion SE80, in der diese Suchen gebündelt möglich sind. In Eclipse startet die Tastenkombination (ª) + (Strg) + (A) oder der Menüpfad Navigate 폷 Open ABAP Development Object ( ) den Dialog zum Öffnen von Entwicklungsobjekten (siehe Abbildung 2.61). Der Dialog ist relativ einfach gehalten. Sie sehen ein Eingabefeld und eine Ergebnisliste, die live bei der Eingabe Ihrer Suchanfrage eingeschränkt wird. Bei der Suche werden auch Wildcard-Zeichen unterstützt: 왘 Ein Asterisk (*) ist ein Platzhalter für eine beliebige Zeichenkette. 왘 Ein Fragezeichen (?) ist ein Platzhalter für ein einzelnes beliebiges Zeichen. Haben Sie mehrere Projekte in Ihren Workspace eingebettet, können Sie an dieser Stelle auswählen, welches Sie durchsuchen möchten. Sie können die Suche auch auf bestimmte Objekttypen beschränken. Die RepositoryObjekte haben vierstellige Typ-Codes, mit denen sie eindeutig identifiziert werden können. Geben Sie dazu in der Suchzeile des Dialogs Open ABAP Development Object »type:« ein (siehe Abbildung 2.61). Mit der Tastenkombination (Strg) + Leertaste können Sie sich die Liste der verfügbaren Objekte anzeigen lassen.

Abbildung 2.61 Objektsuche in der Eclipse-Umgebung

Um ein Objekt zu öffnen, klicken Sie doppelt auf dieses Objekt in der Liste. Der Dialog merkt sich zwar die zuletzt geöffneten Objekte, allerdings bleibt

138

Arbeitsvorrat organisieren

Ihre Suchanfrage nicht erhalten, wenn Sie den Dialog erneut aufrufen. Diese Funktion dient hauptsächlich dem Öffnen von Objekten und nicht zum Durcharbeiten mehrerer Suchergebnisse. Dazu gibt es eine umfangreichere Suchfunktion. Objektsuche in der ABAP Workbench Bis SAP NetWeaver 7.31 gab es in der ABAP Workbench keine Möglichkeit, generisch nach dem Namen eines Repository-Objekts zu suchen. Mit diesem Release wurde die Funktion Anderes Objekt … ( , (ª) + (F5)) so umgebaut, dass es nun auch möglich ist, nach dem Namen zu suchen.

Den erweiterten Suchdialog erreichen Sie über die Tastenkombination (Strg) + (H). Dabei handelt es sich um eine allgemeine Suchfunktion, die nicht nur die ABAP-Objekt-Suche beinhaltet. Die anderen Suchfunktionen erreichen Sie über verschiedene Registerkarten. Wenn Sie nicht alle Funktionen benutzen (weil Sie z. B. keine Java-Entwicklung betreiben), können Sie die Anzahl der Registerkarten über den Button Customizing einschränken, wie in Abbildung 2.62 geschehen.

Abbildung 2.62 Der Eclipse-Suchdialog

Auch die ABAP-Objektsuche ist sehr einfach gehalten. In ein Eingabefeld können Sie den Namen des gesuchten Objekts eingeben. Im Unterschied zum Dialog ABAP-Entwicklungsobjekt öffnen müssen Sie am Ende des Suchbegriffs mit Wildcards arbeiten. Die Suche nach »Z_ISSUE« liefert z. B. keinen Treffer. Um das Programm Z_ISSUE_LIST zu erhalten, müssen Sie nach »Z_ISSUE*« suchen. Sie können die Suche auf Ihre Favoriten-Pakete einschränken. Dies ist vor allem praktisch, wenn Sie nach Objekten suchen, die Sie zuletzt bearbeitet haben. Zudem können Sie auch alle Systeme durchsuchen, die Sie in Ihren Workspace eingebettet haben. Stellen Sie dazu den Umfang auf Arbeitsbereich ein.

139

2.8

2

Funktionen der ABAP Development Tools

Die Suche können Sie wie gewohnt im Vordergrund ausführen lassen, währenddessen weiterarbeiten und Eclipse im Hintergrund werkeln lassen. Das Ergebnis wird Ihnen in einem eigenen View angezeigt. Den View Search haben Sie schon in Abschnitt 2.6, »Verwendungsnachweis«, kennengelernt. Genau wie beim Verwendungsnachweis haben Sie die Möglichkeit, Ihre Suche erneut auszuführen oder auf Ergebnisse Ihrer letzten Suchen zurückzugreifen. Neben der Suche nach Objektnamen ist es manchmal interessant, im Quellcode zu suchen. Vermutlich kennen Sie die Standardsuche in der ABAP Workbench, die Sie über die Tastenkombination (Strg) + (F) erreichen. Mit der Standardsuche haben Sie die Möglichkeit, im aktuellen Editor oder Rahmenprogramm bzw. der aktuellen Klasse zu suchen. An den Programmgrenzen ist jedoch Schluss. Ähnliche Funktionen bietet Ihnen auch Eclipse. Die Tastenkombination (Strg) + (F) öffnet den Dialog Find/Replace, in dem Sie im aktuell geöffneten Editor-Fenster suchen können (siehe Abbildung 2.63). Der Suchdialog ermöglicht die üblichen Suchen nach Ausdrücken im Quelltext, von denen die meisten auch in der ABAP Workbench zur Verfügung stehen.

Abbildung 2.63 Suchen/Ersetzen-Dialog

Der Dialog Find/Replace ist auf die Suche im aktuellen Editor beschränkt. Wenn Sie einen Ausdruck suchen, von dem Sie nicht mehr genau wissen, an welcher Stelle er sich befindet, können Sie die Funktion ABAP Source Search verwenden, die ebenfalls über die Tastenkombination (Strg) + (H) zu erreichen ist und auf der Textsuche in SAP HANA basiert.

140

Arbeitsvorrat organisieren

ABAP Source Search aktivieren Wenn Sie die ABAP Source Search zum ersten Mal verwenden wollen, kann es sein, dass Sie die Fehlermeldung Text search services are not supported on … erhalten. Das kann daran liegen, dass die Business Function SRIS_SOURCE_SEARCH nicht aktiv ist. Sie können diese Funktion in Transaktion SFW5 aktivieren bzw. deaktivieren. Beachten Sie, dass die HANA-Textsuchmaschine speicherintensiv ist. Sie kann mehrere Gigabyte Hauptspeicher belegen. Die ABAP Source Search funktioniert im Moment aufgrund des begrenzten Arbeitsspeichers nicht bei einem AWS-Testsystem. Aktivieren Sie hier die Business Function, kann dies zum Absturz des HANA-Server-Prozesses führen.

Vorsicht beim Aktivieren von Business Functions Business Functions sollten Sie nur aktivieren, wenn Sie alle Seiteneffekte absehen können. Lassen Sie solche Änderungen in Ihrer Produktivlandschaft in jedem Fall von einem SAP-Administrator und nur nach Absprache durchführen!

Die Textsuche basiert auf einem Index, dessen Aufbau asynchron erfolgt und bis zu einigen Stunden dauern kann. Verwenden Sie den Report SRIS_CODE_ SEARCH_PREPARATION, um zu prüfen, ob der Index vollständig angelegt wurde. Weitere Informationen finden Sie unter: http://scn.sap.com/commu nity/abap/eclipse/blog/2014/01/23/abap-sourcecode-search. Die ABAP Source Search können Sie wie die Standardsuche über einen einzelnen Editor verwenden. Wenn Sie mehrere Begriffe eingeben, die durch Leerzeichen voneinander getrennt sind, wird eine UND-Verknüpfung angenommen, d. h., nur wenn alle angegebenen Begriffe zutreffen, wird das entsprechende Objekt angezeigt. Weitere logische Operatoren finden Sie in Tabelle 2.6. Operator

Beschreibung

*

Der Wildcard-Operator steht als Platzhalter für eine Kette beliebiger Zeichen.

–

Mit dem Minuszeichen können Sie Begriffe explizit von der Suche ausschließen.

OR

Mit dem OR-Operator können Sie Begriffe mit einem logischen ODER verknüpfen. Ihnen werden dann alle Stellen angezeigt, an denen mindestens einer der angegebenen Begriffe auftaucht.

»«

Anführungszeichen sorgen dafür, dass der angegebene Begriff so gesucht wird, wie er eingegeben wurde, d. h., Leerzeichen werden auch als Leerzeichen gesucht und nicht als logisches UND.

Tabelle 2.6 Operatoren der ABAP Source Search

141

2.8

2

Funktionen der ABAP Development Tools

Sie können zusätzliche Suchfilter definieren, um Ihre Suche etwa auf bestimmte Pakete einzuschränken (siehe Abbildung 2.64). Alternativ können Sie nur bestimmte Objekttypen (wie Klassen, Programme, Funktionsbausteine etc.) durchsuchen lassen oder die Suche auf bestimmte Benutzer einschränken, die für die entsprechenden Objekte verantwortlich sind. Das Sucheingabefeld unterstützt die Autovervollständigung mittels (Strg) + Leertaste. Wollen Sie mit mehreren Kriterien einschränken, können Sie diese einfach getrennt durch ein Leerzeichen angeben.

Abbildung 2.64 Suchbegriff und Suchfilter bei der ABAP Code Search

Mindestvoraussetzung für die ABAP Source Search Die ABAP Source Search ist erst ab SAP NetWeaver AS ABAP 7.4 SP5 verfügbar und funktioniert nur zusammen mit SAP HANA. Die Funktion wurde mit den ABAP Development Tools 2.19 ausgeliefert.

Wie helfen Ihnen die Suchfunktionen nun dabei, Ihren Arbeitsvorrat zu organisieren? Zum einen können Sie nach bestimmten Quelltextfragmenten suchen. So lässt sich z. B. die Frage beantworten, an welcher Stelle »harte« Updates der Tabelle VBAP vorgenommen werden. Für mich persönlich entfaltet diese Funktion aber erst in Verbindung mit gut durchdachten Code- und Kommentarkonventionen ihr volles Potenzial. Stellen Sie sich z. B. vor, Sie müssen einen Fehler beheben, der im Zusammenhang mit einem bestimmten Change Request ins System gespielt wurde, oder suchen eine Änderung, die Kollege X irgendwann im Mai gemacht hat. In diesen Fällen macht es sich bezahlt, neuen Quellcode mit einheitlich formatierten Kommentaren zu verse-

142

Arbeitsvorrat organisieren

hen. Ist dieses Format einmal festgelegt, ist es im Zusammenspiel mit CodeVorlagen (siehe Abschnitt 2.3.2) praktisch kein Mehraufwand, solche Kommentare zu platzieren. So gebe ich bei meinen Entwicklungen in der Regel folgende Informationen an: 왘 Autor 왘 Änderungsdatum 왘 Beschreibung (Dies ist generell bei komplexeren Entwicklungen eine gute Idee.) 왘 angefordert durch 왘 Anforderungsnummer Versehen Sie diese Informationen immer mit den gleichen Schlüsselworten, können Sie auch nach Jahren noch problemlos alle Entwicklungen finden, die z. B. zur Anforderungsnummer CR 0815 gehören. Bei Änderungen an bestehenden Codes hat sich zudem eine Art Stempel etabliert, um eine angepasste Zeile auf den ersten Blick auffindbar zu machen. So ein Stempel könnte z. B. so aussehen: "SCHOEND20140101

Damit haben Sie den Benutzernamen des Änderers und den aktuellen Zeitstempel in Ihrem Kommentar. Eine andere Variante ist es, offene Punkte als Kommentar abzulegen. Sie können solche Kommentare immer mit »Todo:« oder »FixMe:« einleiten. Quelltextsuche in der ABAP Workbench Der Vollständigkeit halber sei erwähnt, dass es auch im SAP GUI ähnliche Funktionen gibt. Zum einen können Sie Transaktion CODE_SCANNER nutzen. Etwas feinere Einschränkungsmöglichkeiten bietet der Report RS_ABAP_SOURCE_SCAN. Bei beiden Suchfunktionen muss aber der Suchraum eingeschränkt werden. Wird dieser zu groß gewählt, dauert die Suche dementsprechend lange.

2.8.2

Lesezeichen

Lesezeichen oder Bookmarks kennen Sie vielleicht aus der ABAP Workbench. Sie können diese innerhalb eines Quelltextes setzen und dann über das Kontextmenü oder per Tastenkombination anspringen. Die Bezeichnung Lesezeichen ist vielleicht etwas irreführend, denn dessen Lebensdauer ist auf ein Editor-Fenster begrenzt. Verlassen Sie dieses, werden die Bookmarks wieder

143

2.8

2

Funktionen der ABAP Development Tools

verworfen. Was würden Sie sagen, wenn Sie ein Buch lesen und Ihr Lesezeichen nach dem Umblättern plötzlich spurlos verschwindet? Der Begriff Sprungmarke würde deshalb vielleicht besser passen, d. h., Sie können z. B. eine Markierung in die Datendeklaration und eine an die Stelle setzen, an der Sie gerade arbeiten, und so sehr schnell zwischen diesen beiden Punkten hin und her springen. Dauerhafter verhält sich die Objektliste (Worklist), die Sie in Transaktion SE80 über Utilities 폷 Worklist 폷 Display aufrufen können. Hier können Sie Quelltextabschnitte speichern und diese sogar mit einem Kommentar versehen. Leider wird die Objektliste meiner Erfahrung nach selten oder nur sehr inkonsequent verwendet. Dies mag daran liegen, dass sie sich nicht so leicht in den Arbeitsfluss einfügt. Zudem gibt es kein optisches Feedback im Quellcode zu den gesetzten Markierungen. Das Konzept der Bookmarks in Eclipse ist eine Mischung aus den Bookmarks in der ABAP Workbench und der Objektliste. Sie können Bookmarks mit einem Rechtsklick auf den Vertical Ruler und dem Kontextmenüeintrag Add Bookmark anlegen (siehe Abbildung 2.65). Zu jedem dieser Lesezeichen können Sie zudem einen kurzen Kommentar verfassen. Die Bookmarks werden dann als Marker ( ) im Vertical Ruler angezeigt. Darüber hinaus tauchen sie standardmäßig auch im Overview Ruler auf.

Abbildung 2.65 Bookmark hinzufügen

Außerdem finden Sie alle Bookmarks in Ihrem Projekt im View Bookmarks (siehe Abbildung 2.66), den Sie über den Menüpfad Window 폷 Open View bzw. über den Quick Access öffnen können. Ihre gesetzten Lesezeichen können Sie mit einem Klick auf den entsprechenden Eintrag im Bookmarks-

144

Arbeitsvorrat organisieren

View anspringen. Ihnen werden standardmäßig alle Bookmarks angezeigt, auch die, die sich in anderen (geöffneten) Projekten Ihres Workspaces befinden. Sie können aber die Sicht einschränken. Wählen Sie dazu Configure Content… aus dem Menü des Bookmarks-Views. Sie können z. B. dafür sorgen, dass Ihnen nur die Bookmarks des aktuell geöffneten Objekts angezeigt werden, oder einen Textfilter für die Beschreibung anlegen. Vielleicht haben Sie sich bei der Lektüre der bisherigen Abschnitte eine umfangreiche Sammlung von Beispielen zusammengestellt, die Sie mit Bookmarks kennzeichnen können. Benennen Sie die Bookmarks einheitlich (etwa beginnend mit »Beispiel:«), und schon können Sie den Bookmarks-View als Ihr persönliches Vorlagenverzeichnis verwenden.

Abbildung 2.66 View »Bookmarks«

Um mithilfe der Tastatur zwischen Bookmarks hin und her zu navigieren, können Sie die in Abschnitt 2.4.3, »Lineale und Markierungen«, beschriebene Funktion Next Annotation nutzen. Sie müssen allerdings zuerst sicherstellen, dass auch Bookmarks mit dieser Funktion angesprungen werden. Klappen Sie dazu über das kleine Dreieck neben dem Icon Next Annotation das Menü aus, und markieren Sie den Eintrag Bookmarks (siehe auch Abbildung 2.42). Von nun an können Sie über die Funktionen der Toolbar oder mit den Tastenkürzeln (Strg) + (.) bzw. (Strg) + (,) zwischen Ihren Lesezeichen hin und her springen. Positionierung von Bookmarks Beachten Sie, dass Bookmarks, anders als Einträge in der ABAP-Objektliste, nicht starr an einer Zeile hängen, d. h., wenn Sie über einem Bookmark Zeilen einfügen oder löschen, verschiebt sich auch das Lesezeichen dementsprechend.

2.8.3

Aufgaben verwalten

Früher habe ich offene Punkte oft als Kommentar in meinen Quelltext geschrieben, um dann am nächsten Tag an dieser Stelle weitermachen zu können. Leider ist es manchmal bei diesem Kommentar geblieben. Mit den

145

2.8

2

Funktionen der ABAP Development Tools

neuen Suchfunktionen bzw. mit Transaktion CODE_SCANNER ist es zwar möglich, nach To-do-Kommentaren zu suchen, aber wirklich bequem ist dieses Vorgehen nicht. Zudem sollten Sie versuchen, Quelltexte von solchen persönlichen Notizen frei zu halten. Schöner wäre es, solche Aufgaben als Metadaten an den Quelltext zu heften. Dies ist in Eclipse möglich. Auf die gleiche Art, auf die Bookmarks angelegt werden, ist es auch möglich, Aufgaben zu definieren. Nutzen Sie dazu wieder das Kontextmenü des Vertical Rulers, und wählen Sie Add Task… (siehe Abbildung 2.65). Zusätzlich zu einer Beschreibung können Sie hier auch eine Priorität vergeben. Aufgaben erscheinen als Markierung im Vertical Ruler und zusätzlich in einem eigenen Tasks-View. Verwechseln Sie diese nicht mir der Task List oder dem Task Repository, über die Sie in Abschnitt 2.8.5, »Aufgabenverwaltung mit Mylyn«, noch mehr erfahren. Den View Tasks können Sie ähnlich wie den View Bookmarks anpassen. Es gibt hier bereits einen vordefinierten Textfilter, mit dem Sie auf »TODOs« einschränken können, d. h., es werden nur Aufgaben angezeigt, in deren Beschreibung der Begriff TODO in Großbuchstaben vorkommt. Sie können aber auch beliebige eigene Filter eingeben. Sie haben im Tasks-View zudem die Möglichkeit, eine Aufgabe als erledigt zu markieren. Damit ist der Funktionsumfang dieser einfachen Aufgabenliste auch schon erschöpft. Sie soll allerdings auch nicht die Aufgaben eines ganzen Projektteams koordinieren, sondern möglichst einfach sein, damit Sie schnell und ohne große Unterbrechungen Ihres Arbeitsflusses Aufgaben festhalten können, zu denen Sie später noch kommen wollen, z. B. »Implementiere diese Methode!« oder »Erstelle einen eigenen Datentyp!«. So können Sie sich darauf konzentrieren, eine Aufgabe zu beenden, ohne dabei Gefahr zu laufen, etwas zu vergessen, das Sie für den Moment zurückgestellt hatten. Wenn Ihnen die Möglichkeiten des Tasks-Views nicht genügen, sei Ihnen Abschnitt 2.8.5, »Aufgabenverwaltung mit Mylyn«, ans Herz gelegt, in dem Sie eine wesentlich mächtigere Möglichkeit kennenlernen werden, Aufgaben, Bug-Reports oder Anforderungen zu managen. Auch Aufgaben lassen sich mit (Strg) + (.) bzw. (Strg) + (,) anspringen, dazu müssen Sie ein Häkchen bei Next Annotation 폷 Tasks in der Toolbar setzen. Die Annotationen für Tasks und Bookmarks können Sie in den Einstellungen unter Window 폷 Preferences 폷 Editors 폷 Text Editors 폷 Annotations anpassen.

146

Arbeitsvorrat organisieren

2.8.4

Quellcode-Links

Mit Bookmarks und Tasks können Sie zwar Ihren eigenen Arbeitsvorrat organisieren, die Interaktion mit den Kollegen haben wir dabei aber völlig außen vor gelassen. Leider gibt es keine einfache Möglichkeit, BookmarkListen auszutauschen. Allerdings bringen die ADT ein praktisches neues Feature mit, um Quellcode-Stellen einfach mit Kollegen auszutauschen, und zwar über einen ABAP-Link. Dabei handelt es sich um eine URL, die z. B. per E-Mail oder Messenger geteilt werden kann. Die URL beginnt mit einem eigenen Protokoll, für das die ADT registriert sind. Sobald Sie auf den Link klicken, öffnet sich die entsprechende Stelle im Quelltext in Ihrer EclipseUmgebung – sofern Sie einen Benutzer für das betreffende System haben. Bevor Sie diese sogenannten ADT-Links nutzen können, müssen Sie in den Einstellungen unter Window 폷 Preferences 폷 ABAP Development Ihre Eclipse-Umgebung als Handler für das Protokoll adt einstellen (siehe Abbildung 2.67). Haben Sie mehrere Eclipse-Installationen im Einsatz, können Sie wählen, welche die Code-Links öffnen soll.

Abbildung 2.67 Handler für ADT-Links aktivieren

1. Öffnen Sie die Klasse ZCL_ISSUE, und markieren Sie ein paar Zeilen in der Klasse. 2. Klicken Sie mit der rechten Maustaste auf die markierte Stelle, und wählen Sie im Kontextmenü den Eintrag Share Link for Selection. 3. Wählen Sie ADT-Link, und klicken Sie anschließend auf den Button Copy link to clipboard (siehe Abbildung 2.68). Alternativ können Sie den Link auch direkt per E-Mail versenden. Eclipse ruft dann Ihr Standard-E-Mail-Programm auf und fügt den Link in eine Nachricht ein.

147

2.8

2

Funktionen der ABAP Development Tools

Abbildung 2.68 Link in die Zwischenablage kopieren

4. Schließen Sie die Registerkarte mit dem Editor und die Entwicklungsumgebung. 5. Fügen Sie den Link z. B. in eine Datei in einem Textverarbeitungsprogramm ein. Sorgen Sie gegebenenfalls dafür, dass der Link auch als Hyperlink erkannt wird. Der Link sollte etwa so aussehen: adt://A4H/sap/bc/adt/oo/classes/zcl_issue/source/main#start=18,0;end= 21,35 6. Klicken Sie auf den Link, öffnet sich Eclipse und fordert Sie auf, sich am System anzumelden. Sie können übrigens auch ganze Objekte mit einem Link markieren. Klicken Sie dazu im Project Explorer mit der rechten Maustaste auf das entsprechende Objekt, und wählen Sie im Kontextmenü den Eintrag Share Link. Auch wenn Sie keinen Editor zur Hand haben, der Ihren ADT-Link automatisch als Hyperlink erkennt, können Sie diese Funktion verwenden: 1. Starten Sie die ADT in Eclipse. 2. Wählen Sie Navigate 폷 Open ADT Link, oder nutzen Sie die Tastenkombination (Strg) + (Alt) + (O). 3. Fügen Sie den ADT-LINK ein, und bestätigen Sie mit OK. Seit SAP NetWeaver 7.4 SP5 und den ABAP Development Tools 2.31 gibt es eine weitere Möglichkeit, Quellcode-Stellen zu teilen – auch, wenn der Empfänger gerade nicht über einen Zugang zu Eclipse oder dem SAP GUI verfügt. Es muss lediglich ein Browser vorhanden sein und eine Verbindung zum Zielsystem bestehen. Der Applikationsserver kann den Quellcode als HTMLSeite im Browser darstellen, auf den Empfänger zugreifen können, die über einen gültigen Benutzer mit den entsprechenden Rechten verfügen. Diese Funktion muss allerdings zunächst aktiviert werden:

148

Arbeitsvorrat organisieren

1. Starten Sie Transaktion SICF, indem Sie in Eclipse die Tasten (Alt) + (F8) (Run ABAP Application) drücken und nach »SICF« suchen. Ein Doppelklick auf den Transaktionsnamen startet den SAP GUI. 2. Wechseln Sie in die Servicehierarchie, indem Sie (F8) drücken. 3. Öffnen Sie den Pfad Default Host 폷 SAP 폷 BC 폷 ADT. 4. Klicken Sie mit der rechten Maustaste auf den Service ADT, und wählen Sie Activate Service. Bestätigen Sie die Aktivierung anschließend. Nach dem Aktivieren haben Sie im Fenster Link freigeben (siehe Abbildung 2.68) neben dem ADT-Link auch die Möglichkeit, einen HTTP-Link zu generieren. Den so erstellten Link können Sie in einem beliebigen Browser öffnen (siehe Abbildung 2.69). Sogar die Anzeige auf einem mobilen Gerät ist prinzipiell möglich.

Abbildung 2.69 HTTP-Link im Browser anzeigen

149

2.8

2

Funktionen der ABAP Development Tools

Neustart der Entwicklungsumgebung Sollte die Funktion zur Generierung des HTTP-Links auch nach dem Aktivieren des SICF-Services nicht verfügbar sein, starten Sie die Entwicklungsumgebung neu.

2.8.5

Aufgabenverwaltung mit Mylyn

Mylyn ist ein Plug-in, das mittlerweile einen festen Platz in den Eclipse-Auslieferungen hat. Dabei handelt es sich, einfach gesagt, um eine Aufgabenverwaltung. Mit dieser Kategorisierung wird man den Möglichkeiten dieses Plug-ins allerdings kaum gerecht. Wir sehen uns an dieser Stelle die Basisfunktion von Mylyn an, damit Sie Ihre ersten Gehversuche unternehmen können. Über dieses Plug-in wurden ganze Bücher verfasst, daher bitte ich zu entschuldigen, dass wir uns nicht in voller Breite mit diesem Thema befassen können. Möchten Sie noch weitere Informationen zu Mylyn bekommen, ist die Mylyn-Seite auf der Eclipse-Homepage ein guter Anlaufpunkt: http:// eclipse.org/mylyn/start/. Aufgabenkontext Kennen Sie Mylyn bereits, haben Sie vielleicht schon vom Aufgabenkontext Gebrauch gemacht, mit dem Sie Entwicklungsobjekte an die aktuelle Aufgabe binden können. Bei Wiederaufnahme der Aktivität werden nur die Objekte aus dem Aufgabenkontext angezeigt, sodass Sie fokussiert an einer Aufgabe arbeiten können. Diese Funktion wird in den ADT nicht voll unterstützt. Sie können keine einzelnen Repository-Objekte hinzufügen, Mylyn merkt sich allerdings, welche Editoren Sie geöffnet haben. Wenn Sie eine Aufgabe aktivieren werden die entsprechenden Editoren angezeigt. Die Funktion Link With Editor ( ) sollten sie ggf. kurzzeitig deaktivieren, da Eclipse sonst versucht, zu jedem Editor das entsprechende Objekt im Project Explorer zu öffnen, was einige Zeit in Anspruch nehmen kann. Lokale Aufgaben

Lokale Aufgaben Lokale Aufgaben in Mylyn dienen wie die Aufgaben, die wir in Abschnitt 2.8.3, »Aufgaben verwalten«, besprochen haben, primär der eigenen Organisation. Der zentrale Einstiegspunkt ist der View Task List. Diese lokale Aufgabenliste bietet Ihnen allerdings einige Möglichkeiten mehr als die einfachen Aufgaben des Views Tasks. 1. Öffnen Sie den View Task List über Window 폷 Show View 폷 Other … 폷 Task List.

150

Arbeitsvorrat organisieren

2. Klicken Sie mit der rechten Maustaste in den View, und wählen Sie Local Task im Kontextmenü, oder drücken Sie die (Einfg)-Taste. 3. Geben Sie einen Titel für Ihre lokale Aufgabe an (siehe 1 in Abbildung 2.70).

Abbildung 2.70 Aufgabe anlegen

4. Geben Sie an, wann Sie die Aufgabe angehen möchten und wann die Aufgabe spätestens fällig ist. Sie können zudem eine Schätzung über die voraussichtliche Dauer der Aufgabe abgeben 2. 5. Beschreiben Sie die Aufgabe näher 3. 6. Legen Sie die Priorität der Aufgabe fest 4, und speichern Sie Ihre Aufgabe mit der Tastenkombination (Strg) + (S). Sie können Ihre Aufgaben auch kategorisieren. Dazu müssen Sie vorher eine Kategorie über das Kontextmenü der Task List (Eintrag Category) anlegen. Weitere Aufgaben können Sie entweder direkt in der Kategorie anlegen oder per Drag & Drop in die Kategorie verschieben. Darüber hinaus können Sie zu einer Aufgabe beliebig viele Unteraufgaben definieren. Dazu markieren Sie die entsprechende Aufgabe und wählen New 폷 Subtask oder die Tasten (ª) + (Einfg). Die angelegte Aufgabenliste bringt einige hilfreiche Funktionen mit. Positionieren Sie die Maus länger auf einem Eintrag (Aufgabe oder Kategorie), um Details einblenden zu lassen (siehe Abbildung 2.71). In einem kleinen Balken unten in der Quickinfo wird Ihnen der Gesamtfortschritt angezeigt. Über die Symbolleiste können Sie Ihre Aufgaben in der Liste nach Kategorien gruppieren ( ) oder die Liste nach Erledigungsdatum einteilen lassen ( ). Die bereits erledigten Aufgaben können Sie ausblenden ( ). Die Funktion Focus on Workweek ( ) stellt sicher, dass Sie von Ihrer Aufgabenflut

151

2.8

2

Funktionen der ABAP Development Tools

nicht überwältigt werden, sondern nur das sehen, was Sie sich für diese Woche vorgenommen haben.

Abbildung 2.71 Funktionen der Task List

Um lokale Aufgaben mit Ihren Kollegen zu teilen, steht Ihnen eine Importund Exportfunktion zur Verfügung. Markieren Sie die Aufgaben, die Sie exportieren möchten, und wählen Sie Import and Export 폷 Export im Kontextmenü. Die gewählten Aufgaben werden als gezippte XML-Datei abgespeichert. Über die Funktion Import and Export 폷 Import können Sie analog Aufgaben wieder importieren. Wirklich kollaborativ lässt sich über den Austausch lokaler Aufgaben via XML jedoch nicht arbeiten.

Task Repositories Vielleicht setzt Ihr Unternehmen bereits Ticketsysteme oder Bug-Tracker (d. h. Lösungen zur Meldung und Verfolgung von Fehlermeldungen und neuen Anforderungen) ein, um Anfragen und Aufgaben zu verwalten. Mylyn bietet eine Integration mit einer Vielzahl von Ticketsystemen an, z. B. Bugzilla (http://www.bugzilla.org), ein freies webbasiertes Tracking-System. Eine Liste der unterstützen Systeme finden Sie unter http://wiki.eclipse.org/ Mylyn/Extensions. Bugzilla-Testsystem Es gibt einige fertig konfigurierte freie Testumgebungen für Bugzilla im Internet, z. B. Landfill (https://landfill.bugzilla.org/), eine Testumgebung, in der Bugzilla in verschiedenen Versionen gehostet wird. Sie können sich kostenlos für eine oder mehrere Versionen registrieren. Verwenden Sie möglichst nicht das aktuellste Release, da dieses unter Umständen nicht von Mylyn unterstützt wird. Ich verwende Version 4.4 (https://landfill.bugzilla.org/bugzilla-4.4-branch/).

152

Dokumentation

2.9

Dokumentation

Vielleicht haben Sie sich auf Ihrer bisherigen Reise durch Eclipse schon gefragt, was mit den Beschreibungen und Dokumentationen ist, die Sie in der ABAP Workbench bei den meisten Entwicklungsobjekten vergeben konnten oder sogar mussten. Dieses Konzept wurde in den ADT (teilweise) abgelöst. Es wurde ein spezielles Kommentarformat entwickelt, mit dem Objekte dokumentiert werden können und das als ABAP Doc bezeichnet wird. ABAP Doc können Sie für Klassen, Programme oder Funktionsbausteine verwenden. Aber auch lokale Variablen und Typendeklarationen können Sie mit Dokumentationen anreichern. Im Eclipse-Editor können Sie sich die Dokumentation mit der Funktionstaste (F2) oder im View ABAP Element Info anzeigen lassen. Eine ähnlicher Ansatz wird schon seit Jahren bei Programmiersprachen wie Java oder C# verwendet. Um ABAP Doc zu nutzen, müssen Sie mindestens über einen SAP NetWeaver AS ABAP 7.4 SP2 verfügen. Eine Unterstützung des AS ABAP 7.31 ist derzeit nicht geplant. Weitere Informationen zu ABAP Doc finden Sie unter http://scn.sap.com/docs/DOC40872.

2.9.1

Objekte dokumentieren

Bei ABAP Doc handelt es sich um speziell formatierte Kommentare, die Sie in ABAP vor den meisten Deklarationen ergänzen können. ABAP-Doc-Kommentare werden mit "! eingeleitet. Hinter diesem Zeichen kann dann ein beliebiger beschreibender Text stehen, z. B.: "! Nummer des aktuell bearbeiteten Belegs lf_order_number TYPE VBELN.

Bei mehrzeiligen Kommentaren muss jede neue Zeile mit "! eingeleitet werden. Eclipse fügt dieses Kommentarzeichen bei jedem Zeilenumbruch automatisch hinzu. "!Enthält die erste Position "!des aktuellen Belegs ls_item TYPE VBAP.

Auch Methoden, Funktionsbausteine und Form-Routinen können Sie mit ABAP Doc dokumentieren. Zudem können Sie zusätzliche Beschreibungen zu Parametern und Ausnahmen angeben. Dazu stehen Ihnen die in Tabelle 2.7 zusammengefassten Schlüsselwörter zur Verfügung. Beachten Sie, dass Sie auch hier ein "! voranstellen müssen.

153

2.9

2

Funktionen der ABAP Development Tools

Syntax

Beschreibung

@parameter |

Beschreibung eines Parameters

@exception |

Beschreibung einer Ausnahme

@raising >Ausnahmenname> |

Beschreibung einer klassenbasierten Ausnahme

Tabelle 2.7 ABAP-Doc-Schlüsselwörter

Eine dokumentierte Methode könnte wie in Listing 2.20 aussehen. "! Sets the content of an issue. The current "! content is completely replaced. "! @parameter is_issue | The new content set_issue IMPORTING is_issue TYPE zissue Listing 2.20 Mit ABAP Doc dokumentierte Methode

Auch ABAP Doc bietet Ihnen Quick-Fix-Funktionen an. Erstellen Sie z. B. zu einer Methode einen ABAP-Doc-Kommentar, können Sie sich mit der Tastenkombination (Strg) + (1) Vorlagen für die Parameterkommentare generieren lassen. In begrenztem Umfang haben Sie die Möglichkeit, ABAP Doc zu formatieren. Dazu stehen Ihnen die HTML-Tags aus Tabelle 2.8 zur Verfügung. HTML-Tag

Beschreibung



Überschrift Ebene 1



Überschrift Ebene 2



Überschrift Ebene 3



Absatz



kursiver Text



fett gedruckter Text



unnummerierte Liste



nummerierte Liste

bzw.

Zeilenumbruch

Tabelle 2.8 Unterstützte HTML-Tags zur Formatierung

154

Dokumentation

Den zu formatierenden Text umschließen Sie einfach mit dem entsprechenden Tag. Weitere Deklarationen (wie BODY-Tags) sind nicht erforderlich. Wichtig ist allerdings, dass geöffnete Tags wieder geschlossen werden. Das Schachteln von Tags ist im Augenblick noch nicht möglich. Sonderzeichen und Umlaute müssen in ABAP Doc maskiert werden. Dabei kommt die aus HTML-bekannte Syntax zum Einsatz (siehe Tabelle 2.9). Verstoßen Sie bei der Eingabe Ihres ABAP Docs gegen Syntaxregeln, wird Ihnen dies mit einer Annotation ( ) angezeigt. Zeichen

Escaped

Zeichen

Escaped

<

<

Ä

Ä

>

>

Ö

Ö

"

"

Ü

Ü

'

'

ä

ä

@

@

ö

ö

|

|

ü

ü

Tabelle 2.9 Escaped-Zeichenketten zur Maskierung von Sonderzeichen und Umlauten

Beliebige ASCII-Zeichen ersetzen Tabelle 2.9 zeigt nur eine Teilmenge der unterstützten Sonderzeichen. Sie können auf diese Weise jedes beliebige ASCII-Zeichen abbilden. Eine Referenz finden Sie z. B. hier: http://www.ascii-code.com/.

Im Folgenden statten wir unsere Beispielentwicklung mit einer Dokumentation aus: 1. Öffnen Sie die Klasse ZCL_ISSUE. 2. Fügen Sie Listing 2.21 oberhalb der Klassendeklaration ein: "! Klasse zur Bearbeitung von Issues. "! Es wird das Laden, Anlegen und Ändern "! von Issues unterstützt. CLASS zcl_issue DEFINITION Listing 2.21 Dokumentation von ZCL_ISSUE

3. Springen Sie zur Definition des Constructors von ZCL_ISSUE, und fügen Sie davor den Code aus Listing 2.22 ein. "! Erstellt ein leeres Issue oder lädt "! ein Issue von der Datenbank.

155

2.9

2

Funktionen der ABAP Development Tools

"! Zur Neuanlage geben Sie keine "! issue ID an. constructor IMPORTING ls_issue TYPE z_issue_id EXCEPTIONS no_issue_found optional, Listing 2.22 ABAP Doc zum Constructor in ZCL_ISSUE

4. Drücken Sie (Strg) + (1), während der Cursor noch in der letzten Kommentarzeile steht, und wählen Sie Fügen Sie der Dokumentation fehlende Parameter hinzu. 5. Das System generiert Parameter und Ausnahmenkommentare (siehe Listing 2.23), die Sie ebenfalls ergänzen. "! "! "! "! "!

@parameter if_issue | Inhalt eines Issues Technische Felder wie ERDAT werden automatisch befüllt. @exception no_issue_found | Zur angegebenen ID wurde kein Issue gefunden.

Listing 2.23 Parameter-Dokumentation-Constructors der Klasse ZCL_ISSUE

6. Optional können Sie auf die gleiche Weise zu allen Deklarationen einen ABAP-Doc-Kommentar erstellen. 7. Aktivieren Sie Ihre Änderungen. Es ist generell eine gute Idee, den eigenen Quellcode zu dokumentieren, und das besser früher als später. Vielleicht probieren Sie auch einmal aus, Methoden zuerst zu dokumentieren und erst anschließend zu implementieren. Die Dokumentation kann dann als eine Art Leitfaden bei der Implementierung dienen. Sehr praktisch ist auch, dass lokale Variablen mit einer Dokumentation versehen werden können, was bisher nicht möglich war.

2.9.2

Dokumentation anzeigen

ABAP Doc bietet einen Mehrwert bei der Anzeige, denn die Dokumentation eines Elements steht Ihnen jederzeit zur Verfügung. Sie sehen nicht nur den geschriebenen Kommentar in der Definition, sondern können sich diese Dokumentation auch bei der Verwendung des Elements bzw. bei seiner Implementierung anzeigen lassen. Dazu gibt es drei Möglichkeiten: 왘 Die Code-Vervollständigung greift den ABAP-Doc-Kommentar auf und zeigt ihn als ergänzende Information an (siehe Abbildung 2.72).

156

Dokumentation

Abbildung 2.72 ABAP Doc in der Code-Vervollständigung

왘 Die zweite Variante ist die Code Element Info, die Sie aufrufen, indem Sie (F2) drücken, während Sie mit dem Cursor auf einem dokumentierten Element stehen. Die Code Element Info wird direkt an Ihrem Cursor eingeblendet, und Sie sehen die Signatur des Elements sowie die Dokumentation (siehe Abbildung 2.73). Beachten Sie, dass dies nicht im Deklarationsteil eines Elements funktioniert, sondern nur bei der Verwendung und der Implementierung (etwa bei Methoden).

Abbildung 2.73 Code Element Info

왘 Zu guter Letzt gibt es noch den View ABAP Element Info, der Ihnen die Signatur und die Dokumentation des aktuellen Elements anzeigt. Sie erreichen ihn über die View-Auswahl (Window 폷 Open View 폷 Other bzw. (ª) + (Alt) + (Q), (Q)). Alternativ gelangen Sie zu dem View, wenn Sie in der Code Element Info ((F2)) auf das @-Zeichen in der linken unteren Ecke klicken. Der Inhalt des Views entspricht dem der Code Element Info, mit dem Unterschied, dass der View nicht ausgeblendet wird, sondern bei Bedarf ständig geöffnet sein kann.

157

2.9

2

Funktionen der ABAP Development Tools

Klassische Dokumentation Beim Aufruf der Dokumentation in der Code Element Info macht es keinen Unterschied, ob Sie klassisch im SAP GUI kommentiert oder ABAP Doc verwendet haben. In beiden Fällen wird Ihnen die Dokumentation angezeigt. Sind beide Versionen vorhanden, erhält ABAP Doc den Vorzug.

2.9.3

Dokumentation importieren

Haben Sie bestehende Entwicklungen, die Sie gerne in Eclipse fortsetzen möchten, müssen Sie die Kommentare nicht neu anlegen. Zum einen zeigt Ihnen die ABAP Element Info auch die bestehende Dokumentation des Elements an, zum anderen bieten Ihnen die ADT die Möglichkeit, bestehende Dokumentationen zu importieren. Dazu wählen Sie aus dem Source-Menü, das Sie mit der Tastenkombination (ª) + (Alt) + (S) oder im Kontextmenü des Quelltextes aufrufen, den Eintrag Import ABAP Doc from Description. Daraufhin wird ein valides ABAP Doc generiert, Umlaute werden allerdings unter Umständen falsch dargestellt. Beachten Sie daher die Warnungen, die Ihnen angezeigt werden. Sie können ABAP Doc nur in Objekte laden, die Sie auch ändern können. Gehen Sie wie folgt vor, wenn Sie eine bestehende Entwicklung fortführen möchten: 1. Öffnen Sie die Klasse ZCL_PROJECT in der ABAP Workbench. 2. Legen Sie die Methodendeklarationen inklusive einer Beschreibung an, wie in Abbildung 2.74 dargestellt.

Abbildung 2.74 Methoden von ZCL_PROJECT

3. Legen Sie zur Methode is_persistent den Rückgabeparameter rf_persistent an, und vergeben Sie auch hier eine Beschreibung (siehe Abbil-

158

Dokumentation

dung 2.75). Dies soll als Beispiel zunächst genügen. Möchten Sie noch mehr ausprobieren, können Sie die Methodendeklarationen basierend auf Abbildung 2.2 vervollständigen.

Abbildung 2.75 Methodendeklaration von IS_PERSISTENT

4. Speichern und aktivieren Sie die Klasse. 5. Wechseln Sie zu den ABAP Development Tools, und öffnen Sie die Klasse ZCL_PROJECT ((ª) + (Strg) + (A)). 6. Wählen Sie aus dem Kontextmenü Quelle 폷 Import ABAP Doc from Description. Alternativ erreichen Sie das Menü Source auch über die Tastenkombination (ª) + (Alt) + (S). Nach dem Import sollte Ihre Klasse wie in Abbildung 2.76 aussehen. Sie können nun die Dokumentation auch in Eclipse anpassen.

Abbildung 2.76 ZCL_PROJECT mit importierten Beschreibungen

159

2.9

2

Funktionen der ABAP Development Tools

Sprache beachten Der Import der Dokumentation ist sprachabhängig, d. h., wenn Sie sich über Ihr ABAP-Projekt mit der Anmeldesprache Deutsch am Server anmelden, wird die deutsche Dokumentation geladen. Liegt keine Übersetzung für diese Sprache vor, wird keine Dokumentation importiert.

2.9.4

ABAP Language Help

Neben der Objekt-Dokumentation benötigt man von Zeit zu Zeit auch die ABAP-Schlüsselwort-Hilfe. Diese können Sie, wie Sie es von der ABAP Workbench gewohnt sind, mit der Funktionstaste (F1) aufrufen. Befindet sich der Cursor dabei über einem Schlüsselwort, wird die entsprechende Hilfeseite im View ABAP Language Help angezeigt. Sie können über die Funktion Link with Editor ( ) dafür sorgen, dass die Hilfeseite zu dem Schlüsselwort, auf dem sich der Cursor gerade befindet, automatisch angezeigt wird. Zudem bietet Eclipse eine sehr umfangreiche Hilfe zu allen verfügbaren Eclipse-Funktionen an. Diese finden Sie im Menü unter Help 폷 Help Contents. Auch die durch die ADT beigesteuerten Funktionen sind hier unter SAP – ABAP Development User Guide dokumentiert. Die Hilfe ist sehr gut strukturiert und vollständig. Ein Blick in die Hilfe lohnt sich daher in jedem Fall.

160

Leider ist die Softwareentwicklung keine perfekte Welt, in der alles immer auf Anhieb funktioniert. Dass sich Fehler immer wieder einschleichen, lässt sich kaum verhindern. Mit den richtigen Tools ist es jedoch nicht mehr so schwierig, diese aufzuspüren und zu beheben.

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Stellen Sie sich folgendes Szenario vor: Sie erstellen ein neues Programm. Alles läuft super, der Quelltext fließt geradezu aus Ihren Fingern auf den Bildschirm. Sie aktivieren Ihre Kreation, ohne dass Fehlermeldungen auftreten. Sie transportieren das Programm direkt ins Produktivsystem und melden die Fertigstellung. Zwei Wochen später kommt ein freudestrahlender Anwender auf Sie zu und möchte sich für Ihre tolle Arbeit bedanken: »Sie haben ein Programm für die Ewigkeit erschaffen!«. Wem kommt so eine Geschichte bekannt vor? Wahrscheinlich keinem einzigen Entwickler. Der Alltag in der Entwicklung sieht in der Regel anders aus. Zunächst einmal haben wir selten die Gelegenheit, auf der grünen Wiese zu beginnen. Und selbst wenn das möglich ist, wird kaum ein Entwickler auf die Idee kommen, ein Programm freizugeben, ohne es zumindest einmal ausgeführt zu haben. In der Regel ist der Entwicklungsprozess von unzähligen Entwicklertests begleitet, gefolgt von Integrationstests sowie anderen Qualitätssicherungsmaßnahmen. Dabei fallen leider immer wieder Probleme und Fehler auf, die analysiert, verstanden und behoben werden müssen. Darüber hinaus kommt es häufig vor, dass sich Anforderungen ändern und Programme umgebaut werden müssen. Dass dies einen erheblichen Aufwand nach sich zieht, muss ich Ihnen wahrscheinlich nicht erzählen. In diesem Kapitel geht es daher um Funktionen in den ABAP Development Tools for SAP NetWeaver (ADT), die Sie bei diesen alltäglichen Herausforderungen unterstützen.

161

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

3.1

Testen

Testen ist für viele Entwickler gleichbedeutend mit ausprobieren. Programme, Funktionsbausteine oder Klassen werden während der Entwicklungsphase aufgerufen und mit verschiedenen Parametern gefüttert, um auszuprobieren, ob die Entwicklung sich so verhält, wie man es vorgesehen hat. Werden im Anschluss daran noch Änderungen vorgenommen, werden nur noch bestimmte (Test-)fälle abgeklopft. Dieses Vorgehen hat jedoch wenig mit einem strukturiertem Testen zu tun. Dazu bringt ABAP seit Jahren ein mächtiges Tool mit: ABAP Unit. Einer der Vorteile von ABAP-Unit-Tests besteht darin, dass sich diese Tests immer wieder ausführen lassen. Der größte Aufwand besteht daher einmalig beim Erstellen der Tests, die Ausführung der Tests ist dagegen ohne großen Aufwand möglich. So können Sie eine Entwicklung immer wieder testen, wenn Änderungen vorgenommen wurden. Damit erkennen Sie schneller Seiteneffekte Ihrer Software und verbessern die Qualität Ihrer Programme. In diesem Abschnitt geht es weniger um das Vorgehen und die Techniken bei Softwaretests im Allgemeinen oder Unit-Tests im Besonderen, sondern lediglich um die Werkzeuge, die Ihnen dazu in Eclipse zur Verfügung stehen. Vielleicht kann ich Sie sogar ermutigen, sich zum ersten Mal an Unit-Tests zu wagen und diese zukünftig regelmäßig durchzuführen.

3.1.1

ABAP-Testklassen

Die Grundlage der Unit-Tests in ABAP bildet eine ABAP-Testklasse. Diese können Sie als lokale Klasse in einem Include anlegen und zum Testen von Reports, Funktionsbausteinen und – wahrscheinlich die bekannteste Variante – Klassen nutzen. Wir betrachten hier exemplarisch das Testen von Klassen. Als Grundlage für unsere Beispiel-Unit-Tests dient uns die Klasse ZCL_PROJECT, die wir in Abschnitt 2.2.4, »Klassen«, entwickelt haben. Bisher besteht diese Klasse nur aus leeren Methoden. Den Quellcode der vollständig implementierten Klasse, die in diesem Abschnitt als Ausgangspunkt dient, können Sie auf der Webseite von SAP PRESS unter www.sap-press.de/3700 im Bereich Materialien zum Buch herunterladen. Vielleicht ist Ihnen schon aufgefallen, dass im Editor-View für Klassen eine Reihe von Registerkarten unterhalb des Quelltextes angeboten wird, darunter die Registerkarte Testklassen (siehe Abbildung 3.1). Hier können Sie lokale Klassen für Ihren Unit-Test implementieren.

162

Testen

Abbildung 3.1 Registerkarte »Testklassen«

Es gibt in den ADT keinen Assistenten, der Sie bei der Anlage von Testklassen unterstützt, trotzdem werden Sie nicht ganz alleine gelassen. Mit den ADT wird ein Template ausgeliefert, das Sie im View Templates unter dem Namen testClass finden. Fixture-Methoden Wenn Sie bereits in der ABAP Workbench mit Testklassen gearbeitet haben, vermissen Sie vielleicht die Fixture-Methoden wie SETUP oder TEARDOWN bei der Vorlage. Sie können dazu einfach ein eigenes Template anlegen und sich dazu ebenfalls eine Vorlage im Download-Bereich zum Buch herunterladen.

Auf Basis dieser Vorlage erstellen Sie eine Testklasse für unsere Klasse ZCL_ PROJECT wie folgt: 1. Öffnen Sie die Klasse ZCL_PROJECT im Editor, und wechseln Sie zur Registerkarte Testklassen. Sie sollten einen leeren Editor-Bereich vorfinden, in dem Sie Ihre Klasse implementieren können. 2. Fügen Sie das Template testClass ein. Am einfachsten geben Sie dazu »testClass« im Editor ein und aktivieren die Code-Vervollständigung mit den Tasten (Strg) + Leertaste. 3. Nennen Sie die neue Testklasse LCL_PROJECT_TEST. Springen Sie mit der Tabulatortaste von einer Variablen des Templates zur nächsten. Die Testeigenschaften HARMLESS (für die Risikostufe) und SHORT (Ausführungsdauer) können Sie so beibehalten. Den Namen der ersten Testmethode ändern Sie in GET_PROJECT. 4. Fügen Sie in der Private Section die Deklarationen der Methoden SETUP und TEARDOWN hinzu, und legen Sie per Quick Fix ((Strg) + (1)) deren Implementierungen an. Ihre Testklasse sollte nun wie in Abbildung 3.2 aussehen. 5. Aktivieren Sie Ihre Änderungen mit der Tastenkombination (Strg) + (F3). Sie haben nun das Grundgerüst für Ihre Unit-Tests angelegt. Der Zusatz FOR TESTING in der Klassendeklaration weist diese Klasse als Testklasse aus. Jede Methode, die Sie anlegen und ebenfalls mit FOR TESTING kennzeichnen, wird automatisch vom ABAP Unit Framework aufgegriffen und als Testmethode ausgeführt. Mit der Klasse CL_ABAP_UNIT_ASSERT, die durch das Framework

163

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

bereitgestellt wird, können Sie verschiedene Bedingungen prüfen, Tests gezielt fehlschlagen lassen oder den gesamten Testablauf abbrechen. Das Template enthält bereits einen Aufruf der Methode FAIL dieser Klasse als Vorlage (Zeile 15 in Abbildung 3.2).

Abbildung 3.2 Neu erstellte Testklasse LCL_PROJECT_TEST

Bei den beiden Methoden SETUP und TEARDOWN handelt es sich um sogenannte Fixture-Methoden. Sie werden ebenfalls vom ABAP Unit Framework aufgerufen. Die Methode SETUP wird jedes Mal vor und die Methode TEARDOWN jedes Mal nach dem Aufruf einer Testmethode aufgerufen. Sie dienen dazu, jeder Testmethode einen definierten Ausgangsstatus zu liefern (den Test-Fixture). Es gibt übrigens auch ein »statisches« Pendant zu den beiden Instanzmethoden: Die Klassenmethoden CLASS_SETUP und CLASS_TEARDOWN werden jeweils zu Beginn und am Ende des Gesamttests aufgerufen. Mit unserer einfachen Testklasse können Sie schon einen Unit-Test durchführen: 1. Klicken Sie mit der rechten Maustaste in den Editor-View für die Klasse ZCL_PROJECT. Ob Sie sich gerade auf der Registerkarte Globale Klasse oder im Testklassen-Include befinden, spielt dabei keine Rolle. Wählen Sie im Kontextmenü den Eintrag Run As 폷 ABAP Unit Test, oder verwenden Sie die Tastenkombination (ª) + (Strg) + (F10), um den ABAP-Unit-Testlauf zu starten.

164

Testen

2. Der View ABAP Unit Runner öffnet sich daraufhin und zeigt Ihnen das Ergebnis Ihres Testlaufs an (siehe Abbildung 3.3).

Abbildung 3.3 View »ABAP Unit Runner«

Unser Test ist fehlgeschlagen, was mit einem sehr prominent platzierten roten Balken angezeigt wird. Unterhalb dieses Balkens finden Sie eine Auflistung der Tests, die ausgeführt wurden, inklusive ihrer Ausführungsdauer. Auf der rechten Seite sehen Sie eine detaillierte Fehlermeldung inklusive eines Aufrufstapels (Stack). Im Stack finden Sie alle Aufrufe (Methoden, Funktionen etc.) bis zu der Stelle, die den Fehler verursacht hat. In unserem Fall wurde der Fehler absichtlich innerhalb der lokalen Testmethode erzeugt, um den Test zum Scheitern zu bringen. Den Text der angezeigten Fehlermeldung können Sie bei der Definition Ihrer Tests selbst mitgeben. Mit einem Klick auf den Link im Stack gelangen Sie direkt an die Abbruchstelle im Quellcode. Testdaten und stabiler Testfall Das Testen von ABAP-Quellcode ist leider nicht immer ganz einfach. Dies liegt weniger in der Natur von ABAP als in der Natur des Testumfelds. Die meisten ABAP-Entwicklungen basieren auf fachlichen Daten, die aus der Datenbank stammen. Oft sind diese Daten im Test sehr schwierig nachzustellen und verändern sich auch durch den Test. (Denken Sie etwa an Materialbestände, Kreditlimits oder Belegstatus). Leider gibt es für diese Problematik keine Universallösung. Sie können das Problem nur minimieren, indem Sie schon beim Aufbau Ihrer Implementierungen auf eine gute Testbarkeit achten, z. B. durch eine lose Kopplung der Komponenten sowie durch eine starke Kohäsion innerhalb der Modularisierungseinheiten. Können Sie kleinere Einheiten testen, können Sie die Programmteile, die Sie gerade nicht betrachten, durch Komponenten ersetzen, die immer die gleichen Testparameter liefern, sogenannte Mock-Daten. Nicht immer ist es möglich oder gewollt, Komponenten (hier insbesondere Klassen) auf diese Weise zu entkoppeln. In diesen Fällen ist es schwierig, den Zustand einer Klasse so zu verändern, dass ein bestimmtes Szenario nachstellbar ist, Sie

165

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

können aber Ihre Testklasse zum »Freund« Ihrer zu testenden Klasse erklären, sodass die Testklasse auch Zugriff auf den privaten (PRIVATE SECTION) und geschützten (PROTECTED SECTION) Bereich der zu testenden Klasse erhält. Eine Vorlage zu einer entsprechenden Deklaration stelle ich Ihnen ebenfalls zum Download bereit. Ziel dieses Vorgehens ist es, einen reproduzierbaren Test zu erhalten, der bei jeder Ausführung gleich funktioniert. Daher müssen Sie für einen stabilen Testfall sorgen, die sogenannte Fixture-Methode. Sie für jeden Test aufs Neue bereitzustellen bzw. zu validieren ist die Aufgabe der Fixture-Methoden (SETUP, TEARDOWN, CLASS_SETUP und CLASS-TEARDOWN).

Um unseren Testfall zu definieren, implementieren Sie die Methoden SETUP und TEARDOWN und erstellen anschließend den Test für die Methode GET_PROJECT. Implementieren Sie zunächst die Methode SETUP wie in Listing 3.1. METHOD setup. generate_testdata( ). create object me->mr_project EXPORTING if_project_id = c_pos_project_1 EXCEPTIONS no_project_found = 1 others = 2 IF sy-subrc 0. cl_abap_unit_assert=>abort( |Erstellen der Testklasse | && c_pos_project_1 && | ist fehlgeschlagen| ). ENDIF. ENDMETHOD. Listing 3.1 Implementierung der Methode SETUP

Erstellen Sie als Nächstes mithilfe der Tastenkombination (Strg) + (1) eine Methode GENERATE_TESTDATA, und implementieren Sie diese wie in Listing 3.2. METHOD generate_testdata. ms_testprj_pos_1 = VALUE #( mandt = sy-mandt project_id = c_pos_project_1 project_name = 'Testprojekt' bgdat = '01.01.2015' plend = '31.12.2015' erdat = sy-datum ernam = sy-uname ). MODIFY zproject FROM ms_testprj_pos_1. IF sy-subrc NE 0. cl_abap_unit_assert=>abort( |Projekt | && c_pos_project_1 && | konnte nicht erstellt werden.| ). ENDIF.

166

Testen

COMMIT WORK AND WAIT. ENDMETHOD. Listing 3.2 Implementierung der Methode GENERATE_DATA

Implementieren Sie nun die Methode TEARDOWN der Testklasse wie in Listing 3.3. METHOD teardown. DELETE FROM zproject WHERE project_id = c_pos_project_1. COMMIT WORK AND WAIT. ENDMETHOD. Listing 3.3 Implementierung der Methode TEARDOWN

Erstellen Sie die fehlenden Datendeklarationen per Quick Fix, oder ersetzen Sie die Private Section der Testklasse durch den Quellcode aus Listing 3.4. PRIVATE SECTION. METHODS: "[...] generate_testdata. DATA: ms_testprj_pos_1 TYPE zproject, mt_issues TYPE z_issue_t, mr_project TYPE REF TO zcl_project. CONSTANTS: c_pos_project_1 TYPE z_projekt_id VALUE '$UT-0001'. Listing 3.4 Private Section der Testklasse LCL_PROJECT_TEST

Zu guter Letzt ersetzen Sie die Implementierung der Methode GET_PROJECT durch den Code aus Listing 3.5. METHOD get_project. DATA: ls_project TYPE zproject. ls_project = me->mr_project->get_project( ). cl_abap_unit_assert=>assert_equals( msg = | Datenbankprojekt unterscheidet sich vom geladenen | && |Projekt| exp = me->ms_testprj_pos_1 act = ls_project ). ENDMETHOD. Listing 3.5 Implementierung der Methode GET_PROJECT

Führen Sie den Test nun über die Tastenkombination (ª) + (Strg) + (F10) oder Run As 폷 ABAP Unit Test aus, sollte Ihnen der ABAP Unit Runner einen grünen Balken anzeigen, um Ihnen mitzuteilen, dass alle Tests erfolgreich durchlaufen wurden.

167

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Die Gültigkeit der Testdaten stellen Sie sicher, indem Sie diese selbst anlegen und wieder aufräumen. Bei unserem einfachen Datenmodell brauchen Sie dazu nur ein Datenbank-Update durchzuführen. Seien Sie jedoch vorsichtig, wenn Sie mit SAP-eigenen Tabellen arbeiten. Nutzen Sie in diesen Fällen unbedingt die vorgesehenen Funktionsbausteine und Klassen, um ausschließlich valide Daten anzulegen und nicht aus Versehen andere Datensätze zu zerstören. Verwenden Sie beim Erstellen von Testdaten möglichst nicht die Methoden der Klasse, die Sie gerade testen möchten. Vervollständigen wir nun unseren Unit-Test und testen die restlichen Methoden der Klasse ZCL_PROJECT: 1. Kopieren Sie den Quelltext der Testklasse LCL_PROJECT_TEST, der zum Download auf der Webseite von SAP PRESS bereitsteht, und ersetzen Sie damit den bisherigen Quelltext. 2. Aktivieren Sie Ihre Änderungen, und führen Sie den Test aus ((ª) + (Strg) + (F10)). Einzelne Testmethoden ausführen Sie können auch einzelne Methoden testweise ausführen. Klicken Sie dazu im View Outline mit der rechten Maustaste auf die Testmethode, die Sie ausführen möchten, und wählen Sie Run As 폷 ABAP Unit Test im Kontextmenü. Testmethoden erkennen Sie an dem kleinen grauen T vor dem Methodennamen.

3. Der ABAP Unit Runner zeigt wieder einen roten Balken an, zudem sehen Sie eine Liste aller ausgeführten Tests (siehe Abbildung 3.4). Die Methode GET_PROJECT wurde erfolgreich ausgeführt, die restlichen Tests sind fehlgeschlagen.

Abbildung 3.4 Zweiter Lauf von LCL_PROJECT_TEST

Schauen wir uns die Testmethode CREATE_NEW_PROJECT genauer an. Die Fehlermeldung besagt, dass das Erstellungsdatum nicht korrekt gesetzt wurde.

168

Testen

Offensichtlich wurde nur der Initialwert auf die Datenbank geschrieben. Diesen Fehler können Sie nun mit den Mitteln von Eclipse beheben: 1. Sie befinden sich im View ABAP Unit Runner (siehe Abbildung 3.4). Mit einem Klick auf den Aufrufstapel Include: ms_project-aedat = sy-datum. me->ms_project-aenam = sy-uname.

Ersetzen Sie sie durch die folgenden Zeilen: me->ms_project-erdat = sy-datum. me->ms_project-ernam = sy-uname.

4. Aktivieren Sie Ihre Änderung ((Strg) + (F3)), und führen Sie den Test erneut aus ((ª) + (Strg) + (F10)). Der Test der Methode CREATE_NEW_PROJECT verläuft nun erfolgreich, wir haben aber immer noch drei Problemfälle, deren Test fehlschlägt. Um diese Fehler zu beheben, benötigen wir weitere Werkzeuge, die ich Ihnen in Abschnitt 3.2, »Debugging«, vorstelle.

3.1.2

Code Coverage

Mit Unit-Tests versucht man in der Regel, alle Fälle, die auftreten können, abzudecken, daher sollten alle Zweige des getesteten Quelltextes durchlaufen werden. Ein weit verbreiteter Indikator für die Abdeckung, die ein Test erzielt, ist die sogenannte Code Coverage (Quelltext- oder Testabdeckung). Die Code Coverage zeigt an, welche Teile des Quellcodes bei einem Testfall durchlaufen wurden. Auch in die ABAP-Unit-Welt hat dieser Indikator Einzug gehalten, d. h., Sie können zu jeder Ihrer Testklassen die Abdeckung ermitteln lassen.

169

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Aussagekraft der Code Coverage Die Code Coverage ist eine trügerische Größe. Eine geringe Quelltextabdeckung zu erzielen ist zweifellos ein Indiz dafür, dass Ihre Tests nicht alle möglichen Fälle abdecken. Aber auch 100 % Abdeckung bedeutet noch lange nicht, dass Sie vor Fehlern gefeit sind. Dieser Wert sagt zum einen nichts über die Qualität des eigentlichen Tests aus, zum anderen ist nicht garantiert, dass auch wirklich alle möglichen Wertekombinationen getestet wurden. Die Formel A = B ÷ C können Sie tausende Male problemlos mit unterschiedlichsten Werten durchlaufen. Setzt ein Anwender C auf 0, stürzt Ihr Programm trotzdem ab.

Um die Code Coverage Ihres Unit-Tests zu ermitteln, öffnen Sie die Klasse ZCL_PROJECTS im Editor-View und wählen Coverage As 폷 ABAP Unit Test im Kontextmenü oder drücken die Tasten (ª) + (Strg) + (F11). Der ABAP Unit Runner führt nun Ihren Unit-Test aus, und das Ergebnis wird Ihnen wie gewohnt im View ABAP Unit Runner angezeigt. Darüber hinaus wird ermittelt, welche Anweisungen während der Testausführung durchlaufen wurden. Die Ergebnisse dieser Prüfung werden Ihnen im View ABAP Coverage angezeigt. Zudem werden die Anweisungen der durchlaufenen Klasse im Quelltext-Editor eingefärbt. Der View ABAP Coverage stellt das Ergebnis des Coverage-Testlaufs tabellarisch dar (siehe Abbildung 3.5). Sie erkennen die getestete Klasse und darunter angeordnet die Methoden dieser Klasse. Rechts daneben wird die prozentuale Abdeckung der Anweisungen innerhalb der entsprechenden Methode mit einem kleinen Balken grafisch dargestellt. Die Spalten rechts daneben geben die absoluten Werte an, aus denen die Abdeckungsrate berechnet wurde.

Abbildung 3.5 View »ABAP Coverage«

Neben der Anweisungsabdeckung ermittelt das Werkzeug auch die Verzweigungsabdeckung. Sie können die Ansicht umstellen, indem Sie im ViewMenü, das Sie über das kleine Dreieckssymbol ( ) öffnen, den Eintrag Verzweigungsabdeckung wählen. Die Ansicht ändert sich dabei nur wenig. Der

170

Testen

Aufriss nach Methoden etwa bleibt bestehen, die Werte ändern sich jedoch leicht. Es werden nun alle möglichen Verzweigungspunkte, wie z. B. IFoder CASE-Anweisungen, dahingehend betrachtet, ob sie durchlaufen und ob alle möglichen Fälle untersucht wurden, etwa die Fälle true und false bei einer IF-Anweisung. Diese Statistik kann, richtig ausgewertet, viel über die Qualität Ihrer Tests verraten, auch wenn hier ebenso wie für die Anweisungsabdeckung gilt, dass eine 100 %ige Abdeckung keine Garantie für einen vollständigen Test gibt. Zu guter Letzt können Sie im View-Menü den Eintrag Prozedurabdeckung wählen. Dabei handelt es sich um eine sehr grobe Richtgröße, die angibt, ob eine Routine überhaupt durchlaufen wurde, d. h., hier gibt es nur die Werte 100 % oder 0 %. Der Blick auf diesen Wert eignet sich gut, um sich einen ersten Überblick darüber zu verschaffen, welche Methoden getestet wurden. Ergänzend zu den Daten im View ABAP Coverage zeigt Eclipse farbige Markierungen im Quelltext an. Eine grün hinterlegte Anweisung wurde vom Test mindestens einmal durchlaufen. Eine rote Zeile blieb unberührt. Abbildung 3.6 zeigt die Abdeckung in der Klasse ZCL_PROJECT nach unserem Testlauf.

Abbildung 3.6 Code-Coverage-Markierungen im Quelltext

Betrachten Sie anstelle der Anweisungsabdeckung die Verzweigungsabdeckung, werden nur die entsprechenden konditionalen Anweisungen markiert. Diese können rot, grün oder gelb sein:

171

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

왘 Rot bedeutet, dass diese Anweisung gar nicht durchlaufen wurde. 왘 Gelb heißt, die Anweisung wurde angesprungen, aber es wurden nicht alle Fälle durchlaufen. 왘 Bei einer grünen Markierung wurde die Abfrage vollständig für alle Zweige durchlaufen. Wenn Sie die Markierungen stören, können Sie diese im View ABAP Coverage jederzeit deaktivieren. Klicken Sie dazu auf den Button Hervorhebung Ausblenden ( ) oben rechts. Betrachten Sie die Prozedurabdeckung unseres Testlaufs, sehen Sie sofort, dass die Methode GET_STATUS überhaupt nicht getestet wurde. Einen Test für diese Methode finden Sie bereits auskommentiert in unserer Testklasse. Um die Kommentarzeichen zu entfernen, wechseln Sie auf die Registerkarte Testklassen, setzen den Cursor auf die Definition der Methode GET_STATUS und drücken (Strg) + (7). Suchen Sie anschließend die auskommentierte Implementierung der Methode, markieren Sie diese vollständig, und entfernen Sie mit der Tastenkombination (Strg) + (7) auch hier die Kommentarzeichen. Aktivieren Sie nun die Testklasse mit den Tasten (Strg) + (F3), und führen Sie den Code-Coverage-Lauf mit (ª) + (Strg) + (F11) erneut aus. Wir haben nun eine Prozedurabdeckung von 100 % erreicht. Bei der Anweisungs- bzw. Verzweigungsabdeckung haben wir gut zwei Drittel geschafft, und leider schlagen immer noch vier von sechs Tests fehl. Die Verzweigungsabdeckung kann uns aber schon einen Hinweis darauf geben, an welcher Stelle wir einen Fehler gemacht haben. Auffällig viele Abfragen auf das Ergebnis der Methode IS_PERSISTENT( ) haben nur in einen Ergebnispfad verzweigt. In Abschnitt 3.2 kommen wir im Rahmen des Debuggings darauf zurück.

3.1.3

ABAP Test Cockpit

Das ABAP Test Cockpit (ATC) wurde ursprünglich als internes Werkzeug bei der SAP SE genutzt. Mit SAP NetWeaver 7.0 SP2 wurde es auch öffentlich verfügbar gemacht. Wir konzentrieren uns in diesem Abschnitt auf die Anwendung des ATCs als Entwickler. Trotzdem möchte ich Ihnen kurz die generelle Funktionsweise des ATCs beschreiben. Beim ABAP Test Cockpit handelt es sich um ein Tool zur Qualitätssicherung. Es dient dazu, Unit-Tests und statische Quelltextprüfungen auszuführen. Das ATC ist vollständig in die ABAP Workbench und in die ABAP Development Tools integriert. Die Ergebnisse der Testläufe werden tabellarisch dar-

172

Testen

gestellt und können von einem Entwickler wie eine Aufgabenliste abgearbeitet werden.

Entwicklungssystem 1

Prüfung bei Transportfreigabe Durchführung von Konsolidierungstests und Verteilung der Ergebnisse

Durchführung von statischen, Unitund Szenario-Tests durch Entwickler, Durchführung periodischer Tests

Entwicklungssystem 2

Konsolidierungssystem

Prüfung bei Transportfreigabe

Abbildung 3.7 Qualitätssicherungsprozess mit dem ABAP Test Cockpit (Quelle: SAP)

Das ATC ist nicht nur ein Entwickler-Tool, sondern kann Teil eines Qualitätssicherungsprozesses sein, der in Abbildung 3.7 grafisch dargestellt ist. Entwickler können das ATC während der Implementierungsphase nutzen, um Tests durchzuführen und dafür zu sorgen, dass gewisse Qualitätsstandards eingehalten werden. Beim Transport sorgen automatische Tests dafür, dass nur Quellcode ins Konsolidierungssystem gelangt, der den Qualitätsstandards Ihres Unternehmens entspricht. Im Konsolidierungssystem können dann automatisierte Regressionstests durchgeführt werden, um zu verhindern, dass Änderungen an bestimmten Systemkomponenten Auswirkungen an anderen, vielleicht unvorhersehbaren, Stellen haben (z. B. Signaturänderungen von Funktionsbausteinen). Die Ergebnisse dieser zentralen Testläufe können von Qualitätsmanagern analysiert, auf die Entwicklungssysteme zurückverteilt und als aktiv markiert werden. Daraufhin können sich die Entwickler um die Behebung dieser Fehler kümmern. Die zentrale Transaktion zur Administration der ATC heißt ATC. Als Entwickler werden Sie sich hier allerdings eher selten aufhalten. Um Ihnen die Arbeit mit dem ATC in Eclipse zeigen zu können, planen wir in dieser Transaktion zunächst einen einfachen zentralen Lauf ein. Falls Sie sich unsicher sind, ob Sie das ATC verwenden dürfen oder keine Berechtigung haben, wenden Sie sich an Ihren Systemadministrator oder Qualitätsmanager.

173

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

1. Starten Sie Transaktion ATC im SAP GUI. 2. Wählen Sie aus der Liste der verfügbaren Aktionen den Eintrag Schedule Runs (siehe Abbildung 3.8).

Abbildung 3.8 Verfügbare Aktionen im ABAP Test Cockpit

3. Klicken Sie auf den Button Create (siehe Abbildung 3.9), um eine Konfiguration für den ATC-Lauf anzulegen, die festlegt, welche Tests innerhalb eines Laufs durchgeführt werden.

Abbildung 3.9 Namen für die Konfiguration vergeben

4. Als Namen der Konfiguration wählen Sie z. B. »Z_ISSUE« und bestätigen mit dem grünen Häkchen. 5. Lassen Sie die Beschreibung im Konfigurationseditor so, wie sie ist. Die dort angegebenen Variablen werden später im Protokoll durch die Werte aus dem entsprechenden Lauf ersetzt. Wählen Sie als Check Variant den Wert PERFORMANCE_DB. Als Package wählen Sie Z_ISSUE_LIST.

174

Testen

Code Inspector Der Begriff Check Variant kommt Ihnen vielleicht bekannt vor. Dabei handelt es sich um die Varianten, die Sie im Code Inspector (Transaktion SCI) anlegen und pflegen können und mit denen Sie den Umfang der Prüfungen festlegen, die der Code Inspector ausführen soll. Sie können auch sogenannte Object Sets verwenden, die Sie für den Code Inspector angelegt haben, um eine Menge von Objekten zu definieren, die in einem Lauf berücksichtigt werden sollen. Dazu müssen Sie nur die Auswahl von By Query in By Object Set ändern.

6. Speichern Sie die Konfiguration. 7. Markieren Sie Ihre Konfiguration in der Liste, und planen Sie den Lauf mit einem Klick auf den Button Schedule ein. 8. Es öffnet sich der Dialog Schedule run series, in dem Sie alle Standardeinstellungen vornehmen und den Lauf mit (F8) ausführen können. 9. Kehren Sie zum Hauptbildschirm des ATCs zurück. Damit haben Sie einen ATC-Prüflauf gestartet, was normalerweise im zentralen Qualitätssicherungssystem passieren würde. Über den Eintrag Monitor and Control runs auf der Startseite von Transaktion ATC (siehe Abbildung 3.8) können Sie den Status des Laufs abfragen. Einen abgeschlossenen Lauf erkennen Sie an dem Zielfahnen-Icon ( ) in der Monitoring-Sicht. Sie können das Ergebnis des Laufs aktivieren und verteilen, indem Sie den Eintrag Manage Results auf der Startseite von Transaktion ATC wählen. Aus der so aufgerufenen Liste wählen Sie den letzten Lauf aus und aktivieren dieses Ergebnis mit einem Klick auf den Button Activate (siehe Abbildung 3.10).

Abbildung 3.10 Ergebnisse aktivieren

In der Ergebnisliste sehen Sie auch schon, dass es zwei Probleme mit der Priorität 1 gibt. Wollen Sie sich die Ergebnisse im Detail ansehen, können Sie mit einem Klick auf Display in die ABAP Workbench abspringen und sich dort die entsprechenden Stellen im Quelltext ansehen. Nun geht es daran, die gefundenen Fehler und Probleme zu analysieren und zu beseitigen, d. h.,

175

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Sie als Entwickler sind gefragt. Die Ergebnisse der Qualitätsprüfung finden Sie in Eclipse im View ATC Result Browser. Sie sehen hier alle Systeme, die im aktuellen Workspace eingebunden sind (siehe Abbildung 3.11). Klappen Sie die Knoten auf, wird Ihnen eine Liste mit den durchgeführten Testläufen angezeigt, in der Sie ganz oben das aktive Ergebnis finden. Gehen Sie nun wie folgt vor, um die entsprechenden Code-Stellen zu korrigieren: 1. Markieren Sie das aktive Ergebnis, damit Ihnen auf der rechten Seite des Views die Details zum Lauf angezeigt werden.

Abbildung 3.11 ATC Result Browser

2. Wir wollen uns erst mal auf die Fehler konzentrieren. Markieren Sie den Eintrag Simple Nested Writing DB OP. 3. Klicken Sie mit der rechten Maustaste auf den Eintrag, und wählen Sie Show Details ( ), um eine genauere Beschreibung zu erhalten. Mit einem Klick auf das Icon Show results overview ( ) können Sie jederzeit zur Übersicht zurückspringen. 4. Klicken Sie doppelt auf den Eintrag Simple Nested Writing DB OP, um an die entsprechende Stelle im Quelltext zu gelangen. 5. Die meisten Prüfungen im Code Inspector wurden mit einer ausführlichen Dokumentation versehen. Die Prüfung, die diesen Fehler ausgelöst hat, betrifft die Verwendung eines DELETE-Statements innerhalb einer Schleife. Das Problem lässt sich jedoch leicht beheben. Durch das ATC sollten Sie sich bereits im Quelltext-Editor der Klasse ZCL_PROJECT befinden. Markieren Sie den Quelltextausschnitt aus Listing 3.6. LOOP AT me->mt_issues INTO ls_issue. DELETE FROM zissue WHERE issue_id = ls_issue-issue_id. ENDLOOP. Listing 3.6 Verschachtelte Löschen-Anweisung in der Klasse ZCL_PROJECT

176

Testen

Fügen Sie stattdessen den folgenden Code-Baustein ein: DELETE zissue FROM TABLE me->mt_issues.

6. Aktivieren Sie Ihre Änderungen, wechseln Sie zum ATC Result Browser, klicken Sie mit der rechten Maustaste auf den aktiven Eintrag, und wählen Sie den Eintrag Recheck (Erneut prüfen) im Kontextmenü. Die gleiche Prüfvariante wird nun erneut durchgeführt, allerdings erfolgt der Lauf nur lokal, d. h., die Ergebnisse werden nicht zentral verteilt und tauchen daher auch nicht im ATC Result Browser auf. Stattdessen finden Sie das Ergebnis der erneuten Prüfung im View ATC Problems. Dieser View stellt sozusagen Ihren persönlichen Arbeitsvorrat im ATC dar und ist ähnlich aufgebaut wie die Detailsicht des ATC Result Browsers (siehe Abbildung 3.12).

Abbildung 3.12 View »ATC Problems«

Wie erwartet hat unsere Korrektur den Fehler behoben, und es wird nur noch ein roter Eintrag angezeigt. Schauen wir uns diesen nun genauer an. Springen Sie per Doppelklick auf das Ergebnis an die Fundstelle im Quelltext. Im Gegensatz zu den Ergebnissen des ATC Result Browsers werden Ihnen die Ergebnisse des Views ATC Problems auch als Annotation auf dem Vertical und Overview Ruler angezeigt. Wenn Sie mit der Maus über die Markierung fahren, erhalten Sie weitere Informationen zu diesem Fehler. Versuchen Sie sich doch einmal daran, den Fehler zu beheben, um die Probleme mit höchster Priorität zu beseitigen. Die Warnungen mit Priorität 2 können Sie für unser Beispiel ignorieren. Sie müssen nicht zwangsweise darauf warten, dass Ihnen über das ATC ein Ergebnis zugewiesen wird, sondern können auch proaktiv Prüfungen durchführen. Dabei können Sie entweder die systemweite Standardprüfvariante verwenden oder wie folgt eine eigene Prüfvariante auswählen:

177

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

1. Markieren Sie Ihr aktuelles ABAP-Projekt im Project Explorer. 2. Starten Sie die projektspezifischen Einstellungen mit (Alt) + (¢) oder alternativ im Kontextmenü des Projekts über den Eintrag Properties. 3. Navigieren Sie zur Einstellung ABAP Development 폷 ABAP Test Cockpit (siehe Abbildung 3.13). 4. Aktivieren Sie die Option Global Code Inspector check variant.

Abbildung 3.13 Einstellungen zum ABAP Test Cockpit

5. Wählen Sie »SWF_ABAP_UNIT« als Prüfvariante. Sie können bei der Eingabe die Code-Vervollständigung ((Strg) + Leertaste) verwenden. 6. Bestätigen Sie mit OK. Die Prüfvariante SWF_ABAP_UNIT sorgt dafür, dass vorhandene Unit-Tests für die aktuell gewählten Objekte ausgeführt werden. Das Ergebnis wird dann im View ATC Problems angezeigt. Um die Variante auszuführen, öffnen Sie die Klasse ZCL_PROJECT und drücken die Tasten (ª) + (Strg) + (F2) oder wählen Run As 폷 ABAP Test Cockpit, um das ATC auszuführen. Das ATC führt Ihre Unit-Tests aus und fügt die Ergebnisse dem View ATC Problems hinzu. Die Fundstellen werden wieder im Quelltext hervorgehoben.

178

Testen

Prüfvarianten erstellen Sie sind nicht darauf angewiesen, eine der Standardvarianten des Code Inspectors zu verwenden, sondern können in Transaktion SCI Ihre eigenen Varianten erstellen oder eine Variante verwenden, die von Ihrem Qualitätsmanager bereitgestellt wird. So können Sie über das ATC Ihre Unit-Tests ausführen lassen, ineffiziente SQL-Statements abfragen und dafür sorgen, dass die Entwicklungsstandards durchgängig eingehalten werden.

3.1.4

Laufzeitanalyse

Die Leistung einer Entwicklung zu optimieren kann je nach Komplexität der Anwendung ein schwieriges Unterfangen sein. Oftmals ist nicht auf den ersten Blick ersichtlich, ob die Ursache des Performance-Engpasses ein besonders ineffizientes SQL-Statement ist oder wie lange der Durchlauf einer Schleife dauert. Um diese Code-Stellen einfacher identifizieren zu können, gibt es die Laufzeitanalyse (Transaktion SAT bzw. früher SE30). Die Verwendung dieser Werkzeuge hat sich leider bisher nicht sehr gut in den Arbeitsfluss eingefügt. Mit den ABAP Development Tools wurde die Möglichkeit, Laufzeitanalysen (bzw. den Performance Profiler) auszuführen, direkt in die Entwicklungsumgebung integriert. Um diese Analyse für unsere Klasse ZCL_PROJECT aufzurufen, öffnen Sie die Klasse mit einem Doppelklick im Project Explorer und wählen im Kontextmenü Profile as 폷 ABAP Unit Test. Öffnen Sie anschließend den View ABAP Traces, falls dieser nicht automatisch geöffnet wurde. Dieser View ist nach den Projekten in Ihrem Workspace untergliedert. Klappen Sie ein ABAP-Projekt auf, erhalten Sie eine Liste der letzten Performance-Traces. Klicken Sie doppelt auf einen Eintrag, um den Trace zu öffnen. Sie gelangen zu einer Übersichtsseite wie in Abbildung 3.14. Hier erhalten Sie nur die Metadaten zu Ihrem Performance-Trace-Lauf, eingeteilt in Datenbank-, ABAP- und Systemaufrufe. Interessanter sind die anderen Registerkarten: 왘 In der Hit List (Trefferliste) sind einzelne Anweisungen mit der Häufigkeit des Aufrufs sowie der Einzel- (Netto) und Gesamtausführungszeit (Brutto) aufgeführt. Mit einem Klick auf eine Anweisung springen Sie direkt in den Quelltext. 왘 Der Call Tree (Aufrufstruktur) zeigt nur Routinen und ihre Aufrufhierarchie an. Zudem werden auch hier die Ausführungszeiten ausgegeben.

179

3.1

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Abbildung 3.14 Übersicht des Performance-Traces

왘 Die Call Timeline (Zeitachse) (siehe Abbildung 3.15) visualisiert den Trace grafisch. Verschiedenartige Anweisungen werden mit verschiedenen Farben gekennzeichnet und auf einer Zeitachse aufgeführt. Ein Klick auf eines der Felder bringt Sie an die passende Stelle im Quelltext. 왘 Auf der Registerkarte Database Accesses (Datenbankzugriffe) werden nur Operationen auf der Datenbank angezeigt. Dabei werden der Tabellenname, die Operation sowie die Ausführungshäufigkeit und Ausführungszeit angegeben. Zudem sehen Sie hier auf den ersten Blick, ob es sich um einen gepufferten oder einen ungepufferten Zugriff auf die Datenbank handelte. Performance-Traces, die Sie über Eclipse aufzeichnen, können Sie auch über Transaktion SAT einsehen und umgekehrt.

180

Debugging

Selbstverständlich können Sie einen Performance-Trace auch während einer normalen Programmausführung oder in der ABAP-Objects-Testumgebung aufzeichnen. Wählen Sie dann die Option Profile As 폷 ABAP Application, oder starten Sie den Trace mit (ª) + (Strg) + (F9).

Abbildung 3.15 Zeitachse im Performance-Trace

Performance-Trace bei Unit-Tests Es ist einerseits sehr praktisch, Unit-Tests zur Generierung von Performance-Traces zu nutzen, da sich so Ergebnisse ohne Benutzerinteraktionen reproduzieren lassen, beachten Sie aber, dass der Unit-Test den Performance-Trace verfälscht, da nicht nur die getesteten Methoden mit in die Auswertung fließen. Zum einen werden auch sämtliche Aufrufe des ABAP Unit Frameworks mit berücksichtigt, zum anderen sollten Sie bedenken, dass auch die Fixture-Methoden mit in das Ergebnis einfließen, die ja vor und nach jeder Testmethode durchlaufen werden. In unserer Beispielklasse ZCL_PROJECT machen diese Aufrufe einen Großteil der Datenbankzugriffe aus.

3.2

Debugging

Der ABAP Debugger ist für viele ABAP-Entwicklern über die Jahre zum treuen Freund geworden, um Fehler zu finden, Programme zu analysieren oder Werte von Feldern testweise zu ändern. Auch in Eclipse müssen Sie nicht auf ihn verzichten. Da auch außerhalb der ABAP-Welt fleißig nach Feh-

181

3.2

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

lern gesucht wird, verwundert es nicht, dass in Eclipse ein ähnlich mächtiges Tool wie in der ABAP Workbench herangewachsen ist. In diesem Abschnitt schauen wir uns die Grundfunktionen des Eclipse Debuggers an.

3.2.1

Breakpoints setzen

Meistens beginnt der Einstieg in den Debugger über einen Breakpoint. In Eclipse ist es ähnlich einfach wie in der ABAP Workbench, einen Breakpoint zu setzen. Klicken Sie einfach auf den Vertical Ruler, und ein kleiner Punkt ( ) zeigt an, dass der Breakpoint gesetzt wurde. Breakpoints in Eclipse sind standardmäßig für den angemeldeten Benutzer gesetzt. Sie können aber, genau wie in der ABAP Workbench, auch für andere Benutzer Breakpoints setzen. Dazu können Sie die Breakpoints in den Einstellungen zum Projekt konfigurieren. Markieren Sie dazu das Projekt im Project Explorer, und drücken Sie die Tasten (Alt) + (¢). Sie finden die Einstellungen unter ABAP Development 폷 Debug. Schalten Sie die Einstellung Debugger stops at breakpoints for requests of auf die Option User um, und geben Sie den alternativen Benutzernamen an (siehe Abbildung 3.16).

Abbildung 3.16 Projektspezifische Debug-Einstellungen

Um einen Einstieg in die Analyse der Klasse ZCL_PROJECT zu erhalten, wollen wir einen Breakpoint in dieser Klasse setzen:

182

Debugging

1. Öffnen Sie die Klasse ZCL_PROJECT im Quelltext-Editor. 2. Navigieren Sie zur Methode GET_ISSUES. 3. Klicken Sie in der Zeile mit der IF-Anweisung auf den Vertical Ruler, um einen Breakpoint zu setzen (siehe Abbildung 3.17).

Abbildung 3.17 Breakpoint in der Klasse ZCL_ISSUE setzen

Damit steht unserer Debug-Sitzung nichts mehr im Wege. Solange in den Debug-Einstellungen der Debugger aktiviert ist (siehe Abbildung 3.16), hält die Ausführung der Klasse an jedem Breakpoint an. Anders, als Sie es vielleicht von Java gewohnt sind, müssen Sie eine Anwendung nicht explizit im Debug-Modus starten, obwohl dieser Eintrag im Kontextmenü auch für ABAP-Ressourcen noch angezeigt wird. Voll qualifizierter Hostname Der ADT-Debugger benötigt den Full Qualified Host Name (FQHN) Ihres Servers. Wird dieser von Ihrem System nicht korrekt aufgelöst (etwa wenn Sie den Server in der Cloud betreiben), müssen Sie ihn Ihrem System erst bekannt machen. In Windows-Systemen tragen Sie dazu die IP Ihres Servers, gefolgt vom FQHN, in die Datei hosts ein. Beachten Sie dazu auch den SAP-Hinweis 1906917.

3.2.2

Debugger

Führen Sie nun unseren Unit-Test für die Klasse ZCL_PROJECT erneut aus ((ª) + (Strg) + (F10)), um mithilfe des Debuggers herauszufinden, warum einige der Tests fehlschlagen. Eclipse macht Sie darauf aufmerksam, dass der Debugger in einer eigenen Perspektive ausgeführt wird. Bestätigen Sie dieses Pop-upFenster mit Yes (Abbildung 3.18). Sie können auch die Option Remember My Decision aktivieren, um die Frage nicht erneut beantworten zu müssen. Eclipse wechselt in die Debug-Perspektive, die standardmäßig in fünf ViewStapel unterteilt ist. Abbildung 3.19 zeigt das typische Layout dieser Perspektive. Unten finden Sie den Editor mit dem aktuellen Quelltext 1. Die aktuell bearbeitete Zeile ist grün hervorgehoben und außerdem mit einem kleinen Pfeil ( ) annotiert. Rechts daneben findet sich der Outline-View 2, der hier der Orientierung und der Navigation im Quelltext dient. Im Debug-View 3

183

3.2

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

wird der aktuelle Aufrufstapel angezeigt. Im Variables-View 4 können Sie sich Felder und Werte aus dem aktuellen Programm anzeigen lassen und diese auch ändern. Der View Breakpoints auf der Registerkarte dahinter 5 zeigt alle aktiven Break- und Watchpoints an. Am unteren Rand der Perspektive findet sich der View ABAP Internal Table (Debugger) 6. Hier lassen sich interne Tabellen betrachten und anpassen.

Abbildung 3.18 Wechsel in die Debug-Perspektive

Abbildung 3.19 Perspektive »Debug«

184

Debugging

Die Basisfunktionen des Debuggers beinhalten die Einzelschrittausführung sowie das Springen zur Anweisung – Funktionen, die auch der ABAP Debugger mit Leichtigkeit meistert. Praktischerweise sind die Tastenkürzel für diese Grundfunktionen die gleichen wie in der ABAP Workbench. Tabelle 3.1 zeigt die Buttons und Tastenkombinationen des Eclipse-Debuggers im Überblick. Icon

Tastenkürzel

Funktion

(F5)

Einzelschritt (Step Into)

(F6)

Weiter (Step Over)

(F7)

Herausspringen (Step Return)

(F8)

Weiter (Resume)

(ª) + (F8)

Weiter bis Cursor (Run to Line)

(ª) + (F12)

Zur Anweisung springen (Jump to Line) Anwendung beenden (Terminate) Debugger beenden (Disconnect)

Tabelle 3.1 Grundfunktionen des Eclipse-Debuggers

Beginnen wir nun mit dem Debugging unserer Beispielanwendung. Nachdem Sie den Unit-Test gestartet haben, sehen Sie sich in der Debug-Perspektive die Methode GET_ISSUES an. Prüfen Sie, ob eine Liste von Issues ausgegeben wird: 1. Schauen Sie sich den Aufrufstapel im Debug-View an, und klicken Sie auf die Methode, die GET_ISSUES aufgerufen hat. In Abbildung 3.20 heißt diese Methode ebenfalls GET_ISSUES, es handelt es sich hier jedoch um den Aufruf aus der lokalen Testklasse. 2. Sie gelangen in die Testmethode GET_ISSUE und befinden sich im PositivTestfall. Kehren Sie über den Aufrufstapel zurück zu Ihrem Ausgangspunkt.

185

3.2

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Abbildung 3.20 Aufrufstapel des GET_ISSUE-Testfalls

Führen Sie mit (F6) einen Debug-Schritt aus. Die Ausführung überspringt den positiven Zweig der IF-Anweisung, denn anscheinend liefert die Methode IS_PERSISTENT nicht den Wert ABAP_TRUE. Das sollten wir uns genauer ansehen. 1. Setzen Sie den Cursor auf die IF-Anweisung, und drücken Sie (ª) + (F12), um zurück zu dieser Anweisung zu springen. 2. Drücken Sie (F5), um in die Anweisung IS_PERSISTENT zu gelangen. Dem Rückgabeparameter RF_PERSISTENT wird direkt das Feld MF_STORED übergeben. Fahren Sie mit der Maus über das Feld MF_STORED, zeigt Ihnen ein Pop-up-Fenster den Inhalt der Variablen. Er ist – wie erwartet – leer. 3. Setzen Sie den Wert testweise auf X. Klicken Sie dazu doppelt auf MF_ STORED, um das Feld dem View Variables (siehe Abbildung 3.19, 4) hinzuzufügen. Alternativ können Sie den Variablennamen auch von Hand eingeben. Klicken Sie im View Variables doppelt auf die Spalte Value, um den Wert ändern zu können. Bestätigen Sie mit der (¢)-Taste. 4. Da wir den Wert dieser Variablen vielleicht auch in zukünftigen DebugSitzungen benötigen, fügen Sie ihn zu den Favoriten hinzu. Klicken Sie mit der rechten Maustaste auf den Eintrag, und wählen Sie Keep as Favorite im Kontextmenü. 5. Um zu prüfen, was der neue Wert geändert hat, springen Sie mit (F7) zum Methodenaufruf von IS_PERSISTENT zurück und fahren mit (F6) mit dem nächsten Debug-Schritt fort, der Sie in den positiven Zweig der IF-Bedingung führt. 6. Klicken Sie doppelt auf die Variable RT_ISSUES, die daraufhin sowohl dem View Variables als auch dem View ABAP Internal Table hinzugefügt wird.

186

Debugging

7. Fahren Sie mit (F6) fort. Im View ABAP Internal Table sehen Sie nun den Inhalt der Variablen RT_ISSUES. In diesem View können Sie über das Kontextmenü Zeilen einfügen und löschen. Zudem können Sie den Inhalt der Tabelle direkt im View anpassen. 8. Beenden Sie die Debug-Sitzung mit einem Klick auf den Button Disconnect ( ). Die Ausführung des Programms wird dadurch nicht abgebrochen, aber es werden auch keine weiteren Breakpoints mehr angesprungen. 9. Wechseln Sie zurück in die Perspektive ABAP. Test-Timeout Es kann sein, dass der Test trotz der vorgenommenen Änderungen fehlschlägt. Das liegt daran, dass ABAP Unit auch die Ausführungszeit prüft, was Sie mit der Anweisung DURATION SHORT in der Testdeklaration einstellen. Die Ausführung eines Tests darf bei dieser Einstellung standardmäßig nicht länger als 60 Sekunden dauern. Die Zeiten können aber in Transaktion SAUNIT_CLIENT_SETUP angepasst werden.

Nun müssen wir nur noch herausfinden, warum das Persistenz-Flag MF_ STORED nicht korrekt gesetzt wird. Vermutlich findet sich das Problem beim Laden der Struktur MS_PROJECTS von der Datenbank. Setzen Sie einen Watchpoint, um direkt an diese Stelle zu springen: 1. Wir wollen zu einem möglichst frühen Zeitpunkt in die Analyse des Quellcodes einsteigen. Setzen Sie daher einen Breakpoint in die erste Anweisung des Constructors der Klasse ZCL_PROJECT. 2. Starten Sie eine neue Debugging-Sitzung, indem Sie mit der Tastenkombination (ª) + (Alt) + (F10) einen neuen Unit-Test ausführen. 3. Geben Sie »ME->MS_PROJECT-PROJECT_ID« in dem View Variables in der mit markierten Zelle ein. (Alternativ können Sie auch »ME->MS_PROJECT« eingeben und die Struktur aufklappen.) 4. Klicken Sie mit der rechten Maustaste auf den neuen Eintrag, und wählen Sie Set Watchpoint ( ) aus dem Kontextmenü. 5. Wechseln Sie zum View Breakpoints, und markieren Sie den neuen Watchpoint (siehe Abbildung 3.21). 6. Wir kennen die ID unseres SET_ISSUE-Testfalls, daher können wir den Watchpoint auf einen bestimmten Wert eingrenzen. Geben Sie in das Feld Bedingung den Ausdruck »= $UT-0001« ein.

187

3.2

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Abbildung 3.21 Bedingung zu einem Watchpoint setzen

7. Die verbliebenen Breakpoints stören uns im Moment nur. Markieren Sie diese, und entfernen Sie sie mit der Taste (Entf). Alternativ können Sie die Breakpoints auch nur deaktivieren, indem Sie das Häkchen davor entfernen. Führen Sie die Debug-Session mit der Taste (F8) fort. Der Debugger hält an, sobald der Watchpoint erreicht wird. Im Vertical Ruler zeigt Ihnen ein Symbol ( ) an, dass ein Watchpoint erreicht wurde. An dieser Stelle können Sie mit der Analyse fortfahren. 1. Fügen Sie den Eintrag ME->MS_STORED im View Variables hinzu. 2. Springen Sie im Einzelschrittmodus ((F5)) durch den Constructor, und behalten Sie dabei die Variable MF_STORED im Auge. Wenn Sie in der SETUPMethode des Tests angekommen sind, können Sie den Debugger beenden. Wechseln Sie anschließend wieder in die ABAP-Perspektive. Die Variable MF_STORED ändert sich nicht. Wir haben festgestellt, dass zwar ein Datensatz von der Datenbank geladen, aber das Flag nicht gesetzt wird. Hier können Sie zum Glück einfach Abhilfe schaffen: 1. Springen Sie zum Constructor der Klasse ZCL_PROJECT im Quelltext-Editor. 2. Ergänzen Sie die IF-Abfrage zu SY-SUBRC um einen ELSE-Zweig, der die Variable MF_STORED auf den Wert 'X' setzt (siehe Listing 3.7). IF sy-subrc NE 0. RAISE no_project_found. ELSE. me->mf_stored = abap_true. ENDIF. Listing 3.7 Setzen von MF_STORED

188

Systemmeldungen abonnieren

3. Aktivieren Sie Ihre Änderungen ((Strg) + (F3)), und führen Sie den UnitTest mit (ª) + (Strg) + (F10) erneut aus. Falls noch Breakpoints gesetzt sind, überspringen Sie diese mit (F8). Unser kleiner Bugfix hat nicht nur den Testfall zu GET_ISSUE, sondern auch die anderen Testfälle, die fehlgeschlagen sind, korrigiert. Kleine Ursache, große Wirkung. Anweisungs- und Ausnahme-Breakpoints Sie können auch Breakpoints definieren, die bei bestimmten Anweisungen oder bei Auftreten einer bestimmten Ausnahme aktiv werden. Öffnen Sie dazu den Breakpoint-View, und wählen Sie Add ABAP Breakpoint. Hier haben Sie nun die Möglichkeit, Anweisungs- oder Ausnahme-Breakpoints anzulegen (siehe Abbildung 3.22). Ein Dialog fordert Sie dabei auf, die entsprechende Anweisung bzw. Ausnahme anzugeben. Wenn Sie diese Breakpoints nicht in einer laufenden Debug-Sitzung setzen, müssen Sie daran denken, das Häkchen bei Restrict to running debuggers zu entfernen.

Abbildung 3.22 Anweisungs-Breakpoint setzen

3.3

Systemmeldungen abonnieren

Laufzeitfehlerkönnen nervig und zeitraubend sein, geben aber Aufschluss darüber, dass in einem Programm etwas nicht so funktioniert, wie es sollte. Die ABAP-Runtime-Error-Liste in Transaktion ST22 ist daher ebenfalls ein wichtiges Analyse-Tool für die tägliche Arbeit. Die ADT haben einen eigenen Mechanismus, um solche Systemmeldungen abzufragen. Die Einträge werden vom SAP NetWeaver AS ABAP als Feed bereitgestellt, den Sie über den View Feed Reader abonnieren können. Daraufhin erhalten Sie eine Benachrichtigung, wenn es einen neuen Eintrag gibt. Praktischerweise werden Sie nicht nur über Ihre eigenen Laufzeitfehler benachrichtigt, sondern der Feed liefert alle Nachrichten. So können Sie z. B. überwachen, ob es im laufenden Betrieb Ihrer Anwendungen Probleme gibt, die sonst vielleicht lange unentdeckt geblieben wären.

189

3.3

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Damit Sie aber nicht in der Flut von Meldungen untergehen, können Sie wie folgt Filter definieren: 1. Öffnen Sie den View Feed Reader über Window 폷 Open View 폷 Other … 폷 Feed Reader (oder mit den Tasten (Strg) + (3)). 2. Klicken Sie auf den Button Add Feed ( ) im Menü, und wählen Sie Add feed from repository (siehe Abbildung 3.23).

Abbildung 3.23 Feed hinzufügen

3. Wählen Sie im folgenden Dialog auf der linken Seite Ihr aktuelles ABAPProjekt und auf der rechten Seite ABAP Runtime Errors (siehe Abbildung 3.24). Sie haben auch die Möglichkeit, Systemnachrichten oder neue Einträge aus dem ABAP Test Cockpit abzufragen. Fahren Sie mit Next fort.

Abbildung 3.24 ABAP-Feed definieren

4. Vergeben Sie einen Titel, der im Feed Reader angezeigt werden soll. Ändern Sie die Filterauswahl auf die Variante Package, und geben Sie »Z_ISSUE_LIST«, den Namen Ihres Pakets, ein (siehe Abbildung 3.25). Schließen Sie die Anlage des Feeds mit Finish ab.

190

Systemmeldungen abonnieren

Abbildung 3.25 Abfrageintervall und Filter definieren

Der neu abonnierte Feed wird nun im Feed Reader angezeigt (siehe Abbildung 3.26). Alle fünf Minuten wird geprüft, ob es neue Einträge gibt.

Abbildung 3.26 Laufzeitfehleranzeige im Feed Reader

Wird ein neuer Eintrag gefunden, der Ihren Filterkriterien entspricht, werden Sie benachrichtigt und sehen den neuen Eintrag im Feed Reader. Markieren Sie den Eintrag, um in der Detailsicht eine Beschreibung des Fehlers zu erhalten. Mit einem Doppelklick auf den Eintrag gelangen Sie in Transaktion ST22 im SAP GUI.

191

3.3

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

3.4

Refactoring

Selbst beim besten Software-Design ist es irgendwann notwendig, Änderungen vorzunehmen, was auch Umbauten in Programmen und Klassen nach sich zieht. Dabei kann es sich um das Umbenennen einer Variablen oder das Verschieben ganzer Programmteile in eine neue Modularisierungseinheit handeln. Dieser Prozess wird im Allgemeinen als Refactoring oder Restrukturierung bezeichnet. Das Refactoring zeichnet sich dadurch aus, dass es keine funktionalen Änderungen nach sich zieht, d. h., die restrukturierte Einheit verhält sich nach dem Umbau genau wie vorher. Nur die Struktur hat sich – hoffentlich zum Besseren hin – geändert. Um gleichbleibende Funktionalität zu gewährleisten, werden in der Regel Unit-Tests durchgeführt. Ein Test, der vor dem Refactoring funktioniert hat, sollte danach ebenfalls erfolgreich durchlaufen werden. Die ADT bringen viele Funktionen mit, die Sie bei der Restrukturierung Ihrer Programmierung unterstützen. Ich werde Ihnen die wichtigsten in diesem Abschnitt vorstellen. Eine Liste der verfügbaren Funktionen finden Sie in der Eclipse-Hilfe (Help 폷 Help Contents) unter SAP – ABAP Development User Guide 폷 Tasks 폷 Fundamental Tasks and Tools 폷 Applying Quick Assists 폷 Refactoring ABAP Source Code. Die Klasse ZCL_PROJECT hat unseren Unit-Test in Abschnitt 3.1, »Testen«, und Abschnitt 3.2, »Debugging«, erfolgreich durchlaufen, aber das Potenzial, ein wenig umstrukturiert zu werden. Beginnen wir damit, den Deklarationsteil der Klasse aufzuräumen. Bei der Entwicklung kommt es oft vor, dass Sie eine Idee verfolgen, wieder verwerfen und etwas umbauen müssen. Auch wenn Sie den Quelltext von nicht benötigten Stellen bereinigt haben, bleiben Deklarationen oft unbeachtet stehen. Zwar kann mit einem Verwendungsnachweis geprüft werden, ob eine Variable noch verwendet wird, aber wer will das schon machen, wenn es sich um ein Programm mit hunderten Feldern handelt? Mithilfe der Refactoring-Funktionen von Eclipse können Sie sich so einer Variablen schnell entledigen: 1. Öffnen Sie die Klasse ZCL_PROJECT im Editor, springen Sie zur Private Section, und markieren Sie die komplette Datendeklaration. 2. Wählen Sie im Kontextmenü Quelle 폷 Delete unused variables (selection), oder drücken Sie (ª) + (Alt) + (U). 3. Die Variable MF_ISSUE_ID scheint nicht mehr verwendet zu werden und wurde daher entfernt. Aktivieren Sie Ihre Änderung, und führen Sie den Unit-Test erneut durch. Alternativ können Sie auch mit der Tastenkombination (Alt) + (U) alle nicht verwendeten Variablen im Editor entfernen lassen.

192

Refactoring

Manchmal stelle ich mitten in der Arbeit fest, dass eine Variable einen unpassenden Namen trägt oder eine Methode nur unzureichend die Funktion beschreibt. Wurde die Variable gerade erst deklariert, mag dies kein größeres Problem sein. Wenn aber schon mehrere Tausend Zeilen Code nach dieser Variablen stehen, sieht die Sache schon anders aus. Selbst wenn wir mit der Suchfunktion arbeiten, können wir nie ganz sicher sein, alle relevanten Stellen auch in anderen Modulen gefunden und umbenannt zu haben. Zu diesem Zweck bietet Eclipse eine intelligente Renaming-Funktion an, die auch Verwendungen in anderen Modulen erkennt und korrekt auflöst. In der Klasse ZCL_PROJECT gibt es die Variable MF_STORED, deren Name etwas unpassend ist. Besser wäre MF_PERSISTENT, daher ändern wir diese Bezeichnung wie folgt: 1. Suchen Sie im Quelltext die Deklaration der Variablen MF_STORED. Setzen Sie den Cursor auf den Variablennamen, und drücken Sie die Tasten (ª) + (Alt) + (R). Die Funktion können Sie alternativ auch über Quick Fix auswählen ((Strg) + (1)). 2. Geben Sie im Textfeld den neuen Namen »MF_PERSISTENT« ein, und klicken Sie auf Next. 3. Im nächsten Schritt sehen Sie die betroffenen Objekte. Sie können Eclipse hier dazu zwingen, die Änderung durchzuführen, selbst wenn diese Änderung Syntaxfehler hervorrufen würde. Fahren Sie mit Next fort. 4. Abschließend wird Ihnen genau gezeigt, an welchen Stellen die Änderung greifen wird (siehe Abbildung 3.27). Allerdings haben Sie an dieser Stelle keine Möglichkeit mehr, etwas zu ändern, sondern können nur noch bestätigen oder abbrechen. Bestätigen Sie mit Finish. 5. Aktivieren Sie Ihre Änderungen, und testen Sie das Ergebnis. Auf die gleiche Art und Weise können Sie auch Methoden umbenennen. Achten Sie darauf, keine Konflikte auszulösen, indem Sie den gleichen Namen doppelt vergeben. Methoden anzulegen bedeutet immer einen gewissen Aufwand, auch wenn sich dieser mit Quick Fix drastisch reduziert hat. Wenn sich nicht unmittelbar ein Vorteil für die Arbeit ergibt, scheut man sich oft davor, Funktionen auszulagern. Werden diese Funktionen (etwa eine SELECT-Anweisung) wieder benötigt, wird häufig Copy and Paste anstelle eines sauberen Umstrukturierens verwendet, wodurch QuellcodeDoppelungen in der Entwicklung entstehen. Mit der Funktion Methode extrahieren können Sie ganz einfach Quellcode-Stücke aus einer Programmierung lösen und in eine eigene Methode auslagern. Um die Anlage von Parametern kümmert sich Eclipse.

193

3.4

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

Abbildung 3.27 Details zur Änderung des Feldnamens

In unserer Klasse ZCL_PROJECT haben wir auch dafür ein Beispiel. Im Constructor befindet sich eine SELECT-Anweisung. Wollen wir die Klasse von der Datenbank aktualisieren, ist dies leider nicht möglich, sondern es muss jedes Mal eine neue Instanz erzeugt werden. Dies können wir wie folgt ändern: 1. Navigieren Sie im Quelltext-Editor zur Implementierung des Constructors der Klasse ZCL_PROJECT. 2. Markieren Sie den vollständigen Inhalt des Constructors (siehe Listing 3.8), und wählen Sie im Kontextmenü Quelle 폷 Extract Method, oder drücken Sie (ª) + (Alt) + (M). IF if_project_id IS NOT INITIAL. SELECT SINGLE * FROM zproject INTO me->ms_project WHERE project_id = if_project_id AND loevm = abap_false. IF sy-subrc NE 0. RAISE no_project_found. ELSE. me->mf_persistent = abap_true. ENDIF. ENDIF. Listing 3.8 Inhalt des Constructors der Klasse ZCL_PROJECT

194

Refactoring

3. Es erscheint ein Dialog zur Anlage der Methode (siehe Abbildung 3.28). Geben Sie hier »REFRESH« als Namen für die Methode ein. Beenden Sie die Anlage mit Finish. Die folgenden Schritte verlaufen analog zum Rename-Assistenten und zeigen lediglich die Änderungen.

Abbildung 3.28 Methode extrahieren

4. Aktivieren Sie Ihre Änderungen, und testen Sie erneut. Die extrahierte Methode wurde durch die Markierung der Option Privat in der Private Section der Klasse angelegt. Möchten Sie die Sichtbarkeit der Methode nachträglich noch ändern, setzen Sie den Cursor im Quelltext-Editor auf die Methode REFRESH, drücken Sie die Tasten (Strg) + (1), und wählen Sie die Quick-Fix-Option Make refresh public. Aktivieren Sie Ihre Änderungen, und führen Sie den Unit-Test erneut durch. Sichtbarkeit ändern Beachten Sie, dass Sie mit der Sichtbarkeit auch die Funktionalität Ihres Objekts ändern können. Verstecken Sie eine zuvor öffentliche Methode, kann dies dazu führen, dass Ihr Programm nicht mehr lauffähig ist.

Methoden anzulegen ist ein guter Weg, um die Wiederverwendbarkeit des Codes zu verbessern. Noch besser ist es, gleichartige Funktionen in einer eige-

195

3.4

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

nen Klasse oder einem Interface zu bündeln. Sehen wir uns die Klassen ZCL_ ISSUE und ZCL_PROJECT einmal genauer an. Wie in dem UML-Diagramm in Abbildung 3.29 zu erkennen ist, weisen beide die Methoden SAVE, DELETE und IS_PERSISTENT auf. Alle drei Methoden haben auch jeweils die gleiche Bedeutung. Daher können wir diese Methoden in einem Interface zusammenfassen. ZCL_ISSUE ZCL_PROJECT

-ms_issue: ZISSUE -is_persistent: boolean +mr_comments_cl: zcl_comment +save() +is_persistent(): boolean +delete() +set_issue(is_issue: zissue) +get_issue(): zissue +get_comments(): zcl_comment +add_comment(if_comment: string, if_autor: name) +get_project(): zcl_project

-ms_project: zproject -is_persistent: boolean

0..*

+save() +is_persistent(): boolean +delete() +set_project(is_project: zproject) +get_project(): zproject +get_issues(): zissue_t +get_status(ef_open_items: int4, ef_finished_items: int4, ef_percentage: float)

1

Abbildung 3.29 Struktur der Klassen ZCL_ISSUE und ZCL_PROJECT

Das Ziel-Design könnte etwa wie in Abbildung 3.30 aussehen. Die Funktionen, die mit der Handhabung der persistenten Daten zu tun haben, sind nun in einem Interface zusammengefasst. Man könnte auch die Methode REFRESH noch in das Interface ziehen. Da diese aber noch auf einer objektspezifischen ID als Importing-Parameter beruht, würden wir dazu ein paar Umbauten mehr benötigen. Wenn Sie mögen, können Sie sich ja im Anschluss an die Lektüre dieses Kapitels daran versuchen. Eine mögliche Lösung finden Sie im DownloadBereich zu diesem Buch.

ZIF_PERSISTENT_ITEM

+save() +is_persistent() +delete()

ZCL_ISSUE

-ms_issue: ZISSUE -is_persistent: boolean +mr_comments_cl: zcl_comment +set_issue(is_issue: zissue) +get_issue(): zissue +get_comments(): zcl_comment +add_comment(if_comment: string, if_autor: name) +get_project(): zcl_project

ZCL_PROJECT

0..*

1

-ms_project: zproject -is_persistent: boolean +set_project(is_project: zproject) +get_project(): zproject +get_issues(): zissue_t +get_status(ef_open_items: int4, ef_finished_items: int4, ef_percentage: float)

Abbildung 3.30 Interface ZIF_PERSISTENT_ITEM

196

Refactoring

Legen Sie das Interface wie folgt an: 1. Erweitern Sie die Public Section der Klasse ZCL_PROJECT um das Interface ZIF_PERSISTENT_ITEM aus Listing 3.9. PUBLIC SECTION. INTERFACES zif_persistent_item. Listing 3.9 Interface ZIF_PERSISTENT_ITEM in der Klasse ZCL_PROJECT

2. Das Interface ist noch nicht vorhanden. Legen Sie es via Quick Fix an (Create global Interface ZIF_PERSISTENT_ITEM). 3. Vergeben Sie im Anlage-Dialog eine Beschreibung, und bestätigen Sie die Anlage. Sie landen im Quelltext des angelegten Interfaces. 4. Aktivieren Sie das neue Interface, und wechseln Sie zurück zur Klasse ZCL_ PROJECT. Aktivieren Sie auch diese Klasse, da das neue Interface sonst nicht korrekt erkannt wird. 5. Verschieben Sie die Methode SAVE() in das Interface. Setzen Sie dazu den Cursor auf die Methodendeklaration, und aktivieren Sie Quick Fix. Wählen Sie den Vorschlag Pull-Up save to interface zif_persistent_item. 6. Verfahren Sie genauso mit den Methoden DELETE() und IS_PERSISTENT(). 7. Aktivieren Sie alle Änderungen ((ª) + (Strg) + (F3)), und testen Sie erneut. Eclipse hat nicht nur die Methoden zusammen mit der Dokumentation in das neue Interface verschoben, sondern auch ein Alias für die Methodennamen angelegt, d. h., die Methoden können wie bisher direkt über die Klasse angesprochen werden und nicht nur über den Interface-Namen. Um dasselbe Interface auch in die Klasse ZCL_ISSUE einzufügen, müssen wir allerdings das gute alte Copy and Paste bemühen: 1. Öffnen Sie die Klasse ZCL_ISSUE im Quelltext-Editor, und fügen Sie in der Public Section die Interface-Implementierung aus Listing 3.10 hinzu. PUBLIC SECTION. INTERFACES zif_persistent_item. ALIASES: save FOR zif_persistent_item~save, delete FOR zif_persistent_item~delete, is_persistent FOR zif_persistent_item~is_ persistent. Listing 3.10 Interface ZIF_PERSISTENT_ITEM in der Klasse ZCL_ISSUE

2. Löschen Sie die Deklarationen der Methoden SAVE(), IS_PERSISTENT() und ZCL_ISSUE. Die Methode DELETE() ist in der Klasse ZCL_ISSUE noch

197

3.4

3

Wenn mal etwas schiefläuft: Fehler finden, analysieren und beheben

nicht implementiert gewesen, daher wird Ihnen eine Warnung angezeigt. Klicken Sie auf die Warnung, und wählen Sie Add implementation for delete. 3. Fügen Sie me->ms_issue-loevm = abap_true. als Implementierung der Methode DELETE() ein, und aktivieren Sie Ihre Änderungen. Mit diesem geringen manuellen Aufwand haben Sie das Interface auch in der Klasse ZCL_ISSUE implementiert und können die Basismethoden SAVE, DELETE und IS_PERSISTENT generisch über das Interface aufrufen. Insgesamt haben wir damit das Design unserer Anwendung deutlich verbessert, ohne die Funktionalität zu ändern. Langfristig sorgen solche Refactoring-Läufe dafür, dass die Software wartbar und leicht erweiterbar bleibt. Ich hoffe, ich konnte Ihre Hemmschwelle für das Refactoring durch die Vorstellung der Möglichkeiten in den ADT deutlich reduzieren. Testgetriebene Entwicklung Bei der testgetriebenen Entwicklung (Test-driven Development) wird das Testen an den Beginn des Entwicklungszyklus gestellt. Nach der Anforderungsanalyse wird zunächst überlegt, wie die Anforderungen mit einem Test verifiziert werden können, anschließend wird dieser Test implementiert. Die erste Ausführung des Tests schlägt zwangsläufig fehl. Der Entwickler sorgt nun dafür, dass gerade so viel Code geschrieben wird, dass der Test erfolgreich durchlaufen werden kann. Da der Test ja eine formale Repräsentation der ursprünglichen Anforderung war, kann man diese Anforderung bei erfolgreichem Durchlaufen des Tests als erfüllt ansehen. Anschließend wird der erstellte Code mittels Refactoring so umgebaut, dass CodeDopplungen und schlecht lesbarer Code entfernt werden und Wildwuchs vermieden wird. Danach wird die nächste Anforderung analysiert, als Test implementiert und so fort. Mangels Refactoring-Möglichkeiten in der ABAP Workbench war die testgetriebene Entwicklung in ABAP wenig verbreitet. Mit den neuen Möglichkeiten der ADT eignet sich ABAP aber ähnlich gut wie Java oder C# zur Anwendung dieses Ansatzes. Wenn Sie sich selbst an dieser Entwicklungsmethode versuchen möchten, können Sie die Klasse ZCL_COMMENT nutzen, um ein wenig auszuprobieren. Einen Unit-Test und eine Beispiellösung finden Sie im Download-Bereich dieses Buches.

198

Web Dynpro ABAP ist eine der Schlüssel-UI-Technologien von SAP. Auch in den ABAP Development Tools ist die Web-Dynpro-Entwicklung möglich.

4

Web Dynpro ABAP in Eclipse

Web Dynpro ABAP gehört neben dem SAP UI Development Toolkit for HTML5 (SAPUI5) zu den Schlüssel-Oberflächentechnologien von SAP. Neue Anwendungen sollten daher in Web Dynpro ABAP oder SAPUI5 umgesetzt werden. Für die SAPUI5-Entwicklung steht ein eigenes Toolset in der Eclipse-Entwicklungsumgebung zur Verfügung, das Sie über die Seite https://tools.hana. ondemand.com/#sapui5 beziehen können. Die Entwicklung mit Web Dynpro ABAP ist hingegen in den ABAP Development Tools for SAP NetWeaver (ADT) möglich und Thema dieses Kapitels. Web Dynpro Java Verwechseln Sie die Entwicklungsumgebung für Web Dynpro ABAP in den ADT nicht mit den Werkzeugen für Web Dynpro Java, die im SAP NetWeaver Developer Studio verfügbar sind. Bei den Web-Dynpro-ABAP-Werkzeugen handelt es sich um ein neues Toolset, d. h., Sie benötigen kein Developer Studio.

Zur Einführung in die Web-Dynpro-Entwicklung in Eclipse entwerfen wir in diesem Kapitel eine Applikation, um unsere in Kapitel 2, »Funktionen der ABAP Development Tools«, eingeführte Aufgabenliste nach Projekten strukturiert auszugeben. Wir sehen uns außerdem an, wie Sie eine Anwendung auf Basis des Floorplan Managers anlegen können. Ziel dieses Kapitels ist es, Ihnen die Entwicklungsumgebung vorzustellen, Kenntnisse in Web Dynpro ABAP und des Floorplan Managers werden daher vorausgesetzt.

4.1

Controller-Programmierung

Um zu beginnen, müssen wir zunächst eine neue Web-Dynpro-ABAP-Komponente anlegen. Öffnen Sie dazu die ABAP Development Tools in Eclipse,

199

4

Web Dynpro ABAP in Eclipse

und wählen Sie Ihr aktuelles ABAP-Projekt. Sie benötigen kein neues ABAPProjekt, um in Web Dynpro zu entwickeln. Gehen Sie dann wie folgt vor: 1. Markieren Sie das Paket Z_ISSUE_LIST im Project Explorer. 2. Starten Sie den Anlage-Assistenten im Kontextmenü über New 폷 Other ABAP Repository Object oder mithilfe der Tastenkombination (Strg) + (N). 3. Wählen Sie aus der Liste der verfügbaren Assistenten ABAP 폷 Web Dynpro 폷 Component, und bestätigen Sie mit Next (siehe Abbildung 4.1).

Abbildung 4.1 Assistenten zum Anlegen einer Web-Dynpro-Komponente aufrufen

4. Geben Sie im folgenden Dialog New Web Dynpro Component »ZWD_C_ ISSUE_LIST« als Namen für die Komponente ein (siehe Abbildung 4.2). 5. Genau wie in der ABAP Workbench können Sie sich direkt einen initialen Window- und View-Controller anlegen lassen. Markieren Sie dazu die Option Create Window, und tragen Sie »W_ISSUE_LIST« als Namen für das Window ein. Markieren Sie auch die Option Create View. Als Namen für den View wählen Sie »V_MAIN«. Fahren Sie mit Next fort. 6. Wählen Sie den Transportauftrag, den Sie für unser Demoszenario angelegt haben, und bestätigen Sie die Anlage der Komponente mit Finish.

200

Controller-Programmierung

Abbildung 4.2 Web-Dynpro-Komponente anlegen

7. Der Assistent erstellt die neue Komponente und öffnet diese in einem SAP-GUI-Bildschirm. Aktivieren Sie hier Ihre Komponente und alle automatisch angelegten Controller mit der Tastenkombination (Strg) + (F3), und schließen Sie die Registerkarte. Das Ergebnis sehen Sie in Abbildung 4.3. Unterhalb des Namens der WebDynpro-Komponente werden die einzelnen Bestandteile aufgelistet – ähnlich wie in der ABAP Workbench.

Abbildung 4.3 Struktur der neuen Web-Dynpro-Komponente

201

4.1

4

Web Dynpro ABAP in Eclipse

Die Eclipse-Editoren zur Web-Dynpro-Bearbeitung sind in mehrere Registerkarten aufgeteilt – ähnlich den Registerkarten in der ABAP Workbench. Der Editor für Komponenten-Controller unterteilt sich in die Bereiche Overview, Context, Attributes, Methods, Events und Implementation. Die Register zur Navigation, die in Abbildung 4.4 dargestellt sind, befinden sich unterhalb des Editor-Fensters. Zusätzliche Informationen und Einstellungen zu den Elementen eines Controllers sind im View Properties zu finden.

Abbildung 4.4 Registerkarten im Editor für Komponenten-Controller

4.1.1

Kontext-Editor

Als Nächstes müssen wir den Kontext unserer Applikation anlegen. Da wir unsere Aufgabenliste (Issue List) als Baum darstellen möchten, sollte sich diese Struktur im Kontext wiederfinden: 1. Öffnen Sie den Komponenten-Controller der Komponente ZWD_C_ISSUE_ LIST. Die Registerkarte Context ist standardmäßig zuerst geöffnet. 2. Klicken Sie mit der rechten Maustaste auf den Wurzelknoten Context, und wählen Sie Add Node im Kontextmenü (siehe Abbildung 4.5), um einen neuen Knoten anzulegen. Alternativ können Sie das Tastenkürzel (Alt) + (O) verwenden.

Abbildung 4.5 Kontextknoten einfügen

3. Markieren Sie den neuen Knoten, und drücken Sie (F2), um ihn umzubenennen (Alternativ können Sie den Namen auch im Properties-View ändern.). Nennen Sie den neuen Knoten »PROJECTS«.

202

Controller-Programmierung

4. Öffnen Sie den Properties-View mit einem Doppelklick auf den Kontextknoten. Ändern Sie die Cardinality (Kardinalität) des Knotens PROJECTS auf 0..n.

Abbildung 4.6 Eigenschaften des Knotens PROJECTS

5. Klicken Sie mit der rechten Maustaste auf den Knoten PROJECTS, und fügen Sie über die Funktion Add Attribute im Kontextmenü (oder per (Alt) + (T)) ein neues Attribut ein. 6. Drücken Sie die Funktionstaste (F2), und benennen Sie das neue Attribut in »PROJECT_ID« um. 7. Ändern Sie den Typ des Attributs im Properties-View in »Z_PROJECT_ ID«. Sie können in diesem Feld übrigens auch die Code-Vervollständigung verwenden oder über den Button mit den Pünktchen ( ) in eine Suchmaske springen. 8. Legen Sie auf die gleiche Art und Weise ein weiteres Element PROJECT_ NAME vom Typ Z_PROJECT_NAME an. 9. Markieren Sie den PROJECTS-Knoten, und fügen Sie mit der Tastenkombination (Alt) + (O) einen neuen Unterknoten ein. Nennen Sie ihn ISSUES, und vergeben Sie die Kardinalität 0..n. 10. Markieren Sie die Eigenschaft Supply Function im Properties-View, und klicken Sie auf den Button Create (siehe Abbildung 4.7), um eine neue Methode anzulegen. 11. Nennen Sie die Methode »SUPPLY_ISSUES«, und vergeben Sie eine Beschreibung. Fügen Sie die drei Attribute, die Sie in Abbildung 4.8 sehen, zu Ihrem neuen ISSUES-Knoten hinzu.

203

4.1

4

Web Dynpro ABAP in Eclipse

Abbildung 4.7 Eigenschaften des Knotens ISSUES

Abbildung 4.8 Fertige Struktur des Kontextes PROJECTS

Damit haben Sie den Kontext für die Navigation in der Aufgabenliste angelegt. Jetzt benötigen wir noch einen Speicher für die Detailanzeige. Die Kontextstruktur dazu soll jedoch nicht manuell, sondern mit Bezug auf ein ABAP-Dictionary-Objekt angelegt werden. Wir beschränken uns in diesem Beispiel auf die Anzeige von Projekten. Sie können die Lösung aber nach dem gleichen Prinzip um die Anzeige von Issues erweitern. 1. Fügen Sie dem Kontext mit der Tastenkombination (Alt) + (O) einen neuen Knoten hinzu, den Sie über die Funktionstaste (F2) in PROJECT umbenennen. 2. Im Properties-View geben Sie »ZPROJECT« als Dictionary Structure an. Auch dabei können Sie wieder mit der Code-Vervollständigung ((Strg) + Leertaste) arbeiten. Klicken Sie in derselbe Zeile auf den Button Derive (siehe Abbildung 4.9). 3. Ihnen wird ein Dialogfenster mit den Elementen der Struktur angezeigt. Belassen Sie es bei der Auswahl, und bestätigen Sie den Dialog mit Finish.

204

Controller-Programmierung

Abbildung 4.9 Kontext mit Bezug auf Dictionary-Objekt anlegen

4. Fügen Sie unterhalb des Knotens PROJECT noch einen Knoten PROJECT_ ISSUES hinzu. Vergeben Sie die Kardinalität 0..n, und binden Sie ihn an die Dictionary-Struktur ZISSUE. Übernehmen Sie mit dem Button Derive alle Elemente aus der Struktur wieder in den Kontextknoten. Der neue Kontext-Editor ähnelt zwar sehr dem aus der ABAP Workbench, allerdings wurden viele Kleinigkeiten geändert, die Ihre Arbeit sehr erleichtern können. So sind die wichtigsten Funktionen über Tastenkürzel zu erreichen und stehen zudem im Kontextmenü sowie über Funktionstasten zur Verfügung. Die wichtigsten Informationen zu Ihren Kontextknoten finden Sie nun direkt im Kontextbaum. Neben dem Namen werden auch die Kardinalität sowie der Knoten- bzw. Attributstyp angezeigt. Die Einstellungen können Sie, wie bereits gesehen, im Properties-View ändern. Die Anzeige können Sie durch ein Suchfeld oberhalb der Baumdarstellung filtern. Sie können auch einen Verwendungsnachweis für Kontextelemente anfordern ((ª) + (Strg) + (G)). Bei allen Controllern haben Sie außerdem die Möglichkeit, Methoden, Attribute und Kontextelemente zu verlinken, wozu Ihnen ADT-Links oder HTTP-Links zur Verfügung sehen.

205

4.1

4

Web Dynpro ABAP in Eclipse

Design der Beispielkomponente Das Design unserer Beispielkomponente wurde bewusst einfach ausgelegt und sieht nur eine Komponente vor. Bei einer produktiven Anwendung könnte man die Detailsicht in eine oder mehrere Komponenten verlagern und den Kontext anders aufbauen.

4.1.2

Attribute

Als Nächstes wollen wir ein Attribut anlegen, um eine Instanz unserer Klasse ZCL_ISSUE abzulegen. Diese Instanz dient uns später zur Bearbeitung der angezeigten Aufgabe. Attribute pflegen Sie wie folgt: 1. Wechseln Sie im Editor des Komponenten-Controllers auf die Registerkarte Attributes. 2. Klicken Sie auf die Schaltfläche Add Attribute, oder drücken Sie (Alt) + (T). 3. Geben Sie »MR_PROJECT« als Attributsnamen im folgenden Dialogfenster ein. Wählen Sie zudem eine passende Beschreibung, und bestätigen Sie mit Finish. 4. Geben Sie im Feld Type bei den Attribute Details »ZCL_PROJECT« ein. Markieren Sie zudem das Ankreuzfeld Ref To, um zu kennzeichnen, dass es sich um eine Referenzvariable handelt. Sie können im Feld Type auch mit der Tastenkombination (Strg) + Leertaste arbeiten oder über den Button Browse einen Suchdialog öffnen. Attribute werden in Eclipse in einer filterbaren Liste dargestellt, in der Sie genau wie bei Kontextknoten schon die Typisierung des Attributs erkennen. Die Eigenschaften zu einem Attribut finden Sie rechts neben der Listendarstellung (nicht im Properties-View). Ist der Text Type:* blau hinterlegt (siehe Abbildung 4.10), wird damit eine Verlinkung angedeutet, über die Sie sich die Definition des angegebenen Typs anzeigen lassen können. Diese Navigationsform finden Sie in einigen Web-Dynpro-Editoren in Eclipse wieder. Leider ist es derzeit nicht möglich, Attribute umzubenennen. Sie können sie lediglich kopieren ((Strg) + (C)) und unter einem neuen Namen wieder einfügen ((Strg) + (V)).

4.1.3

Methoden

Nun wollen wir unserer Komponente ein wenig Intelligenz einhauchen und dazu Methoden anlegen. Die Controller-Programmierung unterscheidet sich

206

Controller-Programmierung

in diesem Punkt von der ABAP-Objects-Entwicklung, da die Definition von Methoden nicht im Quelltext, sondern in einer eigenen Maske erfolgt. Die Implementierung läuft aber sehr ähnlich ab. 1. Wechseln Sie auf die Registerkarte Methods im Komponenten-Controller. 2. Klicken Sie auf den Button Add Method. Alternativ können Sie auch mit den Tasten (Alt) + (O) eine neue Methode anlegen. 3. Geben Sie im Dialogfenster New Method »FILL_PROJECTS_NODE« als Namen sowie eine beliebige Beschreibung ein. 4. Damit haben Sie schon Ihre zweite Web-Dynpro-Methode in Eclipse erstellt. Die erste Methode war die Supply-Methode, die Sie beim Erstellen des Kontextes angelegt haben. Diese finden Sie auch in der Liste der Methoden. Ein Icon symbolisiert, dass es sich hierbei um eine SupplyMethode handelt.. Als Nächstes benötigen wir eine Methode, mit der ein Projekt zur Anzeige im Detailbild ausgewählt wird. 1. Legen Sie eine weitere Methode mit dem Namen »SELECT_PROJECT« an. 2. Klicken Sie auf den Button Add Parameter (alternativ (Alt) + (T)). Ein neuer Parameter wird zu Ihrer Methode hinzugefügt und als Element unterhalb des Methodennamens dargestellt. Auf der rechten Seite können Sie die Eigenschaften des Parameters ändern. 3. Geben Sie »IF_PROJECT_ID« als Namen dieses Parameters ein. Als Type tragen Sie »Z_PROJECT_ID« ein (siehe Abbildung 4.10). Nachdem Sie die Methoden angelegt haben, sollte die Übersicht in Ihrem Editor etwa wie in Abbildung 4.11 aussehen.

Abbildung 4.10 Eigenschaften eines Methodenparameters

207

4.1

4

Web Dynpro ABAP in Eclipse

Abbildung 4.11 Übersicht und Details im Methoden-Editor

Auf ähnliche Art und Weise können Sie einer Methode über die Tastenkombination (Alt) + (X) eine Ausnahme hinzufügen. Wie Sie in Abbildung 4.11 sehen können, können Sie in dieser Sicht auch eine neue Supply-Methode (Add Supply Function) oder einen neuen Ereignisbehandler (Add Event Handler) anlegen. Als Nächstes implementieren wir unsere Methoden. Markieren Sie dazu die Methode FILL_PROJECTS_NODE in der Übersichtsliste. Anschließend klicken Sie auf der rechten Seite auf den Bezeichner Name*. Der Link bringt Sie direkt in den Quelltext-Editor Ihres Controllers zur Implementierung der Methode. Der Quelltext-Editor funktioniert sehr ähnlich wie der Editor anderer Entwicklungsobjekte in den ADT, mit dem Unterschied, dass Sie nicht uneingeschränkt ändern dürfen. Beim Code von Web-Dynpro-Controllern handelt es sich größtenteils um generierten Code, d. h., ein Grundgerüst wird Ihnen durch das Framework bereits vorgegeben und sollte nicht geändert werden. Sie haben lediglich die Möglichkeit, an geeigneten Stellen eignen Quelltext einzubringen. Daher sind große Teile des Web-Dynpro-Quelltextes grau hinterlegt und für Änderungen gesperrt. Methodenimplementierungen sind hingegen änderbar. Die Editor-Sicht für den Komponenten-Controller ZWD_ C_ISSUE_LIST sehen Sie in Abbildung 4.12. Zur Navigation innerhalb des Quelltextes steht Ihnen wieder der OutlineView zur Verfügung (siehe Abbildung 4.13 und Abschnitt 2.2.4, »Klassen«). Sie sehen hier den Inhalt des generierten Includes zum aktuellen Controller. Daher werden Ihnen auch die beiden Interfaces IG_COMPONENTCONTROLLER und IF_COMPONENTCONTROLLER angezeigt.

208

Controller-Programmierung

Abbildung 4.12 Der Quelltext-Editor zum Komponenten-Controller ZWD_C_ISSUE_LIST

Abbildung 4.13 View »Outline« zum Komponenten-Controller ZWD_C_ISSUE_LIST

Für die Entwicklung in Web Dynpro stehen Ihnen spezielle Code-Templates zur Verfügung. Daneben können Sie eigene Web-Dynpro-Templates erstellen. Im Anlage-Dialog finden Sie eine Auswahlbox, um ein Template für Web Dynpro zu kennzeichnen. Auch auf den Web Dynpro Code Wizard zur Erzeugung von Kontextzugriffen müssen Sie nicht verzichten. Dieses aus der ABAP Workbench bekannte Tool versteckt sich nun hinter der Code-Vervollständigung ((Strg) + Leertaste).

209

4.1

4

Web Dynpro ABAP in Eclipse

Implementieren wir nun zunächst die Methode FILL_PROJECTS_NODE unserer Web-Dynpro-Komponente: 1. Wechseln Sie zur Registerkarte Implementation und zur Methode FILL_ PROJECTS_NODE. (Entweder springen Sie von der Registerkarte Methods ab oder vom Outline-View.) 2. Fügen Sie nach der folgenden Code-Zeile eine Leerzeile ein: METHOD fill_projects_node. "EC NEEDED

3. Verwenden Sie die Tastenkombination (Strg) + Leertaste, um die CodeVervollständigung aufzurufen. 4. Die Code-Vervollständigung wird wie in Abbildung 4.14 angezeigt. Wählen Sie die Option contextWrite aus, um eine Set-Operation auf den Kontext auszuführen.

Abbildung 4.14 Kontext lesen und schreiben

5. Im nächsten Schritt können Sie, wie in Abbildung 4.15 gezeigt, einen Kontextknoten wählen. Ob Sie die statischen Attribute des Elements oder die ganze Tabelle auslesen möchten, steuern Sie über die Auswahlbox Code generated as table operations. Wählen Sie für unser Beispiel den Knoten PROJECTS aus, und bestätigen Sie mit OK. 6. Nun müssen wir selbst tätig werden und den generierten Code ein wenig anpassen. Die Methode ZCL_PROJECTS=>LIST_PROJECTS liefert eine Tabelle mit allen auf der Datenbank gespeicherten Projekten. Holen Sie sich die aktuelle Projektliste und speichern sie diese in eine Variable vom Typ Z_PROJECT_T. 7. Iterieren Sie mit einem LOOP über die Projektliste. Übertragen Sie die Einträge aus der Projektliste in die Kontextstruktur (Typ WD_THIS->ELEMENT_ PROJECTS), und füllen Sie die Tabelle für den Knoten PROJECTS mit diesen Einträgen. Ein entsprechendes Feld LT_PROJECTS wurde schon vom Wizard angelegt. Verschieben Sie abschließend die Methode zum Binden

210

Controller-Programmierung

der Tabelle an den Kontext ans Ende der Methode FILL_PROJECTS_NODE. Die Methode sollte daraufhin ähnlich wie in Listing 4.1 aussehen.

Abbildung 4.15 Auswahl eines Kontextknotens

Knoten mit Dictionary-Bezug Wenn Sie einen Kontextknoten mit Bezug zu einem ABAP-Dictionary-Objekt anlegen, können Sie wie gewohnt Strukturen bzw. Tabellen dieses Typs direkt an den Knoten binden. In unserem Beispiel ist das nicht möglich, da wir die Knoten manuell aufgebaut haben und die Struktur nicht mit der auf der Datenbank kompatibel ist. METHOD fill_projects_node. DATA: lo_nd_projects TYPE lt_projects TYPE ls_project TYPE lt_project_list TYPE

REF TO if_wd_context_node, wd_this->elements_projects, wd_this->element_projects, z_project_t.

lo_nd_projects = wd_context->get_child_node( name = wd_this->wdctx_projects ). lt_project_list = zcl_project=>list_projects( ). LOOP AT lt_project_list INTO DATA(ls_project_list). ls_project-project_id = ls_project_list-project_id. ls_project-project_name = ls_project_list-project_name. APPEND ls_project TO lt_projects.

211

4.1

4

Web Dynpro ABAP in Eclipse

ENDLOOP. lo_nd_projects->bind_table( new_items = lt_projects set_initial_elements = abap_true ). ENDMETHOD. Listing 4.1 Implementierung der Methode FILL_PROJECTS_NODE

Nun kümmern wir uns um die Implementierung der verbleibenden Methoden des Komponenten-Controllers: 1. Drücken Sie die Tasten (Strg) + (O), und wählen Sie aus dem Quick Overview die Methode SELECT_PROJECT, um zur Implementierung dieser Methode zu springen. 2. Sie müssen nicht zurück zur Registerkarte Methods springen, um sich die Methodensignatur ins Gedächtnis zu rufen. Setzen Sie den Cursor auf den Methodennamen, und drücken Sie (F2). Die ABAP Element Info zeigt Ihnen die Signatur der Methode an (siehe Abbildung 4.16).

Abbildung 4.16 ABAP Element Info zur Methode SELECT_PROJECT

3. Fügen Sie den Code aus Listing 4.2 als Implementierung der Methode ein. METHOD DATA DATA DATA DATA DATA

select_project. lo_nd_project TYPE REF TO if_wd_context_node. lo_el_project TYPE REF TO if_wd_context_element. ls_project TYPE wd_this->element_project. lo_nd_project_issues TYPE REF TO if_wd_context_node. lt_project_issues TYPE wd_this->elements_project_issues. wd_this->mr_project = NEW #( if_project_id ). lo_nd_project = wd_context->get_child_node( name = wd_this->wdctx_project ). lo_el_project = lo_nd_project->get_element( ). ls_project = wd_this->mr_project->get_project( ).

212

Controller-Programmierung

lo_el_project->set_static_attributes( static_attributes = ls_project ). * Issues setzen lo_nd_project_issues = lo_nd_project->get_child_node( name = wd_this->wdctx_project_issues ). lt_project_issues = wd_this->mr_project->get_issues( ). lo_nd_project_issues->bind_table( new_items = lt_project_issues set_initial_elements = abap_true ). ENDMETHOD. Listing 4.2 Implementierung der Methode SELECT_PROJECT

4. Navigieren Sie zur Methode SUPPLY_ISSUES, und fügen Sie den Code aus Listing 4.3 als Implementierung ein. METHOD supply_issues. DATA: ls_project TYPE lt_issues TYPE ls_issues TYPE lt_issue_list TYPE lr_project TYPE

zproject, wd_this->elements_issues, wd_this->element_issues, z_issue_t, REF TO zcl_project.

parent_element->get_static_attributes( IMPORTING static_attributes = ls_project ). IF ls_project-project_id IS NOT INITIAL. lr_project = NEW #( ls_project-project_id ). lt_issue_list = lr_project->get_issues( ). LOOP AT lt_issue_list INTO DATA(ls_issue_list). ls_issues-issue_id = ls_issue_list-issue_id. ls_issues-issue_name = ls_issue_list-name. ls_issues-issue_description = ls_issue_list-description. APPEND ls_issues TO lt_issues. ENDLOOP. ENDIF. node->bind_table( new_items = lt_issues set_initial_elements = abap_true ). ENDMETHOD. Listing 4.3 Implementierung der Methode SUPPLY_ISSUES

213

4.1

4

Web Dynpro ABAP in Eclipse

5. Zu guter Letzt müssen wir noch dafür sorgen, dass unsere Projektliste initial befüllt wird. Navigieren Sie daher zur Methode WDDOINIT, und fügen Sie den folgenden Aufruf ein: wd_this->fill_projects( ).

Sie können dazu die Code-Vervollständigung für die Variable WD_THIS verwenden. 6. Aktivieren Sie Ihre Änderungen. Damit sind unsere Arbeiten am Komponenten-Controller abgeschlossen.

4.2

Views und Windows

In diesem Abschnitt widmen wir uns den visuellen Bestandteilen unserer Web-Dynpro-Komponente. Zunächst erstellen wir die Views, die die Navigation und die Detailanzeige übernehmen sollen. Anschließend kombinieren wir diese Views in einem Window.

4.2.1

Views

Der View-Editor ist ähnlich aufgebaut wie der des Komponenten-Controllers. Die Registerkarten, die Sie aus der ABAP Workbench gewöhnt sind, wurden mehr oder weniger 1:1 nachempfunden und finden sich nun am unteren Rand des Editors. Wenn Sie im Project Explorer doppelt auf einen View klicken, landen Sie zunächst in der Kontextansicht. Diese ist genauso aufgebaut wie die Sicht, die Sie schon vom Komponenten-Controller kennen. Auf der linken Seite sehen Sie den (im Moment noch leeren) Kontext des Views. In unserem Fall sehen Sie auf der rechten Seite die Kontextknoten, die Sie im Komponenten-Controller angelegt haben. Ordnen Sie nun die benötigten Knoten aus dem Komponenten-Controller dem View zu (Mapping). 1. Wechseln Sie zum View V_MAIN auf der Registerkarte Context. 2. Expandieren Sie den Kontextbaum auf der rechten Seite, bis Sie zur Ebene des Knotens PROJECTS gelangen. 3. Markieren Sie den Knoten PROJECTS, und ziehen Sie ihn per Drag & Drop auf den (Wurzel-)Knoten CONTEXT auf der linken Seite.

214

Views und Windows

4. Der Dialog Context Mapping öffnet sich (siehe Abbildung 4.17). Hier können Sie, anders als im SAP GUI, noch einmal genau differenzieren, welche Elemente Sie mappen möchten.

Abbildung 4.17 Elemente für das Kontext-Mapping auswählen

5. Der Knoten mit den gewählten Elementen wird in den View-Controller kopiert, und das Mapping wird angelegt. Es wird Ihnen durch Verbindungslinien angezeigt (siehe Abbildung 4.18). 6. Aktivieren Sie Ihre Änderungen.

Abbildung 4.18 Anzeige des Kontext-Mappings

215

4.2

4

Web Dynpro ABAP in Eclipse

Als Nächstes bauen wir das Layout der Views auf. Der Layout-Editor lässt sich etwas anders bedienen als sein Verwandter im SAP GUI, das neue Bedienkonzept kann Ihnen die Arbeit aber erleichtern. Neben dem Layout-Editor arbeiten Sie mit den Views Outline und Properties: 왘 Layout-Editor Im grafischen Layout-Editor wird eine Vorschau angezeigt, die an die Layout-Vorschau der ABAP Workbench erinnert. Allerdings gibt es keine Palette mit UI-Elementen. Möchten Sie ein UI-Element im Layout-Editor einfügen, können Sie dies über das Kontextmenü tun (mit Insert 폷 Element). Ein Dialog stellt Ihnen die zum Einfügen verfügbaren UI-Elemente zur Auswahl. Mit dem Ankreuzfeld Highlight Containers oben rechts können Sie die Anzeige der Umrisse sämtlicher Container aktivieren, was beim Erstellen verschachtelter Layouts sehr hilfreich sein kann. Ist das Feld deaktiviert, wird Ihnen eine Vorschau angezeigt, die fast dem Endergebnis entspricht. 왘 Outline-View Die Hierarchie im View Outline entspricht der Hierarchiedarstellung in der ABAP Workbench. Bei einem leeren Layout sehen Sie die Standardcontainer CONTEXT_MENUES und ROOTELEMENTCONTAINER. Neue Elemente fügen Sie über das Kontextmenü hinzu (Insert 폷 Element). Das Layout lässt sich viel intuitiver bearbeiten als in der ABAP Workbench. Neben der Möglichkeit, Elemente nach oben und unten zu verschieben, wurden auch das Kopieren, Ausschneiden und Einfügen von Elementen über das Menü oder Shortcuts ermöglicht. Außerdem können Sie mehrere Elemente markieren und gleichzeitig bearbeiten. 왘 Properties-View Im View Properties werden die Eigenschaften der UI-Elemente angezeigt. Sie sind in Kategorien unterteilt, die auf jeweils eigenen Registerkarten untergebracht sind: 왘 UI Element: allgemeine Eigenschaften 왘 Layout: Auf der Registerkarte Layout stellen Sie den Layout-Manager ein und nehmen allgemeine Einstellungen zum Layout vor. 왘 Layout Data: Auf der Registerkarte Layout Data stellen Sie die elementspezifischen Eigenschaften zum Layout-Manager des übergeordneten Containers ein. 왘 Events: Auf der Registerkarte Events können Sie dem aktuell gewählten UI-Element Aktionen zuweisen.

216

Views und Windows

Die auf der Registerkarte UI Element angezeigte Eigenschaft ist immer die Element-ID. Darauf folgen sämtliche Pflichtfelder des UI-Elements. Alle anderen Eigenschaften werden in alphabetischer Reihenfolge angezeigt (siehe Abbildung 4.19). Der View Properties bietet zudem die bekannten Filter- und Suchfunktionen über ein einzelnes Eingabefeld.

Abbildung 4.19 View »Properties« zu einem UI-Element

Ist im Outline-View bzw. im Layout-Editor mehr als ein Element markiert, zeigt der Properties-View alle Eigenschaften an, die die selektierten Elemente gemeinsam haben. Bei gleichen Werten werden diese ebenfalls angezeigt, bei unterschiedlichen Werten bleibt das Feld Value leer. Sie können aber in beiden Fällen die Eigenschaftswerte aller markierten Elemente gleichzeitig bearbeiten. Um Ihnen zu zeigen, wie Sie mit den Werkzeugen arbeiten, fügen wir als Erstes neue UI-Elemente ein. 1. Klicken Sie im Outline-View mit der rechten Maustaste auf das Element ROOTELEMENTCONTAINER, und wählen Sie im Kontextmenü Insert 폷 Element. 2. Es öffnet sich der Dialog New UI Element (siehe Abbildung 4.20). Wählen Sie aus der Liste das UI-Element TransparentContainer. 3. Nennen Sie das Element »TCN_NAVIGATION«, und bestätigen Sie mit OK.

217

4.2

4

Web Dynpro ABAP in Eclipse

4. Wiederholen Sie den Vorgang, um einen weiteren Transparent Container einzufügen. Nennen Sie diesen »TCN_DETAIL«. 5. Die neu eingefügten Transparent Container tauchen nun im Outline-View auf und können verwendet werden. Der Dialog New UI Element in Abbildung 4.20 unterscheidet sich etwas vom Fenster UI-Element einfügen der ABAP Workbench. Sie haben zunächst die vollständige Liste aller verfügbaren UI-Elemente zur Auswahl und können die Liste über das Eingabefeld oberhalb der Liste auf einen Suchbegriff einschränken. Über die Auswahlliste Categories können Sie die Liste der UI-Elemente außerdem auf eine bestimmte Kategorie einschränken. Die Kategorien entsprechen denen, die Sie vielleicht schon aus der Palette des Layout-Editors in der ABAP Workbench kennen.

Abbildung 4.20 Dialog zur Anlage eines neuen UI-Elements

218

Views und Windows

Einige UI-Elemente, wie das Input Field, werden übrigens direkt zusammen mit ihrem Label (Bezeichner) eingefügt. Wenn Sie lieber mit dem LayoutEditor arbeiten, ist das Vorgehen beim Einfügen neuer UI-Elemente analog. Als Nächstes können wir die Eigenschaften unserer UI-Elemente, der Transparent Container, bearbeiten: 1. Klicken Sie im Outline-View doppelt auf das Element ROOTELEMENTCONTAINER , um den Properties-View zu öffnen (Alternativ markieren Sie das Element und wählen (ª) + (Strg) + (Z) – diese Tastenkombination funktioniert auch im Layout-Editor.). 2. Wechseln Sie auf die Registerkarte Layout, und wählen Sie für die Eigenschaft Layout den Eintrag MatrixLayout. 3. Markieren Sie nun die angelegten Transparent Container TCN_NAVIGATION und TCN_DETAIL. Die Eigenschaften Ihrer Auswahl werden sofort im Properties-View angezeigt. 4. Stellen Sie nun gleichzeitig für diese beiden Container das Layout auf Matrix Layout um. Die restlichen Einstellungen können Sie beibehalten. Mit den beiden Transparent Containern allein können wir noch nicht viel anfangen, wir müssen auch eine Navigationsmöglichkeit anlegen. Dazu verwenden wir einen Navigationsbaum. Aufgrund des Aufbaus unseres Kontextes müssen wir dazu keinen großen Aufwand betreiben: 1. Fügen sie im Container TCN_NAVIGATION ein neues UI-Element vom Typ Tree an, und nennen Sie es »TRE_NAVIGATION«. 2. Im Properties-View wechseln Sie in den Bereich UI Element und markieren die Eigenschaft DataSource. Es erscheint ein Button mit der Aufschrift Bind, auf den Sie klicken. Wählen Sie im so aufgerufenen Menü den Eintrag To Context.

Abbildung 4.21 Kontext an das UI-Element anbinden

3. Daraufhin erscheint der Dialog Bind to Context. Wählen Sie hier den Kontextknoten PROJECTS, für den nun ein kleines Ordnersymbol als Wert

219

4.2

4

Web Dynpro ABAP in Eclipse

der Eigenschaft angezeigt wird. Zudem erscheint der Button Reset, der es Ihnen ermöglicht, die Bindung wieder zu lösen. 4. Als Letztes wollen wir dem Wurzelknoten des Baums noch einen nachvollziehbaren Namen geben. Wählen Sie dazu die Eigenschaft RootText, klicken Sie auf den Button Bind, und wählen Sie To OTR im erscheinenden Menü. 5. Im folgenden Dialog Search online text repository object geben Sie als Paket das Standardpaket »SOTR_VOCABULARY_BASIC« an (siehe Abbildung 4.22). Sie können in diesem Feld auch die Code-Vervollständigung verwenden. 6. Wählen Sie aus der Liste der OTR-Texte den Eintrag Navigation aus, und bestätigen Sie mit OK. Der ausgewählte Text wurde damit an die Eigenschaft gebunden.

Abbildung 4.22 Dialog zur Anbindung eines Textes aus dem Online Text Repository

OTR-Texte Sie müssen OTR-Texte in den Eigenschaften nicht über den Dialog anbinden, sondern können auch »$OTR:/« über die Tastatur eingeben. Eigene OTR-Texte können Sie über Transaktion SOTR_EDIT im SAP GUI pflegen. Eine direkte Eclipse-Integration ist derzeit noch nicht verfügbar.

220

Views und Windows

Sie haben nun gesehen, wie Sie einzelne Werte an den Kontext binden können. Wenn Sie schon größere Anwendungen in Web Dynpro geschrieben haben, wissen Sie, wie zeitaufwendig es sein kann, viele UI-Elemente an den Kontext zu binden. Die Web-Dynpro-Tools in Eclipse bieten zu diesem Zweck einen neuen Kontext-Editor an, den wir uns im nächsten Beispiel ansehen werden. Dazu legen wir zu unserem Baum die Knoten für Projekte und Aufgaben an und binden diese in einem Rutsch an den Kontext: 1. Klicken Sie im Outline-View mit der rechten Maustaste auf das UI-Element TRE_NAVIGATION, und wählen Sie Insert 폷 Node Type im Kontextmenü. 2. Wählen Sie aus der Liste der verfügbaren Elemente TreeNodeType, nennen Sie das anzulegende Element »TNT_PROJECT«, und bestätigen Sie mit OK. 3. Fügen Sie auf die gleiche Weise ein TreeItemType mit dem Namen »TIT_ ISSUE« ein. 4. Klicken Sie nun mit der rechten Maustaste auf TRE_NAVIGATION, und wählen Sie Bind To Context im Kontextmenü ((ª) + (Strg) + (P)). 5. Wählen Sie die Eigenschaft DataSource unterhalb des Elements TNT_PROJECT, und ziehen Sie diese per Drag & Drop auf den Knoten PROJECTS auf der rechten Seite. Sie haben nun die Eigenschaft an den Kontext gebunden, was Ihnen durch eine Verbindungslinie angezeigt wird. 6. Alle Eigenschaften, die gebunden werden sollen, finden Sie in Tabelle 4.1. Schließlich sollte Ihr Binding wie in Abbildung 4.23 aussehen. Schließen Sie die Bearbeitung mit Finish ab. Layout

Kontext

Element

Eigenschaft

Knoten

Attribut

TRE_NAVIGATION

DataSource

PROJECTS

–

TNT_PROJECT

DataSource

PROJECTS

–

TNT_PROJECT

Text

PROJECTS

Project_Name

TIT_ISSUE

DataSource

ISSUES

–

TIT_ISSUE

Text

ISSUES

Issue_Name

TIT_ISSUE

Tooltip

ISSUES

Issue_Description

Tabelle 4.1 Kontext-Binding für das UI-Element TRE_NAVIGATION

Auf diese Weise können Sie beliebige UI-Elemente mit dem Kontext verknüpfen. Dabei werden Ihnen im Editor alle UI-Elemente angezeigt, die dem Element zugeordnet sind, das Sie ausgewählt haben, z. B. ein transparenter

221

4.2

4

Web Dynpro ABAP in Eclipse

Container und alle Elemente, die sich in diesem Container befinden. Sie haben auch die Möglichkeit, die Ansicht im Dialog Bind to Context nur auf die obligatorischen Eigenschaften einzuschränken. Klicken Sie dazu auf den Button Show only mandatory UI element properties ( ) oberhalb des Layout-Baums.

Abbildung 4.23 Dialog für das Kontext-Binding

Im nächsten Schritt bestimmen wir, wie die Detailanzeige aussehen soll, um ein ausgewähltes Projekt anzuzeigen. Diese soll rechts neben dem Navigationsbaum zu finden sein. Sie besteht aus einem einfachen Formular sowie einer Tabelle mit sämtlichen Issues zu einem Projekt. Es gibt in den Web-Dynpro-Tools in Eclipse keine Möglichkeit, ein Formular aus dem Kontext zu generieren. Allerdings ist diese Methode auch in der

222

Views und Windows

ABAP Workbench mit einigen Nacharbeiten verbunden, sodass die Zeitersparnis durch die Generierung dort nur minimal ist. Durch den neuen Binding-Editor und die Möglichkeit, Elemente zu kopieren, legen Sie Formulare daher in Eclipse mit etwas Übung eher schneller an. Gehen wir die Anlage an unserem Beispiel gemeinsam durch: 1. Fügen Sie unterhalb des UI-Elements TCN_DETAIL ein UI-Element Caption mit dem Namen »CPT_TITLE« ein. 2. Fügen Sie unterhalb des Elements TCN_DETAIL ein InputField ein, und nennen Sie es »INP_ID«. Eclipse fügt automatisch das passende Label dazu ein. 3. Markieren Sie das Label und das Input Field, und drücken Sie (Strg) + (C), um beides zu kopieren. 4. Markieren Sie wieder das Element TCN_DETAIL, und drücken Sie dreimal (Strg) + (V), um drei neue Label/InputField-Pärchen einzufügen. 5. Markieren Sie nun alle Label-Elemente, und wählen Sie im PropertiesView unter LayoutData 폷 LayoutData den Eintrag MatrixHeadData. Damit bewirken Sie, dass jedes Label in einer neuen Zeile angezeigt wird. 6. Als Nächstes benennen Sie die IDs der Elemente um. Markieren Sie dazu das Element, das Sie umbenennen möchten, und drücken Sie (F2). Sie können es dann direkt im Outline-View umbenennen. Einen Vorschlag für eine mögliche Benennung finden Sie in Abbildung 4.24.

Abbildung 4.24 Das Detailformular

7. Es fehlen noch die Label-Zuordnungen für die Eingabefelder LBL_NAME, LBL_START sowie LBL_END, da wir diese lediglich kopiert hatten. Markieren Sie zuerst LBL_NAME, navigieren Sie im Properties-View zu UIElement 폷 LabelFor, und wählen Sie das Label INP_NAME aus der Dropdown-Liste.

223

4.2

4

Web Dynpro ABAP in Eclipse

8. Gehen Sie bei den Eingabefeldern LBL_START und LBL_END auf die gleiche Weise vor. Vielleicht haben Sie beim Anlegen des Detailformulars gedacht, dass es schöner wäre, diese Sicht in einen eigenen View auszulagern. Aber alles löschen und neu anlegen? Das ist nicht notwendig. Sie können alle UI-Elemente so, wie sie sind, in einen neuen View verlegen: 1. Klicken Sie im Outline-View mit der rechten Maustaste auf den Transparent Container TCN_DETAIL, und wählen Sie Copy ((Strg) + (C)) aus dem Kontextmenü. 2. Klicken Sie im Project Explorer mit der rechten Maustaste auf die WebDynpro-Komponente ZWD_C_ISSUE_LIST, und wählen Sie New 폷 View im Kontextmenü. 3. Nennen Sie den neuen View »V_PROJECT_DETAILS«, und legen Sie diesen an. 4. Wechseln Sie auf die Registerkarte Layout, markieren Sie den Container ROOTELEMENTCONTAINER, und drücken Sie (Strg) + (V). Die kopierte UIStruktur wird eingefügt. 5. Wechseln Sie zur Registerkarte Layout des Views V_MAIN, und löschen Sie das Element TCN_DETAIL. Fügen Sie stattdessen ein VIEWCONTAINERUIELEMENT ein, und nennen Sie es »VCN_DETAILS«. Es wäre sogar noch besser, die Detailsicht für verschiedene Objekte in jeweils eigenen Komponenten zur Verfügung zu haben. Selbst dies können Sie über die Kopierfunktion erreichen. Sie können UI-Elemente, Methoden, Kontextknoten oder Attribute einfach zwischen Komponenten hin- und her kopieren. Schließlich binden wir unsere Detailsicht an den Kontext: 1. Wechseln Sie dazu zur Registerkarte Context des Views V_PROJECT_ DETAILS. 2. Ziehen Sie den Kontextknoten PROJECTS aus dem Komponenten-Controller in den Kontext des Views, um diesen zu mappen. 3. Wählen Sie alle Elemente aus (auch den Unterknoten PROJECT_ISSUES). 4. Wechseln Sie zur Registerkarte Layout, und markieren Sie das Element TCN_DETAIL. Drücken Sie (ª) + (Strg) + (P), um den Binding-Dialog zu öffnen. Stellen Sie ein Binding wie in Abbildung 4.25 her, und bestätigen Sie mit Finish.

224

Views und Windows

Abbildung 4.25 Kontext-Mapping für den View V_PROJECT_DETAILS

In unserer Dateiansicht benötigen wir noch eine Tabelle zur Anzeige der Aufgaben zu einem Projekt. Zur Anlage von Tabellen gibt es einen Assistenten, der Ihnen einiges an Arbeit abnehmen kann. Dieser funktioniert sowohl für das UI-Element Table als auch für das Element CTable. 1. Klicken Sie mit der rechten Maustaste auf den Knoten TCN_DETAILS, und wählen Sie Insert 폷 Element. Wählen Sie Table aus der Liste der UI-Elemente, und nennen Sie das neue Element »TBL_ISSUES«. Bestätigen Sie Ihre Angaben. 2. Beim Einfügen der Tabelle öffnet sich ein Assistent, der Ihnen den aktuellen Kontext zur Auswahl stellt. Markieren Sie hier den Knoten PROJECT_ ISSUES, und heben Sie die Markierung des Feldes MANDT auf. Bestätigen Sie mit Next. 3. Im nächsten Schritt können Sie Änderungen an den Spalteneigenschaften vornehmen. Wir begnügen uns aber mit den Voreinstellungen und bestätigen mit Finish. 4. Ändern Sie nun noch in den Eigenschaften Ihrer Tabelle den Wert für die Eigenschaft LayoutData auf MatrixHeadData und den Wert für die Eigenschaft ColSpan auf 2.

225

4.2

4

Web Dynpro ABAP in Eclipse

Sie haben nun eine Tabelle mit Issues eingebaut. Die Kontextbindung und die Eigenschaften der Spalten können Sie jederzeit über das Kontextmenü mit der Funktion Edit Table ändern. Zudem können Sie auf die Tabelle und deren Spalten im Outline-View zugreifen. Nun müssen wir noch dafür sorgen, dass dem Anwender die Details auch angezeigt werden. Dazu müssen wir ein Inbound- und ein Outbound-Plug in unseren beiden Views definieren. Diese Plugs sollen bei der Auswahl eines Projektes ausgelöst werden. Wechseln Sie dazu zur Registerkarte Plugs des Views V_MAIN, und klicken Sie auf Add Outbound Plug. Im folgenden Dialog geben Sie »OP_PROJECT_DETAILS« als Namen für das neue Plug ein. Sie haben hier auch die Möglichkeit, über die Funktion Add Parameter zusätzliche Übergabeparameter anzulegen. Dies ist in unserem Fall aber nicht notwendig. Legen Sie den Inbound-Plug für den Detail-View V_PROJECT_ DETAILS über die Funktion Add Inbound Plug an, und nennen Sie diesen Plug »IP_SHOW_PROJECT«. Damit die Plugs ausgelöst und die korrekten Projektdetails geladen werden, legen wir eine neue Aktion für den Projektknoten an. Nach dem gleichen Prinzip können Sie bei Bedarf auch Ereignisbehandler für andere UI-Elemente anlegen: 1. Wechseln Sie zur Registerkarte Layout des Views V_PROJECT_DETAILS. Klicken Sie im Outline-View doppelt auf das UI-Element TNT_PROJECTS, und wechseln Sie im Properties-View auf die Registerkarte Event. 2. Markieren Sie die Eigenschaft onAction, und klicken Sie auf den Button Create. 3. Im folgenden Dialog nennen Sie die neue Aktion »DISPLAY_PROJECT« und vergeben eine Beschreibung (siehe Abbildung 4.26). Der Dialog zeigt Ihnen direkt an, wie der Ereignisbehandler zu Ihrer Aktion heißen wird. Sie können außerdem den Aktionstyp wählen. Wir belassen es bei der Einstellung Standard und bestätigen die Anlage mit Finish. Über den Button Go gelangen Sie in die Implementierung der Ereignisbehandler-Methode. In dieser Methode sorgen Sie dafür, dass das gewählte Projekt geladen wird. Dazu rufen Sie die Methode SELECT_PROJECT im Komponenten-Controller auf und lösen anschließend das Plug OP_PROJECT_ DETAILS aus. Es gibt keinen Assistenten, der die Methodenaufrufe oder den Code zum Auslösen eines Plugs erzeugt. Stattdessen können Sie die CodeVervollständigung verwenden. Der Komponenten-Controller steht in jedem View über das Attribut WD_COMP_CONTROLLER zur Verfügung. Über die Tasten-

226

Views und Windows

kombination (Strg) + Leertaste können alle verfügbaren Methoden aufgelistet und inklusive ihrer Signatur über die Tastenkombination (ª) + (¢) eingefügt werden. Zum Auslösen eines Plugs steht zudem das Template firePlug zur Verfügung. Es fügt eine Code-Vorlage ein, die Sie nur noch um den Namen des Plugs ergänzen müssen. Diesen finden Sie ebenfalls mithilfe der Code-Vervollständigung.

Abbildung 4.26 Dialog »New Action«

Bauen wir nun den Ereignisbehandler zusammen: 1. Mithilfe des Codes aus Listing 4.4 ermitteln Sie zunächst die ID des gewählten Projekts. DATA: lr_project TYPE REF TO if_wd_context_element, lf_project_id TYPE z_projekt_id. lr_project = wdevent->get_context_element( name = 'CONTEXT_ELEMENT' ). lr_project->get_attribute( EXPORTING name = `PROJECT_ID`

227

4.2

4

Web Dynpro ABAP in Eclipse

IMPORTING value = lf_project_id ). Listing 4.4 Projekt-ID ermitteln

2. Als Nächstes rufen Sie die Selektionsmethode im Komponenten-Controller auf. Tippen Sie dazu »wd_comp_controller->« ein, gefolgt der Tastenkombination (Strg) + Leertaste. Wählen Sie aus der Liste die Methode SELECT_PROJECT, und fügen Sie den Code mit (ª) + (¢) ein. 3. Vervollständigen Sie den Aufruf mit der Projekt-ID, sodass Sie die folgende Zeile erhalten: wd_comp_controller->select_project( if_project_id = lf_project_ id ).

4. Fügen Sie das Template firePlug ein, und geben Sie »OP_PROJECTS_ DETAILS« als Namen für das Plug ein. Am Ende sollte Ihr Quelltext wie in Listing 4.5 aussehen. METHOD onactiondisplay_project. DATA: lr_project TYPE REF TO if_wd_context_element, lf_project_id TYPE z_projekt_id. lr_project = wdevent->get_context_element( name = 'CONTEXT_ELEMENT' ). lr_project->get_attribute( EXPORTING name = `PROJECT_ID` IMPORTING value = lf_project_id ). wd_comp_controller->select_project( if_project_id = lf_project_id ). WD_THIS->fire_op_projects_details_plg( ). ENDMETHOD. Listing 4.5 Implementierung der Methode ONACTIONDISPLAY_PROJECT

Wenn Sie diese Arbeitsabläufe erst einmal verinnerlicht haben, geht das Einfügen von Code schnell von der Hand. Der Vorteil im Vergleich zum CodeWizard liegt vor allem darin, dass Sie nicht aus dem Fluss gerissen werden. Es ist nicht notwendig, die Maus in die Hand zu nehmen und eine Funktion in der Toolbar aufzurufen. Die Hilfen stehen Ihnen direkt während der Arbeit im Quelltext zur Verfügung.

228

Web-Dynpro-Applikationen

4.2.2

Windows

Damit unser neuer View angezeigt werden kann, muss er im Window-Controller unserer Web-Dynpro-Komponente eingebunden werden. Der Editor für den Window-Controller ist einer der wenigen Editoren, die noch nicht in Eclipse umgesetzt wurden. Daher ist an dieser Stelle auch wenig Neues zu erklären: 1. Klicken Sie im Project Explorer doppelt auf das Window W_ISSUE_LIST. Ein in Eclipse integriertes SAP-GUI-Fenster mit dem gewählten Window öffnet sich. 2. Wechseln Sie mit (Strg) + (F1) in den Editiermodus, und expandieren Sie die Window Structure vollständig. 3. Klicken Sie mit der rechten Maustaste auf den View VCN_DETAILS, und wählen Sie Embed View, um den View einzubinden. Wählen Sie über die Wertehilfe des Feldes View to Be Embedded den Eintrag V_PROJECT_ DETAILS. 4. Klappen Sie auch die Views VCN_DETAILS und V_PROJECT_DETAILS auf. 5. Ziehen Sie den Outbound-Plug OP_PROJECT_DETAILS auf den Inbound-Plug IP_SHOW_PROJECT, und aktivieren Sie Ihre Änderungen ((Strg) + (F3)). Damit haben wir die Views in das Window eingebettet. Das Ergebnis sollte wie in Abbildung 4.27 aussehen.

Abbildung 4.27 Struktur des Windows W_ISSUE_LIST

4.3

Web-Dynpro-Applikationen

Web-Dynpro-Komponenten lassen sich selbst nicht ausführen, es wird zwangsläufig eine Applikation benötigt, die dem Endanwender den Zugriff

229

4.3

4

Web Dynpro ABAP in Eclipse

auf das System erlaubt. Im Folgenden lesen Sie, was Sie tun müssen, um unsere Komponente ausführen zu können. Eine Web-Dynpro-Anwendung ordnet der Komponente einen aktiven Interface-View (ein Window) zu, das zur Anzeige gebracht wird. Zudem wird ein ICF-Service (ICF = Internet Communication Framework) erstellt, über den die Applikation aufgerufen wird. Das Erstellen einer Applikation ist einfach. Der Aufwand beschränkt sich mehr oder weniger darauf, sich einen Namen und eine Beschreibung einfallen zu lassen: 1. Klicken Sie im Project Explorer mit der rechten Maustaste auf die Komponente ZWD_C_ISSUE_LIST, und wählen Sie New 폷 Application. 2. Im folgenden Dialog geben Sie z. B. »ZWD_A_ISSUE_LIST« als Namen für die Applikation und »Issue List« als Beschreibung ein (siehe Abbildung 4.28). Fahren Sie mit einem Klick auf Next fort.

Abbildung 4.28 Neue Web-Dynpro-Applikation erstellen

3. Wählen Sie Ihren Transportauftrag für unsere Beispielanwendung aus, und legen Sie die Anwendung mit Finish an. 4. Das SAP GUI startet und zeigt Ihre neue Anwendung an. Speichern Sie diese, und schließen Sie die SAP-GUI-Registerkarte. Die neu angelegte Applikation taucht nun unterhalb der Komponente im Project Explorer auf. Sie können die Anwendung auch direkt über Eclipse

230

Floorplan Manager

ausführen. Öffnen Sie dazu das Kontextmenü zu Ihrer Applikation im Project Explorer, und wählen Sie Run As… 폷 Web Dynpro ABAP Application. Der in Eclipse integrierte Browser startet und zeigt Ihre Anwendung an. Unter Umständen werden Sie vorab noch nach Benutzernamen und Passwort gefragt.

4.4

Floorplan Manager

Der Floorplan Manager ist ein Framework zur Erstellung konfigurierbarer Web-Dynpro-Anwendungen. Über den Floorplan Manager können Sie verschiedene Bausteine in Form sogenannter Building Blocks zu einer Anwendung zusammensetzen. Der Floorplan Manager basiert zu einem Großteil auf Web-Dynpro-Konfigurationen. In der Vergangenheit war es mitunter mühselig, eine neue Anwendung zu erstellen, da diese und eine Reihe von Konfigurationen zunächst angelegt werden mussten. Seit der Einführung des Application Creation Tools (ACT) kann diese Aufgabe automatisiert durchgeführt werden. Das ACT ist auch in Eclipse verfügbar. Eine Floorplan-Manager-Anwendung legen Sie in Eclipse wie folgt an: 1. Markieren Sie im Project Explorer das Paket Z_ISSUE_LIST, und drücken Sie (Strg) + (N), um ein neues Objekt zu erstellen. Wählen Sie Floorplan Manager Application aus der Liste, und fahren Sie mit Next fort. 2. Aus der Liste der Assistenten wählen Sie Wizard for Creating Empty FPM Applications und bestätigen die Auswahl mit Finish (siehe Abbildung 4.29).

Abbildung 4.29 Neue Floorplan-Manager-Anwendung anlegen

231

4.4

4

Web Dynpro ABAP in Eclipse

3. Im integrierten Browser öffnet sich das ACT (siehe Abbildung 4.30). Geben Sie als Namen der Web-Dynpro-Applikation »ZWD_FPM_ISSUE_ LIST« sowie eine passende Beschreibung ein.

Abbildung 4.30 Application Creation Tool

4. Wählen Sie als Floorplan-Typ, d. h. als Grundriss, der der Anwendung zugrunde liegen soll, unter Select Floorplan die Option Overview Page. 5. Das ACT schlägt automatisch Namen für die Konfigurationen vor. Sie können diese Namen einfach übernehmen und mit Next zum nächsten Schritt gehen. 6. Wählen Sie als Package Z_ISSUE_LIST, und tragen Sie Ihren Transportauftrag im Feld Request/Task ein. 7. Schließen Sie die Anlage mit Save ab. Ihnen werden nun zwei Links angezeigt, einer, um in den Floorplan-Konfigurationseditor (Flexible UI Designer, FLUID) abzuspringen, und einer, um die Anwendung auszuführen. Wenn Sie den Project Explorer aktualisieren, werden Ihnen zudem die neu angelegte Anwendung und die zugehörigen Konfigurationen angezeigt (siehe Abbildung 4.31).

232

Floorplan Manager

Abbildung 4.31 Floorplan-Manager-Objekte im Project Explorer

Die Floorplan-Manager-Tools sind alle webbasiert. Daher unterscheidet sich die Arbeit mit diesen Tools, ausgehend von Eclipse, nicht von der Arbeit, die von der SAP-GUI-Oberfläche ausgeht. Sie können unsere Aufgabenliste mithilfe dieser Tools nun als Floorplan-Manager-Anwendung zur Verfügung stellen. Die dazu notwendigen Konfigurationen sind nun angelegt und können in Eclipse aufgerufen werden.

233

4.4

Die Datenbank ist das Gedächtnis eines SAP-ERP-Systems. ABAPProgramme legen ständig Datensätze an und lesen sie wieder aus. Für einen Entwickler ist es unbedingt notwendig, Einblick in die Datenbank zu haben – sei es bei der Entwicklung neuer Anwendungen oder bei der Analyse bestehender Programme.

5

Datenbankzugriffe

Das reibungslose Funktionieren eines SAP-ERP-Systems hängt immer mit der Datenbank zusammen. Der Anwender der Transaktionen und Web-Dynpro-Applikationen ist meist sehr gut gegen die technischen Details abgeschirmt. Der erste Blick des erfahrenen ABAP-Entwicklers geht aber meistens zuerst auf die Datenbank, wenn es Probleme gibt. Eines der wichtigsten Werkzeuge des Entwicklers ist daher der Data Browser (Transaktion SE16) bzw. die allgemeine Tabellenanzeige (Transaktion SE16N). Seit Version 2.19 der ABAP Development Tools for SAP NetWeaver (ADT) gibt es eine Alternative zur Tabellenanzeige im SAP GUI. Die Data Preview ermöglicht die Anzeige von Tabelleninhalten innerhalb eines nativen Eclipse-Views. In diesem Kapitel sehen wir uns dieses praktische Tool genauer an. Zudem betrachten wir die neue SQL-Konsole, die mit den ADT 2.31 als Ergänzung zur Data Preview eingeführt wurde. Schließlich werfen wir noch einen Blick auf die Core Data Services, mit denen Sie Views in einer SQL-ähnlichen Sprache anlegen können.

5.1

Data Preview

Vielleicht haben Sie sich schon gefragt, ob Sie jedes Mal in das SAP GUI springen müssen, wenn Sie einen Blick in die Datenbank werfen wollen. Bis zur Version 2.19 der ADT war dies noch so. Mit dieser Version wurde die Data Preview eingeführt, mit der Sie sich schnell den Inhalt einer beliebigen Datenbanktabelle oder eines Views anzeigen lassen können. Dazu müssen Sie nur mit der rechten Maustaste auf den entsprechenden Eintrag im Project Explorer klicken und im Kontextmenü den Eintrag Open Data Preview wäh-

235

5

Datenbankzugriffe

len. Eclipse öffnet daraufhin im Editor-Bereich eine Tabellensicht mit den ersten 100 Einträgen der ausgewählten Tabelle (siehe Abbildung 5.1). Keine Angst, damit ist der Funktionsumfang der Data Preview noch lange nicht erschöpft. Im Folgenden schauen wir uns anhand unserer Beispieltabelle ZISSUE an, was dieses Tool zu bieten hat.

Abbildung 5.1 Data-Preview-Sicht

In der Data-Preview-Sicht steigen Sie direkt in die Anzeige der Daten ein, d. h., es gibt kein vorgeschaltetes Selektionsbild. Die Anzahl der angezeigten Zeilen können Sie im Feld Max rows von 100 Zeilen auf bis zu 5.000 erhöhen. Außerdem können Sie Ihre Selektion über Filter einschränken. Fügen Sie als Nächstes einen neuen Filter auf die Spalte LOEVM hinzu, um alle zum Löschen vorgemerkten Einträge auszublenden: 1. Klicken Sie mit der rechten Maustaste auf die Spaltenüberschrift der Spalte LOEVM, und wählen Sie Add a filter on [LOEVM] im Kontextmenü (siehe Abbildung 5.2). 2. Im sich öffnenden Dialog können Sie Ihre Filterkriterien pflegen. Dabei stehen Ihnen auch verschiedene Operatoren wie kleiner als oder ungleich zur Verfügung. Die vollständige Liste sehen Sie in Abbildung 5.3. Wählen Sie Not Equal to. 3. Geben Sie für unser Beispiel in das Filter-Eingabefeld »X« ein, und drücken Sie (¢).

236

Data Preview

Abbildung 5.2 Filter für eine Tabellenspalte setzen

Abbildung 5.3 Filter bearbeiten

Sofort nach der Eingabe wird die Ausgabe aktualisiert, und die gelöschten Einträge verschwinden. Über die Schaltfläche mit den Pünktchen ( ) haben Sie Zugriff auf die Wertehilfe. Vielleicht vermissen Sie die Möglichkeit, eine Werteliste anzugeben. Diese Möglichkeit steht Ihnen nur zur Verfügung, wenn Sie als Filteroperator In List bzw. Not in List wählen. Über den Button können Sie dann mehrere Werte hinzufügen. In vielen Fällen wird die Größe der Datenbanktabellen deutlich über 5.000 Zeilen liegen. Der einzelne Datensatz ist dann allerdings in der Regel weniger interessant (falls doch, müssen Sie sich mit einem Filter an diesen herantasten). Sehr interessant ist hingegen häufig die Anzahl der Einträge, die ein bestimmtes Kriterium erfüllen. In der linken oberen Ecke ist dauerhaft die Anzahl der angezeigten Zeilen eingeblendet (xx rows retrieved). Die Gesamtzahl der Datensätze auf der Datenbank erhalten Sie über den Button Number of Entries ( ).

237

5.1

5

Datenbankzugriffe

Um die Ausgabe zu sortieren, klicken Sie auf den Namen der Spalte, nach der Sie sortieren möchten. Die Sortierung bezieht sich nicht nur auf die angezeigten Zeilen, sondern auf die komplette Datenbanktabelle (bzw. auf alle Zeilen, die in den aktuellen Filter fallen). Über die Schaltfläche Select Columns haben Sie die Möglichkeit, die angezeigten Spalten zu begrenzen. Blenden Sie testweise die Verwaltungsfelder MANDT, ERNAM, ERDAT, AENAM sowie AEDAT aus. Per Maustaste können Sie außerdem einen sogenannten Quick Filter anlegen. Dabei übernehmen Sie den Wert der gewählten Spalte direkt in die Filterbedingungen. Klicken Sie dazu mit der rechten Maustaste auf einen Eintrag, und wählen Sie Quick Filter on [] im Kontextmenü (siehe Abbildung 5.4). Der neue Filter wird in die Liste der aktiven Filter übernommen und sofort angewandt.

Abbildung 5.4 Quick Filter anlegen

Die Verteilung einzelner Werte einer Spalte können Sie sich ebenfalls anzeigen lassen, wobei alle möglichen Werte nur einmal angezeigt werden. Die Anfrage entspricht der Abfrage SELECT DISTINCT aus OpenSQL. Wollen Sie sich ein Bild davon machen, welche Projekte in der Tabelle ZISSUE vorkommen, gehen Sie wie folgt vor: 1. Klicken Sie mit der rechten Maustaste irgendwo in die Spalte PROJECT_ID, und wählen Sie im Kontextmenü Distinct values for [PROJECT_ID]. 2. Die Anzeige vermittelt Ihnen einen Überblick über die vorkommenden Projekt-IDs in der Tabelle ZISSUE (siehe Abbildung 5.5), in diesem Beispiel sind es vier. Neben der ID wird Ihnen die absolute Häufigkeit dieses Eintrags angezeigt (Count). Zudem rechnet Ihnen Eclipse die relative Verteilung (Distribution) aus. Die Anzeige bezieht sich auf den kompletten Datenbestand, nicht nur auf die angezeigten Zeilen. Über die Eingabe eines Filtermusters (Eingabefeld Filter Pattern, siehe Abbildung 5.6) können Sie die angezeigten Zeilen schnell nach einem Wert durchsuchen. Die Eingabe bezieht sich auf alle Spalten der angezeigten Zeilen. Das Filter-Pattern blendet keine Daten aus, sondern Übereinstimmun-

238

SQL-Konsole

gen werden lediglich farblich hervorgehoben. Die üblichen Wildcard-Symbole (»*« und »?«) werden auch an dieser Stelle unterstützt.

Abbildung 5.5 Projekte in der Tabelle ZISSUE

Abbildung 5.6 Filter-Pattern

Die Ergebnisse Ihrer Anfrage können Sie sichern, indem Sie oben rechts auf das Speichern-Symbol ( ) klicken. Sie haben die Wahl, Ihre Ergebnisse als XML-, HTML- oder CSV-Datei zu sichern. Die ausgegebene Datei entspricht der aktuell angezeigten Tabelle.

5.2

SQL-Konsole

Die Data-Preview-Funktion lässt sich intuitiv bedienen und bietet alle Funktionen, die man auch aus der Tabellenanzeige im SAP GUI gewöhnt ist – wenn auch etwas anders präsentiert. Allerdings reißt sie gestandene ABAP-

239

5.2

5

Datenbankzugriffe

Entwickler wahrscheinlich nicht vom Hocker. Ein anderes Kaliber hat die SQL-Konsole. Mit ihr können Sie nicht nur den Inhalt einer Tabelle betrachten und über Eingabefelder filtern, sondern auch SQL-Abfragen formulieren und sich das Ergebnis sofort in Ihrer Ausgabetabelle ansehen. Dabei steht Ihnen das volle Repertoire der OpenSQL-Syntax zur Verfügung, inklusive Joins und Aggregationen. Die SQL-Konsole ist ab SAP NetWeaver 7.4 SP08 und den ADT 2.31 verfügbar. Neue OpenSQL-Syntax Mit SAP NetWeaver 7.4 (SP05) wurde die Syntax von OpenSQL leicht angepasst. Dies ist hauptsächlich dem Bestreben geschuldet, mehr Funktionen direkt von der Datenbank ausführen zu lassen (Code Pushdown). Die wichtigsten Änderungen sind: 왘 Die Liste der selektierten Spalten wird nun per Komma separiert. 왘 Hostvariablen – Felder aus dem ABAP-Coding – werden mit einem @-Zeichen gekennzeichnet. Sie müssen Ihre alten Programme jedoch nicht umbauen. Innerhalb des ABAPCodings ist Ihnen freigestellt, die alte Syntax weiterhin zu verwenden. Die SQLKonsole hingegen verlangt zwingend neue Syntax.

Sie rufen die SQL-Konsole über die Schaltfläche SQL Console im Data-Preview-Editor auf. Alternativ können Sie sie über das Kontextmenü zu Ihrem ABAP-Projekt öffnen. Wenn Sie die SQL-Konsole für unsere Beispieltabelle öffnen, achten Sie darauf, dass der Filter LOEVM auf die Spalte noch aktiv ist. In einem neuen Editor-Fenster öffnet sich daraufhin eine Tabelle zusammen mit einem Eingabebereich für SQL-Abfragen. Ihre Abfrage sollte wie in Listing 5.1 aussehen. SELECT ZISSUE~ISSUE_ID, ZISSUE~NAME, ZISSUE~DESCRIPTION, ZISSUE~STATE, ZISSUE~TYPE, ZISSUE~PROJECT_ID, ZISSUE~REPORTER, ZISSUE~ASSIGNED_TO, ZISSUE~LOEVM FROM ZISSUE WHERE LOEVM NE 'X' Listing 5.1 Generierte SQL-Abfrage mit gesetztem Filter

240

SQL-Konsole

Der generierte SQL-Quelltext entspricht den Filtereinstellungen, die Sie in der Data Preview angegeben haben. Es handelt sich dabei um vollwertigen OpenSQL-Code, den Sie bis auf die fehlende INTO-Klausel so in Ihren Programmen verwenden können. Sie können übrigens auch eine INTO-Klausel angeben. Die SQL-Konsole ersetzt die Klausel mit der Ausgabetabelle. Sie ist also ein praktisches Werkzeug, um ohne großen Aufwand Abfragen zu testen und zu evaluieren. Lassen Sie uns als Nächstes eine etwas komplexere Abfrage definieren. Es wäre z. B. interessant, zu den Issues auch den Namen des zugehörigen Projekts anzuzeigen: 1. Fügen Sie in der SQL-Konsole nach FROM ZISSUE den folgenden Code ein: INNER JOIN ZPROJECT ON ( ZPROJECT~PROJECT_ID = ZISSUE~PROJECT_ ID )

Verwenden Sie dabei die Code-Vervollständigung ((Strg) + Leertaste), z. B. nach der Eingabe von ZPROJECT~. 2. Fügen Sie in der Liste der Spalten nach ZISSUE~PROJECT_ID die Spalte ZPROJECT~NAME ein. 3. Ersetzen Sie die WHERE-Bedingung durch: WHERE zissue~loevm NE 'X' AND zproject~LOEVM NE 'X'

4. Prüfen Sie Ihre Anfrage mit einem Klick auf den Button Check ( (Strg) + (F2)) auf Korrektheit. 5. Führen Sie die Anfrage mit dem Button Run (

, oder

oder (F8)) aus.

Das Ergebnis wird sofort in der Ausgabetabelle angezeigt. Unterhalb der SQL-Eingabe finden Sie das Ausführungsprotokoll Ihrer Anfrage. Dort wird die genaue Ausführungszeit angezeigt. Zudem zeigt Ihnen das System, wie Ihre Anfrage umgebaut wurde, um ausgeführt zu werden. In unserem Fall wurden eine INTO- und eine UP TO-Klausel hinzugefügt (siehe Abbildung 5.7). Das Protokoll kann insbesondere bei der Analyse von SQL-Statements von großem Nutzen sein. Sie müssen sich so kein Hilfsprogramm mit Timern schreiben oder einen Performance-Trace starten. Nehmen Sie einfache Analysen einfach direkt in der SQL-Konsole vor. Über das Ausklappmenü bei der Schaltfläche Run können Sie Ihre letzten Anfragen auch noch mal ausführen lassen. Sie können Ihre Abfragen auch als Favorit kennzeichnen und haben sie damit dauerhaft im Zugriff.

241

5.2

5

Datenbankzugriffe

Abbildung 5.7 Ausgabe der SQL-Konsole

5.3

Core Data Services

Wenn Sie zuvor noch nicht mit den ADT oder SAP HANA gearbeitet haben, sind Ihnen die Core Data Services wahrscheinlich noch nicht über den Weg gelaufen. Mit den Core Data Services (CDS) haben Sie die Möglichkeit, datenbanknahe Modelle in einer domänenspezifischen Sprache zu definieren und mit Metadaten anzureichern. Im Augenblick wird nur die Definition von Datenbank-Views unterstützt. Die Sprache, die dabei zum Einsatz kommt, ist die Data Definition Language (DDL). Eines der Hauptziele, die mit CDS verfolgt werden, besteht darin, einen größeren Funktionsumfang direkt auf der Datenbank abzubilden (Code Pushdown). Die CDS wurden mit SAP NetWeaver 7.4 SP05 eingeführt. Sie können sie nicht im SAP GUI anlegen, sondern nur über Eclipse. Dazu benötigen Sie mindestens die ADT 2.19. Als Datenbank wird übrigens nicht zwingend HANA vorausgesetzt, Sie können CDS-Views auch verwenden, wenn Sie eine konventionelle relationale Datenbank einsetzen. Das Konzept der CDS verdeutliche ich anhand unseres Beispiels. Dazu legen wir einen CDS-View zu unserer Aufgabenliste an:

242

Core Data Services

1. Markieren Sie das Paket Z_ISSUE_LIST im Project Explorer, und drücken Sie (Strg) + (N), um ein neues Objekt anzulegen. Wählen Sie ABAP 폷 DDL Source aus der Liste. 2. Nennen Sie das neue Objekt »ZCDSV_ISSUE«, und vergeben Sie eine passende Beschreibung. Fahren Sie mit einem Klick auf Next fort. 3. Wählen Sie Ihren Transportauftrag für die Aufgabenliste aus, und klicken Sie auf Next. 4. Wählen Sie aus der Vorlagenliste das Template Define View with join, und bestätigen Sie mit Finish (siehe Abbildung 5.8).

Abbildung 5.8 CDS-View mit Template anlegen

5. Vervollständigen Sie das Template wie in Listing 5.2. Dazu können Sie mit der Tabulatortaste durch die Variablen des Templates springen und die Code-Vervollständigung verwenden. @AbapCatalog.sqlViewName: 'ZISSUE_V' @EndUserText.label: 'Issue List View' define view Zcdsv_Issue as select from ZISSUE left outer join ZPROJECT on ZISSUE.project_id = ZPROJECT.project_id { } Listing 5.2 CDS-View ZCDSV_ISSUE

243

5.3

5

Datenbankzugriffe

Template ab ABAP Development Tools 2.36 Die Auswahl eines Templates bei der Anlage eines CDS-Views ist erst mit den ADT 2.36 möglich. In früheren Releases wurde eine leere DDL Source angelegt. Es ist ein Assistent in Planung, der den Aufbau von Join-Bedingungen übernehmen kann. Dieser wird wahrscheinlich in einer der nächsten Versionen der ADT verfügbar werden. Falls Sie eine ältere Version verwenden, können Sie einfach mit dem Code aus Listing 5.2 weiterarbeiten.

Die Definition des Views wird in Listing 5.2 mit den Schlüsselwörtern define view eingeleitet. Darauf folgt der Name der View-Entity. Das ist nicht zwangsläufig auch der Name, mit dem wir unseren View ansprechen werden, dazu später mehr. Die Selektion der Daten wird durch das Schlüsselwort AS eingeleitet. Darauf folgt ein SELECT-Statement mit FROM-Klausel und in diesem Fall auch mit einem LEFT OUTER JOIN zwischen den Tabellen ZISSUE und ZPROJECT. Als Quelle für den CDS-View können Sie Datenbanktabellen, andere CDS-Views oder klassische ABAP-Dictionary-Views verwenden. Die Syntax zur Referenzierung von Spaltennamen ist bei CDS-Views etwas anders (».« anstelle von »~«). Zudem fehlt in Listing 5.2 noch die Angabe der selektierten Spalten. Dazu kommen wir ebenfalls erst später. Bei der Angabe der Join-Bedingungen können Sie aus dem Vollen schöpfen. Neben INNER JOIN können Sie auch LEFT OUTER JOIN oder RIGHT OUTER JOIN verwenden. Zudem unterstützen die CDS auch Vereinigungsmengen (UNION). Wenn Sie mit der Java-Welt vertraut sind, sind Ihnen Annotationen wahrscheinlich schon einmal über den Weg gelaufen, mit denen Sie Quelltexte mit Metadaten anreichern können. Ähnlich ist das auch in den CDS-Views möglich. Schauen Sie sich die ersten beiden Zeilen aus Listing 5.2 an. Mit der Annotation @AbapCatalog.sqlViewName geben Sie den veröffentlichten View-Namen an. Unter diesem Namen finden Sie den View später im ABAP Dictionary wieder. Mit @EndUserText.label vergeben Sie eine Beschreibung Ihres Views. Die Annotation @AbapCatalog.sqlViewName ist übrigens zwingend erforderlich, da Ihr View sonst nicht über das ABAP Dictionary erreichbar ist. Über Annotationen können Sie verschiedene Eigenschaften Ihres Views beeinflussen. Neben rein semantischen Annotationen können Sie z. B. auch das Pufferverhalten steuern (@AbapCatalog.Buffering.status/@AbapCatalog.Buffering.type) oder die Mandantenabhängigkeit des Views abschalten (@ClientDependent). Eine vollständige Liste der verfügbaren Annotatio-

244

Core Data Services

nen finden Sie in der SAP-Hilfe unter http://help.sap.com/abapdocu_740/en/ index.htm?file=abencds_annotations.htm. Unterschied zwischen Annotationen und Hostvariablen Verwechseln Sie das @-Zeichen zur Kennzeichnung von Annotationen nicht mit dem @-Zeichen zur Kennzeichnung von Hostvariablen in OpenSQL. Diese beiden Konzepte haben nichts miteinander zu tun. DDL ist zwar stark an OpenSQL angelehnt, ist aber eine eigene Sprache.

Wir haben nun ein Grundgerüst für den View in DDL definiert. Bei der Anlage wurden Sie nach einem Transportauftrag gefragt. CDS-Views werden über das Standardtransportwesen des SAP NetWeaver AS transportiert, es sind also keine zusätzlichen Schritte notwendig, um das Objekt in das Änderungs- und Transportsystem zu bringen. Den View können Sie allerdings so noch nicht aktivieren, da noch die Angabe der auszugebenden Spalten fehlt. Kümmern wir uns daher als Nächstes darum, Felder in die Ausgabe zu bringen. Fügen Sie dazu zwischen die geschweiften Klammern in Listing 5.2 den Inhalt aus Listing 5.3 ein. @EndUserText.label: 'Eindeutige Issue ID' key zissue.name as Issue_Name, //Normales Feld zissue.description as ISSUE_DESCRIPTION, zproject.project_name as PROJECT_NAME, @EndUserText.label: 'Aktion für den Entwickler' case zissue.state //Bedingte Ausgabe when 'NEW' then 'Noch nicht begonnen' when 'WIP' then 'In Bearbeitung' else 'Entwicklung abgeschlossen' end as DEVELOPMENT_STATE Listing 5.3 Spaltendefinition zum CDS-View ZCDSV_ISSUE

Aktivieren Sie Ihren CDS-View mit der Tastenkombination (Strg) + (F3). Klicken Sie im Project Explorer mit der rechten Maustaste auf den View ZCDSV_ ISSUE, und wählen Sie Data Preview im Kontextmenü. Öffnen Sie das SAP GUI ((Strg) + (6)), und wechseln Sie in Transaktion SE11. Geben Sie als View-Namen »ZISSUE_V« ein, und klicken Sie auf Display. Damit haben wir unseren ersten funktionstüchtigen CDS-View gebaut. Die Definition der angezeigten Spalten ist relativ simpel. Sie referenzieren auf den Namen der Spalte über den Tabellennamen und den Spaltennamen auf der Datenbank, getrennt mit einem Punkt. Sie haben hier die volle Unterstützung der Code-Vervollständigung. Schlüsselfelder definieren Sie, indem

245

5.3

5

Datenbankzugriffe

Sie der Definition der Spalte ein KEY voranstellen. Einen alternativen Bezeichner zu einer Spalte legen Sie optional mit dem Schlüsselwort AS fest. Auch für Spalten können Sie Annotationen angeben, z. B. eine zusätzliche Beschreibung zu den Spalten ISSUE_ID und zum DEVELOPMENT_STATE. Anhand des Feldes DEVELOPMENT_STATE sehen Sie noch eine Besonderheit der CDS-Views. Sie haben die Möglichkeit, konditionale Ausdrücke zu verwenden, um Felder direkt in der Abfrage auszuwerten. In unserem Beispiel sorgen wir etwa dafür, dass nur Status angezeigt werden, die für den Entwickler auch interessant sind. Den CDS-View können Sie wie eine normale Datenbanktabelle oder einen ABAP Dictionary View in der Data Preview oder auch in der Tabellenanzeige des SAP GUIs anzeigen lassen. Er taucht sogar in Transaktion SE11 als View auf. Allerdings können Sie den View dort nicht bearbeiten, da DictionaryViews nicht alle Funktionen unterstützen, die ein CDS-View bietet. Es werden daher nur die Eigenschaften angezeigt, die vom ABAP Dictionary auch verstanden werden. Verwenden Sie einen CDS-View im Quelltext, können Sie sich Details über die Elementinfo ((F2)) anzeigen lassen. Die Ausgabe unseres Views können Sie noch mit einer WHERE-Bedingung einschränken. Fügen Sie dazu hinter der geschwungenen Klammer die folgende Bedingung ein: WHERE zproject.loevm = '' AND zissue.loevm = ''.

Aktivieren Sie Ihre Änderungen mit (Strg) + (F3), und aktualisieren Sie die Anzeige der Data Preview. Das Einschränken der Ausgabe über eine WHEREBedingung ähnelt stark der Syntax aus OpenSQL. Es werden alle gängigen Vergleichsoperatoren (BETWEEN, =, , , =, NOT und LIKE) unterstützt, allerdings nicht die Schreibweise über Schlüsselwörter (EQ, LT etc.). Sie können diesen View nun wie eine Tabelle innerhalb einer SELECTAbfrage verwenden oder den neuen SAP List Viewer With Integrated Data Access (IDA) nutzen. Wir legen einen Report an, um das Ergebnis unseres Views in einer herkömmlichen ALV-Liste anzuzeigen. Erstellen Sie dazu einen neuen Report mit dem Namen Z_ISSUE_OVERVIEW, und fügen Sie den Code aus Listing 5.4 ein. Aktivieren Sie dann den Report, und führen Sie ihn mit (F8) aus. REPORT z_issue_overview. cl_salv_gui_table_ida=>create( 'ZISSUE_V' ) ->fullscreen( )->display( ). Listing 5.4 Report Z_ISSUE_OVERVIEW

246

Core Data Services

Anders als bei Dictionary-Views können Sie auch Aggregationen bilden. Die Klausel GROUP BY ... HAVING wird genauso unterstützt wie die Aggregationsoperatoren SUM, MIN, MAX, AVG und COUNT. Erstellen wir zum Abschluss einen neuen CDS-View mit einer Aggregationsfunktion. 1. Erstellen Sie eine neue DDL Source ((Strg) + (N)), und nennen Sie diese »ZCDSV_ISSUE_BY_STATE«. Ordnen Sie die DDL Source Ihrem Transportauftrag für die Aufgabenliste zu. 2. Wählen Sie als Template Define view with parameters, und legen Sie den View mit Finish an. Vervollständigen Sie das Listing wie in Abbildung 5.9.

Abbildung 5.9 CDS-View ZCDSV_ISSUE_BY_STATE

3. Fügen Sie nach der geschweiften Klammer eine WHERE-Klausel hinzu: where zissue.assigned_to = $parameters.ASSIGNED_TO.

Auch für die Angabe von Parametern können Sie die Code-Vervollständigung verwenden. 4. Markieren Sie die SELECT-Anweisung, und drücken Sie (Strg) + (1), um den Quick Fix zu öffnen. Wählen Sie den Vorschlag Add Group By Clause. Ihr Coding sollte nun aussehen wie in Listing 5.5. @AbapCatalog.sqlViewName: 'ZISSUE_STATE_V' @EndUserText.label: 'List Issues by their current state' define view Zcdsv_Issue_By_State with parameters ASSIGNED_TO : z_assigned_to as select from zissue { zissue.state as state, zissue.assigned_to as Responsible, count( * ) as Number_of_Entries } where zissue.assigned_to = $parameters.ASSIGNED_TO group by zissue.state, zissue.assigned_to Listing 5.5 CDS-View ZCDSV_ISSUE_BY_STATE

247

5.3

5

Datenbankzugriffe

5. Aktivieren Sie Ihre Änderungen ((Strg) + (F3)), und starten Sie die Data Preview für den eben angelegten View. 6. Geben Sie im Feld ASSIGNED_TO einen Namen an, der sich in Ihrem Demodatenbestand befindet. Neben der Aggregation haben Sie an diesem Beispiel noch zwei weitere Eigenschaften von CDS-Views kennengelernt: 왘 Zum einen haben wir einen Parameter hinzugefügt und diesen über eine WHERE-Bedingung ausgewertet. Die Data-Preview-Funktion ist in der Lage, diesen Parameter auszuwerten, und fragt ihn bei der Anzeige des Views ab. 왘 Zum anderen haben Sie gesehen, wie Sie Quick Fix innerhalb einer DDL Source verwenden können. Sie können hier im Übrigen fast alle QuelltextHilfen (wie Zeile löschen, duplizieren etc.) verwenden. Die Entwicklung der Core Data Services und der Data Definition Language steht erst am Anfang. Zukünftig ist geplant, auch andere ABAP-DictionaryObjekte mit Hilfe der DDL zu definieren. Damit wäre der Aufruf des SAP GUIs auch bei der Anlage von ABAP-Dictionary-Objekten nicht mehr notwendig. Derzeit gibt es Bestrebungen, Strukturen nativ in die ADT-Entwicklung zu integrieren. Anders als die CDS-Views sollen diese aber sowohl per DDL als auch in Transaktion SE11 zu bearbeiten sein.

248

Haben Sie sich schon einmal ein bestimmtes Werkzeug gewünscht, das Ihre Entwicklungsarbeiten vereinfachen würde? Sie sind Entwickler – was spricht also dagegen, sich selbst ein solches Werkzeug zu bauen? Eclipse ist eine Plattform, die alles mitbringt, um eigene Erweiterungen zu integrieren.

6

Erweiterungen der ABAP Development Tools

Eines der – meiner Meinung nach – spannendsten Themen der ABAP Development Tools for SAP NetWeaver (ADT) ist das Entwickeln eigener Erweiterungen. Eclipse ist von Grund auf flexibel und hoch erweiterbar ausgelegt, daher ist es recht einfach, eigene Erweiterungen (sogenannte Plug-ins) für Eclipse zu erstellen. Ob Sie einen einfachen Menüeintrag hinzufügen oder einen komplexen grafischen Editor zur Generierung von Quellcode erstellen möchten – Ihrer Kreativität sind praktisch keine Grenzen gesetzt. In den vorangegangenen Kapiteln konnten wir uns sehr gut um die technischen Details der ADT in Eclipse herumdrücken. Wenn Sie aber eigene Erweiterungen schreiben wollen, bleibt Ihnen ein bisschen Theorie nicht erspart. Ich beschränke die theoretischen Ausführungen in diesem Kapitel aber auf ein Minimum, sodass wir schnell wieder mit praktischen Beispielen fortfahren können. Für die Erweiterung der ADT genügen reine ABAP-Kenntnisse nicht. Sie müssen sowohl ABAP- als auch Java-Code schreiben. Das Beispiel in diesem Kapitel ist einfach gehalten, sodass Sie auch ohne fundiertes Wissen in Java folgen können sollten. Eine Einführung in Java kann dieses Buch jedoch nicht leisten. Bei der Entwicklung eines eigenen Plug-ins werden Sie auf Begriffe wie Feature, Manifest oder Extension stoßen. Ich beginne das Kapitel daher mit einer kurzen Führung durch die Welt der Eclipse-Plug-ins und beschränke mich dabei auf die grundlegenden Prinzipien. Sollten Sie bereits Erfahrung mit der Entwicklung von Eclipse-Plug-ins haben, können Sie Abschnitt 6.1, »Eclipse

249

6

Erweiterungen der ABAP Development Tools

Rich Client Platform«, überspringen und direkt mit Abschnitt 6.2, »ServerKomponente der ABAP Development Tools«, beginnen.

6.1

Eclipse Rich Client Platform

Viele verbinden mit Eclipse die Erstellung von Java-Programmen. Dies ist zwar die populärste »Inkarnation« der Eclipse Rich Client Platform (RCP), wird aber dem Wesen von Eclipse bei Weitem nicht gerecht. Der Anwendungskern von Eclipse ist vergleichsweise klein und für einen Endanwender recht langweilig. Er stellt nur eine grundlegende Ausführungsumgebung bereit. Sie können sich die reine Plattform unter http://download.eclipse.org/eclipse/ downloads/ herunterladen. Sie schlägt derzeit mit ca. 64 MB zu Buche und stellt Grundfunktionen wie die Workspace-Verwaltung, das Hilfesystem und eine OSGi-Laufzeitumgebungbereit. Die eigentlichen Funktionen werden durch Plug-ins implementiert. Die Java Development Tools (JDT), die Entwicklungsumgebung für Java, sind demnach genauso eine Erweiterung zur Eclipse-Plattform wie die ABAP Development Tools. Auch zur Entwicklung von Eclipse-Erweiterungen gibt es eine eigene Erweiterung: das Plug-in Development Environment (PDE) (siehe Abbildung 6.1). Die Eclipse-Plattform bildet zusammen mit den Java Development Tools und dem Plug-in Development Environment das Eclipse Software Development Kit (SDK). Java Development Tooling (JDT) Plug-in Development Environment (PDE)

Workbench

Eclipse-Plattform

JFace

SWT

Help

Workspace

Team

Plattform-Runtime

Eclipse SDK

Abbildung 6.1 Aufbau des Eclipse Software Development Kits (SDK)

250

Neues Werkzeug

Neues Werkzeug

ABAP Development Tools (ADT)

Eclipse Rich Client Platform

6.1.1

Plug-in-System in Eclipse

Das Plug-in-System von Eclipse basiert auf der OSGi Service Platform. OSGi stand ursprünglich für Open Services Gateway initative – wird heute jedoch von der OSGi Alliance als Eigenname verwendet. Die OSGi Alliance hat ein offenes Komponentenmodell spezifiziert, das die Modularisierung von Softwaresystemen auf Basis von Plug-ins und Services ermöglicht. Vielleicht haben Sie im Zusammenhang mit OSGi schon einmal den Begriff Bundle gehört, den ich im Kontext dieses Kapitels äquivalent zu Plug-in verwende. Die OSGi Alliance gibt lediglich die Spezifikation des Komponentenmodells vor, andere Anbieter können diese Spezifikation nutzen, um OSGi-Laufzeitumgebungen zu implementieren. In Eclipse kommt Equinox als Laufzeitumgebung zum Einsatz. Ein Plug-in oder Bundle stellt eine abgegrenzte Funktionseinheit dar. Es kann Teil der grafischen Oberfläche von Eclipse sein oder nur Services anbieten, die von anderen Plug-ins verwendet werden können. Dementsprechend können mehrere Plug-ins zusammenarbeiten, um eine Funktionalität abzubilden. Sie werden in diesem Fall zu Features gruppiert. Features können wiederum über Update-Seiten ausgeliefert und einzeln installiert werden. Plug-ins sind lose gekoppelt, damit Eclipse flexibel auf bestimmte Anwendungsfälle angepasst werden kann. Diese lose Kopplung wird durch den Erweiterungsmechanismus erreicht, der von Eclipse (bzw. Equinox) angeboten wird. Plug-ins können Erweiterungspunkte definieren (Extension Points), für die sich andere Plug-ins registrieren können. Auf diese Weise bieten die Plug-ins Erweiterungen (Extensions) an. Die Extension Points und Extensions müssen (anders, als in der OSGi-Spezifikation vorgegeben) explizit über eine XML-basierte Konfiguration deklariert werden. Diese Technik zieht sich konsequent durch die Eclipse-Plattform und bildet die Grundlage zur Implementierung eigener Plug-ins bzw. ganzer Anwendungen. Um z. B. einen neuen Eintrag in einem beliebigen Menü zu erstellen, steht der Extension Point org.eclipse.ui.menu zur Verfügung. Möchten Sie einem Befehl einen Shortcut zuweisen, können Sie dies über den Extension Point org.eclipse.ui.bindings tun. Der Mechanismus ist am ehesten mit Enhancement Spots und Enhancement-Implementierungen bei der ABAP-Entwicklung zu vergleichen.

6.1.2

Anatomie eines Plug-ins

Ein Plug-in ist ein Bündel (oder eben Bundle) aus verschiedenen Bestandteilen, die zusammen ausgeliefert werden. Diese Bestandteile können in einer

251

6.1

6

Erweiterungen der ABAP Development Tools

JAR-Datei (Java-Archiv) zusammengefasst werden. Einer der Bestandteile eines Plug-ins ist der Quellcode. Eclipse-Plug-ins werden in Java geschrieben. Der Code wird zur Ausführung in class-Dateien kompiliert, d. h., anders als bei ABAP-Programmen sind Sie nicht automatisch in der Lage, den Code der Erweiterungen einzusehen oder zu debuggen. Allerdings wird zu den meisten Eclipse-Plug-ins der lesbare Java-Code zusammen mit der Quelltextdokumentation zusätzlich bereitgestellt. Haben Sie ein Plug-in-Projekt im Project Explorer geöffnet, finden Sie den Java-Code im Verzeichnis src (siehe 1 in Abbildung 6.2).

Abbildung 6.2 Aufbau eines Eclipse-Plug-in-Projekts

Einen weiteren Bestandteil bilden die Ressourcen, also alles, was ein Plug-in an zusätzlichen Dateien benötigt. Dies können Icons, Bilder, Textdateien oder ähnliche Bestandteile sein. In Abbildung 6.2 sehen Sie den Ordner Icons 2, den Eclipse beim Erstellen eines Plug-ins automatisch anlegt. Sie können weitere Ordner anlegen, um die Ablage zusätzlicher Dateien zu organisieren. Achten Sie aber darauf, dass Sie diese Ordner explizit im Manifest deklarieren müssen, wenn sie Bestandteil des ausgelieferten Plug-ins werden sollen. Das Manifest ist eine formale Beschreibung des Plug-ins. Es besteht aus mehreren Dateien 3: 왘 MANIFEST.MF Die Datei MANIFEST.MF enthält Informationen zum Plug-in wie den Namen und die Versionsnummer sowie die »Haupt«-Klasse (den Activator). Zudem können Sie hier die Abhängigkeiten zu anderen Plug-ins definieren, wenn Ihr Plug-in mit anderen Bestandteilen von Eclipse zusammenspielen soll – was praktisch immer der Fall ist. 왘 Plugin.xml In der Datei Plugin.xml spezifizieren Sie, an welchen Stellen Sie Erweiterungen (Extensions) zu anderen Plug-ins einbringen möchten. Zudem

252

Eclipse Rich Client Platform

deklarieren Sie hier Extension Points, um anderen Plug-ins die Möglichkeit zu bieten, Ihre Implementierung zu erweitern. 왘 Build.properties In dieser Datei werden Informationen zur Erstellung des Plug-ins hinterlegt, z. B. die Verzeichnisse für den Quelltext und für Ressourcen, die mit ausgeliefert werden sollen. Sie müssen diese Dateien nicht von Hand pflegen, sondern Eclipse bietet dazu einen grafischen Manifest-Editor (siehe Abbildung 6.3), der sich öffnet, sobald Sie eine der Manifest-Dateien im Project Explorer öffnen. Der Manifest-Editor bietet für alle Dateien eigene Oberflächen, die, wie in Abbildung 6.3 unten dargestellt, in einzelne Registerkarten aufgeteilt sind. Änderungen auf den Einstellungsseiten spiegeln sich in den Dateien des Manifests wider und umgekehrt.

Abbildung 6.3 Manifest-Editor

253

6.1

6

Erweiterungen der ABAP Development Tools

Sie müssen sich nicht selbst darum kümmern, die Struktur in Abbildung 6.2 für Ihr Plug-in aufzubauen oder Konfigurationsdateien anzulegen. Dies erledigt Eclipse beim Erstellen eines Plug-in-Projekts automatisch. Zudem bietet Eclipse eine Reihe von Vorlagen-Plug-ins an, die Sie als Ausgangspunkt für eigene Entwicklungen verwenden können. In Abschnitt 6.5, »Implementierungen im Frontend (Eclipse)«, werden wir das hier Gelernte anwenden und ein Eclipse-Plug-in erstellen.

6.2

Server-Komponente der ABAP Development Tools

Man neigt dazu, die ADT auf das zu reduzieren, was sich auf dem EclipseFrontend abspielt, das ist allerdings so, als beschränke man ein Auto auf die Karosserie. Die ADT bestehen aus zwei Bestandteilen (siehe Abbildung 6.4): 왘 dem Eclipse-Client, also den Features und Plug-ins, die Sie über die UpdateSeite installiert haben. Die ADT-Plug-ins basieren auf den in Abschnitt 6.1, »Eclipse Rich Client Platform«, beschriebenen Prinzipien. 왘 der Server-Komponente, also dem, was sich unter der Haube abspielt

Werkzeuge

HTTP via RFC

Eclipse-Client

R

Entwickler Eclipse-Plattform

ABAP-Backend 1 REST-Services

… ABAP-Backend n REST-Services

Abbildung 6.4 Architektur der ADT (Quelle: SAP)

Sie entwickeln zwar in den ADT in einem Client, der vermeintlich losgelöst von einem (ABAP-)Server existiert, der SAP NetWeaver Application Server (AS) ist allerdings bei fast allen Operationen führend. Ob Sie Quelltext abspeichern, einen Syntaxcheck durchführen oder den Pretty Printer ausführen – alle diese Aktionen werden von Eclipse lediglich angefragt, der Server führt die Arbeiten durch und liefert dem Frontend das Ergebnis zurück. Wenn Sie ein Objekt bearbeiten, wird es zunächst auf dem Server gesperrt. Daher gibt es keine Probleme bei der Synchronisation von Objekten, wie sie bei einem Check-in-/Check-out-Szenario auftreten würden. Die Kehrseite der Medaille

254

Server-Komponente der ABAP Development Tools

ist, dass es nicht möglich ist, die ADT in einem reinen Offline-Szenario zu betreiben. Allerdings kommt Eclipse sehr gut mit kurzzeitigen Unterbrechungen der Verbindung klar. Es kommt ein intelligenter Caching-Mechanismus zum Einsatz, der lokale Änderungen puffert und zum gegebenen Zeitpunkt auf den Server überträgt. Aktionen wie das Aktivieren oder Speichern des Quelltextes sind zu diesen Zeitpunkten allerdings nicht möglich. Eclipse kommuniziert über Remote Function Calls (RFC) mit dem AS ABAP. Diese Schnittstelle ist nach dem REST-Prinzip (Representational State Transfer) konzipiert. Objekte werden als Ressourcenbetrachtet, die über eine eindeutige Identifikation (Unique Resource Identifier, URI) adressiert werden können. Operationen auf den Ressourcen werden über eine Untermenge der im HTTP-Protokoll spezifizierten Methoden (GET, POST, PUT und DELETE) abgebildet. Um etwa den Quelltext einer Klasse anzufragen, wird eine GET-Anforderung auf die URL http(s)://:/sap/bc/adt/oo/classes//source/main ausgeführt. Im Prinzip passiert hier das Gleiche, als würden Sie in Ihrem Webbrowser eine Adresse eingeben und sich die entsprechende Seite anzeigen lassen. Der Browser setzt im Hintergrund ebenfalls eine GET-Anforderung für die angegebene Adresse ab und erhält die angefragte Ressource (Webseite). Die empfangene Seite wird geparst und aufbereitet angezeigt. Eclipse stellt den Inhalt einer HTTP-Anfrage dagegen z. B. als Quelltext im Editor oder als Inhalt eines Views dar. Client

ABAP-Server

Resource Application A

RFC Handler Resource Application B

Resource Controller A1 Resource Controller A2 Resource Controller B1 Resource Controller A2

Datenbank Datenmodell A OpenSQL Datenmodell B

Abbildung 6.5 Interaktion zwischen Client und ABAP-Server (Quelle: SAP)

Abbildung 6.5 zeigt die Interaktion zwischen dem (Eclipse-)Client und dem AS ABAP schematisch. Zu jeder Ressource, die abgefragt werden kann, gibt es einen Resource Controller für den Zugriff der Schnittstelle auf das domänenspezifische Modell. Er kümmert sich darum, dass bei einer GET-Anfrage der korrekte Datensatz von der Datenbank gelesen und zurückgegeben wird, sollte dabei allerdings nur koordinative Aufgaben erfüllen und nicht direkt mit der Datenbank kommunizieren, sondern Anfragen möglichst über ein

255

6.2

6

Erweiterungen der ABAP Development Tools

Datenmodell stellen. Die Übersetzung des gefundenen Datensatzes zur Übertragung erfolgt über einen Content Handler (nicht in der Abbildung). Der Resource Controller sorgt lediglich dafür, dass der richtige Handler instanziiert und mit den entsprechenden Daten versorgt wird. Damit Ressourcen (bzw. deren Controller) verwendet werden können, müssen sie einer Resource Application zugewiesen werden. Dabei können eine oder mehrere Ressourcen zu einer Applikation zusammengefasst werden. In unserem Beispiel könnten diese Ressourcen Issues oder Projekte sein. Anfragen werden durch den RFC Handler zunächst an die entsprechende ResourceApplication-Klasse geleitet, die sich darum kümmert, dass der korrekte Resource Controller gefunden und aufgerufen wird. Es ist möglich, eigene Ressourcen bzw. Resource Applications zu erstellen. Dazu steht ein BAdI (BADI_ADT_REST_RFC_APPLICATION) im Enhancement Spot SADT_REST_RFC_APPLICATION bereit, das erweitert werden kann. Die neuen Ressourcen können dann über ein Eclipse-Plug-in konsumiert werden. Eines der Grundprinzipien einer REST-basierten Architektur ist die Entkopplung des Clients vom Server. Zu dieser strengen Trennung gehört, dass der Client einer Anwendung keine Vermutungen über die interne Struktur der Ressourcen anstellen darf, es sollen also keinerlei URIs fest hinterlegt werden, sondern durch die REST-Applikation selbst bereitgestellt werden. Der Client benötigt lediglich einen Einstiegspunkt. Dieses Prinzip wird auch als Hypermedia as the engine of application state (HATEOAS) bezeichnet. Man kann sich das in etwa so vorstellen, als liefere die Anwendung ihre eigene Gebrauchsanweisung mit. Diese Anforderung wird innerhalb der ADT über den sogenannten Discovery Service erfüllt, der über einen festen Einstiegspunkt erreichbar ist. Neue Applikationen (bzw. Ressourcen) werden hier registriert, die Plug-in-Seite benötigt also nur noch die Adresse des Servers und den festen URI des Discovery Services. Auch der Discovery Service kann über ein BAdI (BADI_ADT_ DISCOVERY_PROVIDER) erweitert werden.

6.3

Entwicklungsumgebung für Erweiterungen vorbereiten

Praktischerweise haben Sie mit Eclipse gleich das beste Werkzeug zur Verfügung, um Eclipse-Plug-ins zu schreiben. Je nachdem, welches Eclipse-Paket Sie heruntergeladen haben, sollten Sie allerdings zuvor noch einige vorberei-

256

Entwicklungsumgebung für Erweiterungen vorbereiten

tende Maßnahmen treffen. Sind Sie den Anleitungen in Kapitel 1, »Die ersten Schritte – ›Hallo ADT‹«, gefolgt, haben Sie die Eclipse IDE for Java EE Developers (PDE) heruntergeladen, mit der Sie auch Plug-in-Projekte anlegen können. Allerdings fehlen in dieser Version viele Features des Plug-in Development Environments, und Ihnen stehen nicht die Dokumentationen und die Quelltexte der Eclipse-Plattform-Plug-ins zur Verfügung. Der einfachste Weg, dem Abhilfe zu schaffen, ist die im Folgenden beschriebene Installation des Features Eclipse SDK (Software Development Kit) über den Update-Manager, mit dem alle wichtigen Features der PDE heruntergeladen und installiert werden. 1. Wählen Sie Help 폷 Install New Software in Ihrer Eclipse-Umgebung. 2. Wählen Sie unter Work with aus der Liste der verfügbaren Update-Seiten The Eclipse Project Updates – http://download.eclipse.org/eclipse/updates/ 4.4 (siehe Abbildung 6.6). Wenn Sie Eclipse Kepler verwenden, wählen Sie die Update-Seite http://download.eclipse.org/eclipse/updates/4.3.

Abbildung 6.6 Zu installierende Features auswählen

257

6.3

6

Erweiterungen der ABAP Development Tools

3. Wählen Sie in der Liste darunter Eclipse SDK, und fahren Sie mit Next fort. 4. Ihnen werden die abhängigen Features und Plug-ins, die mit installiert werden, angezeigt. Fahren Sie mit Next fort. 5. Lesen und bestätigen Sie die Lizenzvereinbarungen, und starten Sie die Installation mit Finish. Die Installation kann einige Minuten dauern, kann aber wie üblich auch im Hintergrund ausgeführt werden. Sie werden benachrichtigt, sobald die Komponenten installiert wurden. Um den Prozess abzuschließen, ist ein Neustart der IDE notwendig. Die erfolgreiche Installation erkennen Sie unter anderem daran, dass Ihnen in der Datei plugin.xml nun eine Kontexthilfe bei der Bearbeitung der Extensions sowie eine integrierte Hilfe zu den Extension Points zur Verfügung steht. Zudem sind nun die vollständige SDK-Dokumentation sowie die Quelltexte der Eclipse-Plattform-Komponenten verfügbar. Um auch in den Genuss einer Dokumentation für die ADT-Komponenten zu kommen, müssen Sie noch einmal Hand anlegen. Die Dokumentation des ADT SDKs besteht aus einem How-to-Guide und der Dokumentation im Format Javadoc). Beides können Sie unter http://scn.sap.com/docs/DOC-40894 herunterladen. Merken Sie sich die Stelle, an der Sie die SDK-Dokumentation entpacken, da Sie diese später noch an die projektspezifischen Bibliotheken anhängen müssen.

6.4

Implementierungen im Backend (SAP NetWeaver AS ABAP)

Um einen guten Ausgangspunkt für die Entwicklung Ihres ersten eigenen ADT-Plug-ins zu haben, benötigen Sie zunächst die entsprechenden Ressourcen auf dem Server. Wir bleiben bei unserem Beispiel und bieten unsere Issues als Ressourcen an. Mindestvoraussetzungen Um das REST-Framework erweitern zu können, benötigen Sie mindestens SAP NetWeaver AS ABAP 7.4 SP2. Beachten Sie auch, dass Sie unter Umständen den SAP-Hinweis 1774777 einspielen müssen.

Abbildung 6.7 vermittelt einen Eindruck von unserer geplanten Beispielerweiterung. Neben den Klassen ist dort die Vererbungsstruktur innerhalb des Frameworks abgebildet, um Ihnen die Orientierung im Framework zu

258

Implementierungen im Backend (SAP NetWeaver AS ABAP)

6.4

vereinfachen. Wir legen zunächst den Resource Controller ZCL_ISSUE_RES_ CTRL an. Dieser sollte von der Klasse CL_ADT_REST_RESOURCE aus dem ADT

SDK erben. Anschließend legen wir die Resource Application ZCL_ISSUE_ RES_APP an, die von der Klasse CL_ADT_DISC_RES_APP_BASE erbt. Die Resource Application ZCL_ISSUE_RES_APP tragen wir als Implementierung des BAdIs BADI_ADT_REST_RFC_APPLICATION ein. Außerdem legen wir in Abschnitt 6.6, »Discovery Service«, noch die Klasse ZCL_ISSUE_DISCOVERY an, um unsere Ressource dem Discovery Service verfügbar zu machen.

IF_HTTP_EXTENSION CL_ADT_REST_RESOURCE

CL_REST_HTTP_HANDLER

IF_REST_HANDLER IF_REST_APPLICATION

CL_ADT_RES_APP_BASE

IF_ADT_REST_RFC_APPLICATION

IF_ADT_DISCOVERY_PROVIDER CL_ADT_DISC_RES_APP_BASE IF_BADI_INTERFACE

ZCL_ISSUE_RES_CTRL

ZCL_ISSUE_RES_APP

ZCL_ISSUE_DISCOVERY

Abbildung 6.7 Serverseitige Implementierung der Beispielerweiterung

6.4.1

Resource Controller

Um den Resource Controller zu implementieren, legen Sie im Paket Z_ ISSUE_LIST eine neue ABAP-Klasse über die Tastenkombination (Strg) + (N) an. Nennen Sie die neue Klasse »ZCL_ISSUE_RES_CTRL«, und vergeben Sie eine passende Beschreibung (siehe Abbildung 6.8). Wählen Sie als Superklasse CL_ADT_REST_RESOURCE. Fügen Sie die Klasse Ihrem Transportauftrag hinzu, und beenden Sie die Anlage mit Finish. In der Resource-Controller-Klasse können Sie Implementierungen zu den unterstützten HTTP-Methoden anlegen, in unserem Fall gibt es nur die POSTMethode. Über den Request-Parameter haben Sie Zugriff auf den Inhalt der HTTP-Anfrage. Die POST-Methode soll Anfragen zur Anlage neuer Issues entgegennehmen. Die Daten werden dabei im XML-Format geliefert. Das ADT SDK bringt einige Hilfsklassen mit, die Sie dabei unterstützen, die Daten aus der Anfrage zu extrahieren und zur Weiterverarbeitung bereitzustellen, die

259

6

Erweiterungen der ABAP Development Tools

sogenannten Content Handler. Um mit XML-Strukturen umzugehen, steht Ihnen der Handler CL_ADT_REST_ST_HANDLER zur Verfügung. Sie übergeben ihm eine Simple Transformation, und er sorgt dafür, dass Sie Strukturen und Tabellen in XML umwandeln können und umgekehrt.

Abbildung 6.8 Klasse ZCL_ISSUE_RES_CTRL anlegen

Beginnen wir damit, eine solche Transformation für unsere Issues zu erstellen. 1. Markieren Sie das Paket Z_ISSUE_LIST im Project Explorer. 2. Drücken Sie (ª) + (Strg) + (N), um ein neues Dictionary-Objekt anzulegen. 3. Wählen Sie aus der Liste der verfügbaren Objekte Transformation. 4. Nennen Sie die Transformation »Z_ISSUE_ST«, und starten Sie die Anlage mit Finish. Da Transformationen noch nicht durch die ADT unterstützt werden, springen Sie in ein SAP-GUI-Fenster ab (siehe Abbildung 6.9). 5. Vergeben Sie eine Beschreibung zu Ihrer Transformation, und wählen Sie Simple Transformation aus der Auswahlliste Transformation Type.

Abbildung 6.9 Simple Transformation Z_ISSUE_ST anlegen

260

Implementierungen im Backend (SAP NetWeaver AS ABAP)

6. Bestätigen Sie Ihre Angaben sowie die Auswahl des Pakets Z_ISSUE_LIST, und hängen Sie die Transformation an Ihren Transportauftrag für die Aufgabenliste. 7. Wechseln Sie nach erfolgreicher Anlage zur Registerkarte Source Code, und ersetzen Sie den Inhalt durch Listing 6.1. Listing 6.1 Implementierung der Transformation Z_ISSUE_ST

8. Aktivieren Sie die Transformation mit den Tasten (Strg) + (F3). Die Transformation kann nun innerhalb eines Content Handlers verwendet werden. Ersetzen Sie dazu den Inhalt der Klasse ZCL_ISSUE_RES_CTRL durch den Code aus Listing 6.2. CLASS zcl_issue_res_ctrl DEFINITION PUBLIC INHERITING FROM cl_adt_rest_resource FINAL CREATE PUBLIC.

261

6.4

6

Erweiterungen der ABAP Development Tools

PUBLIC SECTION. CONSTANTS: c_class_name TYPE seoclsname VALUE 'ZCL_ISSUE_RES_CTRL', c_st_transformation TYPE string VALUE 'Z_ISSUE_ST', c_root_element TYPE string VALUE 'ISSUES'. METHODS: post REDEFINITION. PROTECTED SECTION. PRIVATE SECTION. ENDCLASS. CLASS zcl_issue_res_ctrl IMPLEMENTATION. METHOD post. DATA: ls_issue TYPE zissue, lr_handler TYPE REF TO if_adt_rest_content_handler, lr_issue TYPE REF TO zcl_issue. * Content Handler anlegen lr_handler = cl_adt_rest_cnt_hdl_factory=>get_instance( )->get_ handler_for_xml_using_st( st_name = c_st_transformation root_name = c_root_element ). * Inhalt des Requests abfragen request->get_body_data( EXPORTING content_handler = lr_handler IMPORTING data = ls_issue ). * Issue anlegen CHECK ls_issue is not initial. lr_issue = NEW zcl_issue( ). lr_issue->set_issue( is_issue = ls_issue ). lr_issue->save( EXCEPTIONS failed_to_save = 1 OTHERS = 2 ). IF sy-subrc 0. response->set_status( status = 409 ). ELSE. * Daten anhängen ls_issue = lr_issue->get_issue( ). response->set_body_data( content_handler = lr_handler

262

Implementierungen im Backend (SAP NetWeaver AS ABAP)

data = ls_issue ). response->set_status( status = 201 ). ENDIF. ENDMETHOD. ENDCLASS. Listing 6.2 Implementierung der Klasse ZCL_ISSUE_RES_CTRL

Die Methode POST wird aufgerufen, wenn ein Client (Eclipse) versucht, eine neue Ressource anzulegen. Zugriff auf den Inhalt der Anfrage liefert der Parameter Request. Die Antwort kann über den Parameter Response beeinflusst werden. Um die XML-Struktur der Anfrage verarbeiten zu können, wird in Listing 6.2 zunächst ein neuer Handler mithilfe der Factory-Klasse CL_ADT_REST_CNT_HDL_FACTORY angelegt. Sie geben ihm den Namen der Transformation sowie das Wurzelelement mit (das Sie in der Transformation angegeben haben), den Rest erledigt die Factory-Klasse. Über diesen Weg können Sie auch andere Content Handler (etwa für die Verarbeitung von einfachem Text) instanziieren. Dazu stellt die Klasse CL_ADT_REST_CNT_HDL_FACTORY jeweils eigene Methoden bereit. Reichen Ihnen die Möglichkeiten der vorhandenen Handler nicht aus, ist es prinzipiell auch möglich, einen eigenen Handler zu programmieren. Den Inhalt des Requests erhalten Sie über request->get_body_data. Der generische Rückgabeparameter kann direkt in eine Struktur vom Typ ZISSUE konvertiert werden. Es folgt die Anlage eines Issues über die Methoden, die wir selbst in Kapitel 2, »Funktionen der ABAP Development Tools«, implementiert haben. Geht bei der Anlage etwas schief, wird ein HTTP-FehlerCode (409) zurückgegeben. Andernfalls wird der Code für Ressource angelegt (201) gesetzt. Das Coding zeigt zudem, wie Sie einer Response Daten anhängen können. Wir werden die Daten in diesem Beispiel nicht auswerten, das Vorgehen können Sie aber als Beispiel heranziehen. Bei der Anlage einer Getter-Methode können Sie genauso vorgehen, um Daten zurückzuliefern.

6.4.2

Resource-Application-Klasse

Der Resource Controller, den wir geschrieben haben, existiert im Moment vollkommen losgelöst und ist daher noch nicht verwendbar. Sie müssen nun dafür sorgen, dass Anfragen vom Frontend korrekt weitergeleitet werden. Um Ressourcen zu registrieren, gibt es ein BAdI, dessen Implementierungen die Resource-Application-Klassen bilden. Welche Resource-ApplicationKlasse verwendet wird, kann über einen Filter auf den URI gesteuert wer-

263

6.4

6

Erweiterungen der ABAP Development Tools

den. Innerhalb der Methode REGISTER_RESOURCE der Implementierung können nun einzelne Resource Controller registriert werden. Legen Sie die Resource-Application-Klasse im Paket Z_ISSUE_LIST an, und nennen Sie sie »ZCL_ISSUE_RES_APP«. Geben Sie CL_ADT_DISC_RES_APP_ BASE als Superklasse an. Den Quellcode der Klasse sehen Sie in Listing 6.3. CLASS zcl_issue_res_app DEFINITION PUBLIC INHERITING FROM cl_adt_disc_res_app_base FINAL CREATE PUBLIC. PUBLIC SECTION. METHODS: if_adt_rest_rfc_application~get_static_uri_path REDEFINITION. PROTECTED SECTION. METHODS: get_application_title REDEFINITION, register_resources REDEFINITION. PRIVATE SECTION. ENDCLASS. CLASS zcl_issue_res_app IMPLEMENTATION. METHOD get_application_title. result = 'Issue List'. ENDMETHOD. METHOD register_resources. registry->register_discoverable_resource( EXPORTING url = '/issues' handler_class = zcl_issue_res_ctrl=>c_class_name description = 'Issue in the issue list' category_scheme = 'http://psp.solutions/adt/issues' category_term = 'issues' ). ENDMETHOD. METHOD if_adt_rest_rfc_application~get_static_uri_path. result = '/solutions/psp/issuelist'. ENDMETHOD. ENDCLASS. Listing 6.3 Implementierung der Resource-Application-Klasse ZCL_ISSUE_RES_APP

Aus Platzgründen habe ich in Listing 6.3 auf die Deklaration von Konstanten verzichtet. Generell ist es aber eine gute Idee, Festwerte in Konstanten abzulegen. In der Klasse werden drei Methoden implementiert. Die Methode GET_APPLICATION_TITLE liefert einen sprechenden Titel für unsere Resource

264

Implementierungen im Backend (SAP NetWeaver AS ABAP)

Application. Die Methode GET_STATIC_URI_PATH liefert als Rückgabewert den Teil des URIs, der für alle Ressourcen Ihrer Applikation gelten soll. Dementsprechend werden alle URIs unserer Aufgabenliste mit /solutions/psp/ issuelist beginnen. In der Methode REGISTER_DISCOVERABLE_RESOURCES hinterlegen wir nun noch, dass es eine Ressource namens »issue« gibt, die unter der URI /solutions/psp/issuelist/issues zu erreichen ist und deren Resource Controller ZCL_ISSUE_RES_CTRL heißt. Nun müssen Sie noch die Resource-Application-Klasse als BAdI-Implementierung hinterlegen: 1. Öffnen Sie in Eclipse den Enhancement Spot SADT_REST_RFC_APPLICATION mit der Tastenkombination (ª) + (Strg) + (A). 2. Klappen Sie auf der linken Seite den Knoten BADI_ADT_REST_RFC_APPLICATION auf, klicken Sie mit der rechten Maustaste auf den Eintrag Implementations, und wählen Sie Create BAdI Implementation (siehe Abbildung 6.10).

Abbildung 6.10 Implementierung des BAdIs BADI_ADT_REST_RFC_APPLICATION

3. Es erscheint ein Dialog zur Auswahl einer Erweiterungsimplementierung. Legen Sie mit (F8) oder dem Anlegen-Button ( ) eine neue Implementierung an. 4. Nennen Sie das neue Enhancement »Z_ISSUE_LIST«, und vergeben Sie eine Beschreibung. Legen Sie die Erweiterung mit (¢) bzw. über einen Klick auf das grüne Häkchen ( ) an. Weisen Sie das Paket Z_ISSUE_LIST und den passenden Transportauftrag zu. 5. Sie gelangen zurück zur Auswahlliste, in der Z_ISSUE_LIST schon vorgewählt sein sollte. Bestätigen Sie die Auswahl mit (¢) oder dem grünen Häkchen ( ).

265

6.4

6

Erweiterungen der ABAP Development Tools

6. Sie gelangen in den Dialog Create BAdI Implementation. Tragen Sie hier »ISSUE_RESOURCE_APPLICATION« als BAdI Implementation und »ZCL_ ISSUE_RES_APP« als Implementing class ein. Vergeben Sie auch eine aussagekräftige Beschreibung, und bestätigen Sie mit (¢) oder dem grünen Häkchen ( ). Abbildung 6.11 zeigt das Ergebnis.

Abbildung 6.11 Enhancement Implementation zur Resource Application

Damit haben wir dem BAdI unsere Resource-Application-Klasse als Implementierung zugewiesen. Nun müssen wir noch dafür sorgen, dass diese Implementierung nur an geeigneter Stelle greift. Dazu legen wir einen Filter auf den angefragten URI an: 1. Klicken Sie in der Enhancement-Implementierung Z_ISSUE_LIST doppelt auf den Eintrag Filter Val. auf der linken Seite (siehe Abbildung 6.11). 2. Wechseln Sie in den Änderungsmodus, und klicken Sie auf die Schaltfläche Combination zur Anlage einer neuen Filterkombination. 3. Klicken Sie doppelt auf die neue Filterkombination (1 in Abbildung 6.12). 4. Geben Sie im Feld Comparator 2 den Wert »CP« 2 und als Value 2 »/solutions/psp/issuelist/*« ein, und bestätigen Sie Ihre Eingaben. 5. Der Resource-Application-Klasse wurde automatisch das Interface IF_ADT_ REST_RFC_APPLICATION hinzugefügt, das wir nicht benötigen, da die Klasse von der Klasse CL_ADT_DISC_RES_APP_BASE erbt. Wechseln Sie in die Klasse ZCL_ISSUE_RES_APP, entfernen Sie die Interface-Deklaration interface IF_ADT_REST_RFC_APPLICATION, und aktivieren Sie die Klasse.

266

Implementierungen im Frontend (Eclipse)

Abbildung 6.12 Neuen Filter anlegen

6. Wechseln Sie zurück zur Enhancement-Implementierung Z_ISSUE_LIST, und prüfen Sie die Konsistenz der BAdI-Implementierung ((Strg) + (F2)). Aktivieren Sie sie anschließend ((Strg) + (F3)). Damit haben wir unser Issue als Ressource auf dem Backend bereitgestellt und können beginnen, das Plug-in zu entwickeln.

6.5

Implementierungen im Frontend (Eclipse)

Der einfachste Weg, ein neues Plug-in zu erstellen, ist, mit einer der vielen Vorlagen zu beginnen, die der Anlage-Assistent von Eclipse bietet. Wir verwenden daher eine Vorlage, die bereits einen Eintrag zum Aufruf eines Kommandos in der Toolbar und im Menü von Eclipse erzeugt. 1. Erstellen Sie ein neues Eclipse-Plug-in-Projekt. Im Project Explorer drücken Sie dazu (Strg) + (N) und wählen Plug-In Project im Dialog zur Anlage. 2. Nennen Sie das Projekt solutions.psp.issuelist. (Die Benennung nach der Namenskonvention Reverse Domain Naming ist nicht verpflichtend, hat sich aber bei Plug-ins und Paketstrukturen durchgesetzt.) Achten Sie darauf, im Bereich Target Plattform die Eclipse Version 3.5 or greater einzustellen (siehe Abbildung 6.13). Die restlichen Einstellungen können Sie so belassen und mit Next fortfahren.

267

6.5

6

Erweiterungen der ABAP Development Tools

Abbildung 6.13 Plug-in solutions.psp.issuelist anlegen

3. Im folgenden Dialog Content können Sie den Namen Ihres Plug-ins sowie verschiedene Laufzeitinformationen eintragen bzw. so lassen, wie sie sind. Achten Sie darauf, dass die Option This Plug-in will make contribution tot he UI ausgewählt ist, und dass Sie keine RCP-Anwendung (Rich Client Application) erstellen (siehe Abbildung 6.14). Fahren Sie mit Next fort. 4. Wählen Sie aus der Liste der verfügbaren Vorlagen Hello, World Command, und fahren Sie mit Next fort. 5. Ändern Sie auf der Seite Sample Command Contribution nur den Handler Class Name in »CreateIssueHandler« (siehe Abbildung 6.15). Schließen Sie die Anlage mit Finish ab. Eclipse legt nun ein Plug-in-Projekt an, das Sie so, wie es ist, bereits ausführen können. Klicken Sie dazu mit der rechten Maustaste auf den Projektnamen, und wählen Sie Run As 폷 Eclipse Application im Kontextmenü.

268

Implementierungen im Frontend (Eclipse)

Abbildung 6.14 Einstellungen zum Inhalt des Plug-ins

Abbildung 6.15 Sample Command Contribution – Einstellungen

Debugging Breakpoints können in Java-Quelltext genau wie in ABAP-Quelltext gesetzt werden. Allerdings müssen Sie Ihr Plug-in (so wie jeden anderen Java-Code auch) im Debug-Modus starten, damit diese berücksichtigt werden. Wählen Sie dazu einfach Debug As 폷 Eclipse Application anstelle von Run As 폷 Eclipse Application.

269

6.5

6

Erweiterungen der ABAP Development Tools

Daraufhin startet eine neue Eclipse-Instanz mit einem eigenen Workspace und dem neuen Plug-in an Bord. Sie finden einen neuen Button in der Toolbar ( ) sowie einen neuen Eintrag Sample Menu im Eclipse-Menü. Klicken Sie auf einen dieser Einträge, öffnet sich ein Dialogfenster, das freundlich die Welt grüßt (siehe Abbildung 6.16).

Abbildung 6.16 Erste Version des Plug-ins »Issuelist« in Aktion

Wie funktioniert das Plug-in? Zunächst einmal muss Eclipse (bzw. die OSGiPlattform) wissen, in welcher Weise das Plug-in seinen Beitrag leisten wird. Dies ist im Manifest hinterlegt. Schließen Sie die Testinstanz von Eclipse, und kehren Sie zurück zu Ihrem Plug-in-Projekt. Klicken Sie dort auf die Datei Plugin.xml im Project Explorer (1 in Abbildung 6.17). Sie gelangen zur Registerkarte Extensions 2 im Manifest-Editor. Hier können Sie deklarieren, in welcher Form das Plug-in sich an einer Erweiterung der Eclipse IDE beteiligen soll. In der Extension org.eclipse.ui.menus 3 registrieren Sie Ihr Plug-in z. B. dafür, Einträge in einem Menü hinzuzufügen. Welches Menü Sie dabei genau ansprechen, spezifizieren Sie mit einem location URI 4. Plug-in Selection Spy Wenn Sie vorhandene Plug-ins der Eclipse-Umgebung erweitern möchten, ist es nützlich, einige technische Details zu kennen. Der Plug-in Selection Spy liefert Informationen über den Plug-in-Namen, die Location-URIs einzelner Menüs oder die Selektionsmöglichkeiten. Sie rufen den Plug-in Selection Spy auf, indem Sie mit der Maus an die Stelle klicken, über die Sie mehr erfahren möchten, und dann die Tastenkombination (ª) + (Alt) + (F1) drücken.

Menüeinträgen können Kommandos (Commands) zugewiesen werden, die Sie bei der Extension org.eclipse.ui.commands registrieren können. Über die Erweiterung org.eclipse.ui.handlers kann für das Kommando dann

270

Implementierungen im Frontend (Eclipse)

eine Handler-Klasse hinterlegt werden. Im Fall unseres Demo-Plug-ins finden Sie die Handler-Klasse (CreateIssueHandler) im Project Explorer im Verzeichnis src, im Paket solutions.psp.issuelist.handlers.

Abbildung 6.17 Extensions des Plug-ins »Issuelist«

Die Registerkarte Extensions ist nur eine aufbereitete Ansicht. Die Datei, auf der sie basiert, können Sie auf der Registerkarte plugin.xml einsehen.

6.5.1

Abhängigkeiten

Abhängigkeiten zu anderen Plug-ins werden im Manifest auf der Registerkarte Dependencies definiert. Im Augenblick finden sich hier nur die Plugins org.eclipse.ui und org.eclipse.core.runtime. Um mit dem SAPBackend kommunizieren zu können, benötigen Sie noch die Dienste weiterer Plug-ins. Fügen Sie nun alle benötigten Plug-ins auf der Registerkarte Dependency hinzu: 1. Klicken Sie doppelt auf die Datei plugin.xml (oder MANIFEST.MF), um in den Manifest-Editor zu gelangen. Wechseln Sie hier zur Registerkarte Dependencies. 2. Klicken Sie auf den Button Add, um neue Abhängigkeiten zu definieren. Es öffnet sich der Dialog Plug-in Selection. 3. Suchen Sie mithilfe des Eingabefeldes nach dem Plug-in org.eclipse. core.resources. Die Ergebnisliste wird erst aufgebaut, wenn Sie etwas in das Suchfeld eingeben. Markieren Sie das gesuchte Plug-in in der Ergebnisliste, und bestätigen Sie mit OK.

271

6.5

6

Erweiterungen der ABAP Development Tools

4. Verfahren Sie auf die gleiche Weise, um die Abhängigkeiten zu den folgenden ADT-Plug-ins zu definieren: 왘 com.sap.adt.communication 왘 com.sap.adt.compatibility 왘 com.sap.adt.destinations 왘 com.sap.adt.destinations.ui 왘 com.sap.adt.tools.core 왘 com.sap.adt.project.ui 왘 com.sap.adt.project Die Änderungen, die Sie im Manifest-Editor vorgenommen haben, werden in der Datei MANIFEST.MF gesichert. Dabei handelt es sich um eine Konfigurationsdatei, die Sie prinzipiell auch manuell pflegen könnten. Um sich den Inhalt direkt anzusehen, wechseln Sie im Manifest-Editor zur Registerkarte MANIFEST.MF. Neben den Einträgen im Manifest hat die Definition der Abhängigkeiten auch dafür gesorgt, dass Ihr Plug-in-Projekt mit den entsprechenden Bibliotheken verknüpft wurde. Sie finden sämtliche referenzierten Bibliotheken im Project Explorer unter dem Eintrag Plug-in Dependencies. Anhand dieser Referenzen können Sie innerhalb Ihres Codes auf die Klassen der einzelnen Plug-ins zugreifen. Allerdings fehlt zunächst die Dokumentation. Wenn Sie innerhalb Ihres Java-Codes eine Klasse oder eine Methode markieren und (F2) drücken, erhalten Sie – wie bei der ABAP-Programmierung auch – die Signatur sowie die vorhandene Dokumentation. Da die ADT-Plug-ins ohne Dokumentation ausgeliefert werden, erhalten Sie für unser Plug-in über die Element Info nur die Signatur und einen Hinweis auf die fehlende Dokumentation. Abbildung 6.18 zeigt die Element Info zum Interface IAdtCoreProject aus dem ADT SDK.

Abbildung 6.18 Fehlende Dokumentation zum Interface IAdtCoreProject

272

Implementierungen im Frontend (Eclipse)

Nun kommt die SDK-Dokumentation zum Tragen, die Sie in Abschnitt 6.3, »Entwicklungsumgebung für Erweiterungen vorbereiten«, heruntergeladen haben. Um diese Dokumentation an eine Bibliothek zu hängen, gehen Sie wie folgt vor: 1. Klicken Sie mit der rechten Maustaste auf die Bibliothek, und wählen Sie den Eintrag Properties im Kontextmenü. 2. Im folgenden Dialog wechseln Sie in den Bereich Javadoc Location (siehe Abbildung 6.19).

Abbildung 6.19 Pfad zur Dokumentation verknüpfen

3. Geben Sie im Feld Javadoc Location Path den Pfad zu Ihrer heruntergeladenen Dokumentation an, und stellen Sie über den Button Validate sicher, dass Sie das richtige Verzeichnis gewählt haben. Bestätigen Sie mit dem Button OK. Wenn Sie nun ein Quellcode-Element der entsprechenden Bibliothek markieren und (F2) drücken, sollte Ihnen die Dokumentation wie in Abbildung 6.20 angezeigt werden. Leider müssen Sie diesen Vorgang für alle Bibliotheken wiederholen, für die die Dokumentation verfügbar sein soll. Ich empfehle Ihnen, die Quelltextdokumentation nur bei Bedarf an die Bibliotheken anzuhängen.

273

6.5

6

Erweiterungen der ABAP Development Tools

Bibliotheken identifizieren Es ist nicht immer ganz einfach, herauszufinden, in welcher Bibliothek bzw. in welchem Plug-in sich eine bestimmte Klasse befindet. Einen Anhaltspunkt bietet das Paket, dem die Klasse zugeordnet ist. Wenn Sie sich über die Taste (F2) Elementinformationen anzeigen lassen, wird Ihnen wie in Abbildung 6.18 das Paket angezeigt. Anhand der Benennung der Bibliotheken können Sie meistens erahnen, in welchem Paket sich die Klasse befindet. Sicherheit erhalten Sie, indem Sie die Bibliothek im Project Explorer aufklappen und sich die Pakete und Klassen (als classDatei) innerhalb der Bibliotheken anzeigen lassen.

Mit der Dokumentation sind Sie gewappnet, um die Eclipse-Welt mit der ABAP-Welt zu verknüpfen.

Abbildung 6.20 Dokumentation einer ADT-spezifischen Klasse

6.5.2

Verbindung zum Backend

Nun ist es an der Zeit, den SAP NetWeaver Application Server (AS) zu kontaktieren. Das Bindeglied zwischen Eclipse Worbench und AS ABAP ist das ABAP-Projekt, das auch als Einstiegspunkt dient, um eine Verbindung mit dem Backend herzustellen. Über das Projekt erhalten Sie Informationen über das Zielsystem (Destination ID), mit denen Sie in der Lage sind, REST-Ressourcen anzulegen und auf dem Backend abzufragen. Oft genutzte Funktionen wie das Beschaffen einer Destination ID können Sie in eine eigene Utility-Klasse auslagern, um den Code leichter wiederverwenden zu können: 1. Klicken Sie im Project Explorer mit der rechten Maustaste auf das Paket solutions.psp.issuelist, und wählen Sie New 폷 Class im Kontextmenü.

274

Implementierungen im Frontend (Eclipse)

(Achten Sie darauf, dieses Mal eine Java-Klasse anzulegen – keine ABAPKlasse.) 2. Geben Sie im Dialog New Java Class »IssueUtils« als Klassennamen ein. Die Paketzuordnung wurde bereits mit solutions.psp.issuelist vorbelegt. Lassen Sie die restlichen Einstellungen, wie sie sind, und legen Sie die Klasse mit Finish an. 3. Fügen Sie den Code aus Listing 6.4 in Ihre Klasse ein: public class IssueUtils { // Hält die aktuelle Selektion private ISelection selection; public IssueUtils(ISelection selection) { this.selection = selection; } public String getDestination() { // ausgewähltes Projekt ermitteln IProject project = ProjectUtil.getActiveAdtCoreProject( this.selection, null, null, IAdtCoreProject.ABAP_PROJECT_NATURE); IAbapProject abapProject = (IAbapProject) project .getAdapter(IAbapProject.class); // korrekte Anmeldung am System sicherstellen AdtLogonServiceUIFactory.createLogonServiceUI() .ensureLoggedOn(abapProject.getDestinationData(), PlatformUI.getWorkbench().getProgressService()); // Logisches Ziel bestimmen String destination = abapProject.getDestinationId(); return destination; } // URIs für ein Issue ermitteln public URI getURI() { return URI.create("/solutions/psp/issuelist/issues"); } } Listing 6.4 Implementierung der Klasse IssueUtils

4. Drücken Sie (ª) + (Strg) + (O), um die fehlenden Importanweisungen zu generieren. Speichern Sie die Klasse mit (Strg) + (S). (Ein Aktivieren ist bei Java-Code nicht notwendig. Eclipse kompiliert den Quellcode automatisch in ausführbaren Byte-Code.)

275

6.5

6

Erweiterungen der ABAP Development Tools

Die Klasse sorgt dafür, dass die Destination ID des aktuell ausgewählten Projekts gewählt wird. Dazu holt sie über die Hilfsklasse ProjectUtil zunächst das aktuell ausgewählte ABAP-Projekt, wozu sie die aktuelle Selektion in Form des Interfaces ISelection benötigt. ISelection ist ein sehr allgemeines Interface, um jegliche Art von Auswahl in Eclipse abzubilden. Konkrete Ausprägungen sind dabei z. B. die Klassen TreeSelection oder BlockTextSelection. Die Methode getActiveAdtCoreProject() der Klasse ProjectUtlil liefert ebenfalls nur eine sehr allgemeine Klasse – IProject – zurück. Das konkrete ABAP-Projekt wird über einen Adapter bezogen. Adapter Pattern Projekte sind nicht das einzige Beispiel für die Nutzung von Adaptern. Das Adapter Pattern zieht sich durch die gesamte Eclipse-API. Es sorgt dafür, dass die Kopplung zwischen den einzelnen Plug-ins so gering wie möglich gehalten wird. IProject und IAbapProject stehen in keiner direkten Vererbungsbeziehung zueinander. Die Anweisung abapProject = (IAbapProject)project; ist zwar syntaktisch korrekt, führt aber bei Ausführung zu einer ClassCastException. Durch den Adapter können Sie die beiden Klassen aber dennoch ineinander konvertieren.

Über die Klasse AdtLogonServiceUIFactory beziehen Sie den Logon-Service. Damit stellen Sie sicher, dass Sie authentifiziert sind und auf das ausgewählte System zugreifen können. Sollte keine gültige Anmeldung vorliegen, wird über die Methode ensureLoggedOn() automatisch eine Anmeldemaske angezeigt. Über die Methode abapProject.getDestinationId() erhalten Sie den Namen des logischen Ziels, mit dem Sie eine Verbindung aufbauen können. Die Adressierung einer Issue-Ressource erfolgt über einen relativen URI, den die Methode getURI() liefert. In Abschnitt 6.6, »Discovery Service«, werden wir die Implementierung durch den Discovery Service ersetzten. Damit die Ressource beim Aufruf des Kommandos abgerufen wird, ersetzen Sie den Code der Methode execute() in der Klasse CreateIssueHandler durch den Code aus Listing 6.5. public Object execute(ExecutionEvent event) throws ExecutionException { IWorkbenchWindow window = HandlerUtil .getActiveWorkbenchWindowChecked(event); ISelection selection = window.getSelectionService() .getSelection(); IssueUtils utils = new IssueUtils(selection); String destination = utils.getDestination();

276

Implementierungen im Frontend (Eclipse)

URI issueURI = utils.getURI(); // Anlage des Resource Issue IRestResource issueResource = AdtRestResourceFactory .createRestResourceFactory() .createResourceWithStatelessSession(issueURI, destination); try { //HTTP-Methode absetzen (Issue senden) IResponse response = issueResource.post( new NullProgressMonitor(), IResponse.class); MessageDialog.openInformation(window.getShell(), "Issuelist", response.getStatusLine()); } catch (RuntimeException e) { MessageDialog.openInformation(window.getShell(), "Issuelist", e.getMessage()); } return null; } Listing 6.5 Implementierung der Methode CreateIssueHandler.execute()

Sie können das Plug-in nun über Run As 폷 Eclipse Application testen. Achten Sie darauf, dass Sie auch in der Testumgebung ein neues ABAP-Projekt anlegen müssen. Starten Sie das neue Kommando, werden Sie nach einem Passwort für Ihr Projekt gefragt, wenn Sie noch nicht angemeldet waren. Als Ergebnis der Testausführung öffnet sich das Pop-up-Fenster in Abbildung 6.21.

Abbildung 6.21 Resultat des Testaufrufs

Ein interessanter Abschnitt in Listing 6.5 ist das Anlegen der Ressource. Über die Klasse AdtRestResourceFactory wird eine Ressource mit einer zustands-

277

6.5

6

Erweiterungen der ABAP Development Tools

losen Session erstellt, d. h., auf dem Server werden zwischen zwei Aufrufen durch den Eclipse Client keine Daten vorgehalten. Es gibt auch die Möglichkeit, eine zustandsbehaftete Session zu erstellen, dies sollte aber nur in Ausnahmesituationen geschehen, da REST eine zustandslose Kommunikation vorschreibt. Mithilfe der erstellten Ressource können nun HTTP-Anfragen an den Server gestellt werden, in unserem Fall ein POST. Das Ergebnis ist vom Typ IResponse und gibt uns den Zugriff auf die Antwort vom Server. Das Vorgehen können Sie auf alle anderen unterstützten HTTP-Methoden anwenden (GET, PUT, DELETE). In Abschnitt 6.5.3, »Datenaustausch«, schauen wir uns auch noch an, wie wir mit Inhalten in der Anfrage bzw. der Antwort umgehen können. Mit der jetzigen Konfiguration können Sie bereits die grundsätzliche Funktionsweise eines ADT-Plug-ins analysieren. Setzen Sie in der Methode zcl_ issue_res_ctrl->post auf dem ABAP-Server einen Breakpoint. Führen Sie Ihr neues Plug-in per Run As 폷 Eclipse Application aus. Klicken Sie nun auf den neuen Toolbar-Button ( ). Nun sehen Sie, wie Ihre Anfrage im Backend-System ankommt. Debugging von ABAP- und Java-Quellcode Vermeiden Sie, gleichzeitig ABAP- und Java-Quellcode zu debuggen, da dies derzeit noch zu Problemen führt. Analysieren Sie bei Bedarf zunächst die eine und dann die andere Seite. Um dieses Problem zu umgehen, starten Sie Ihre Plug-ins nicht im Debug-Modus, wenn Sie Breakpoints im ABAP-Code gesetzt haben.

Einen Überblick über die Kommunikation zwischen Eclipse und AS ABAP erhalten Sie mit dem ABAP Communication Log unter Window 폷 Show View 폷 Others … 폷 ABAP Communication Log. Um die Kommunikation zwischen Plug-in und Server zu visualisieren, müssen Sie das Communication Log zunächst über den Button Start Logging ( ) in der Toolbar des Views aktivieren. Daraufhin werden Ihnen in einer Tabelle alle Anfragen der ABAP Development Tools angezeigt. Mit einem Doppelklick auf die entsprechende Zeile können Sie sich Details zu der Anfrage ansehen. Sie sehen den Header sowie den Inhalt von Request und Response. Abbildung 6.22 zeigt die Anfrage des Plug-ins issuelist. Da wir noch keinen Content definiert haben, ist der untere Teil der Detailanzeige leer. Das ABAP Communication Log ist ein guter erster Anhaltspunkt, um herauszufinden, warum etwas nicht funktioniert. Zudem eignet es sich hervorragend, um bestehende Funktionen der ADT zu analysieren.

278

Implementierungen im Frontend (Eclipse)

Abbildung 6.22 View »ABAP Communication Log«

6.5.3

Datenaustausch

Die Verbindung zum Server funktioniert nun. Allerdings werden noch keine Daten versendet. Anders als ABAP besitzt Java keine nativen Sprachelemente, um Tabellen und Strukturen abzubilden, sondern bleibt hier seiner Natur als objektorientierter Sprache treu. Um ein Issue abzubilden, legen wir daher eine (Daten-)Klasse an. Dabei halten wir uns an die JavaBean-Spezifikation, nach der alle Felder der Klasse privat (von außen nicht sichtbar) und nur durch Getter- und Setter-Methoden erreichbar sind. Zudem soll eine Bean einen parameterlosen Constructor implementieren, um die Klasse zu initialisieren. Legen Sie die Datenklasse wie folgt an: 1. Markieren Sie im Project Explorer das Paket solutions.psp.issuelist, drücken Sie (Strg) + (N), und wählen Sie das Objekt Class. 2. Ändern Sie die Paketzuordnung auf solutions.psp.issuelist.beans, und geben Sie IssueData als Klassennamen an. 3. Legen Sie die Klasse mit einem Klick auf Finish an, und implementieren Sie sie wie in Listing 6.6. public class IssueData { private String id; private String name;

279

6.5

6

Erweiterungen der ABAP Development Tools

private private private private private

String String String String String

description; reporter; assignedTo; type; status;

public IssueData(){ } } Listing 6.6 Implementierung der Klasse IssueData

4. Setzen Sie den Cursor auf eine der Datendeklarationen, und drücken Sie (ª) + (Alt) + (S), um in das Quellcode-Menü zu gelangen, in dem Sie Generate Getters and Setters wählen. 5. Im folgenden Dialog markieren Sie alle Felder und klicken auf OK (siehe Abbildung 6.23). Eclipse generiert nun jeweils eine Getter- und eine SetterMethode für jedes gewählte Feld. Speichern Sie die Klasse mit (Strg) + (S).

Abbildung 6.23 Getter- und Setter-Methoden generieren

Streng genommen, müsste diese Datenklasse noch das Interface java. io.Serializable implementieren, um die Bean-Definition vollständig zu

280

Implementierungen im Frontend (Eclipse)

erfüllen. Da wir keine automatische Serialisierung verwenden, ist dies für das Beispiel jedoch nicht unbedingt erforderlich. Als Nächstes müssen Sie dafür sorgen, die Klasse IssueData mithilfe der Methode POST übertragen zu können. Das Bindeglied zwischen der Datenklasse und dem HTTP-Request ist ein Content Handler. Das ADT SDK bietet dazu das Interface IContentHandler an. Auf dieser Basis können Sie einen eigenen Content Handler für Issues erstellen: 1. Legen Sie eine neue Klasse IssueDataContentHandler im Paket solutions.psp.issuelist.beans an. 2. Wählen Sie über den Button Add das Interface com.sap.adt.communication.content.IContentHandler, und fügen Sie es hinzu. 3. Legen Sie die Klasse mit Finish an, und ersetzen Sie den Code durch den in Listing 6.7. Speichern Sie den Content Handler mit (Strg) + (S). public class IssueDataContentHandler implements IContentHandler { private static final String PREFIX = "issues"; private static final String ISSUE_ELEMENT = "issue"; private static final String ID = "issueid"; private static final String NAME = "name"; private static final String DESCRIPTION = "description"; private static final String REPORTER = "reporter"; private static final String ASSIGNED_TO = "assignedTo"; private static final String TYPE = "type"; private static final String STATUS = "state"; private static final String NAMESPACE = "http:// psp.solutions/adt/issues"; private AdtStaxContentHandlerUtility staxUtility = new AdtStaxContentHandlerUtility(); @Override public IssueData deserialize(IMessageBody arg0, Class