046: ABAP - ADT for VS Code (Part 2)

Inhaltsverzeichnis

• System verbinden
• Workspace
• Skallierung
• Objekte
• Objekt anlegen
• Debugging
• ABAP Unit
• Navigation
• Ausblick

In der letzten Folge hatten wir uns die Grundlagen angeschaut, wieso VS Code entstanden ist und was das Plugin für uns tun kann. Dabei sind wir auf die verschiedenen Punkte eingegangen: Was funktioniert bereits schon und was wird noch nicht funktionieren, zumindest nicht in dieser initialen Version. In dieser Folge gehen wir deshalb in die Praxis und schauen uns wichtige Punkte im Umgang mit dem Editor an.

 

System verbinden

Damit wir uns überhaupt mit einem neuen System verbinden können, müssen wir eine sogenannte Destination anlegen. Dazu gehen wir auf die Command Palette und suchen nach "ABAP: New Destination", um eine neue Konfiguration im Editor anzulegen. Aktuell stehen zwei Anmeldeverfahren zur Verfügung: per RFC zum Beispiel an die Private Cloud oder On-Premise-Systeme, oder per HTTP, um sich mit Cloud-Systemen zu verbinden. Im Fall der RFC-Konfiguration stehen im nächsten Schritt dann die konfigurierten lokalen Systeme, die über das SAP Logon bereitgestellt werden, zur Verfügung und können ausgewählt werden. Dort müssen dann Einstellungen vorgenommen werden wie Mandant, Username und Sprache, um sich an dem System anmelden zu können. In diesem Fall wollen wir uns mit einem ABAP Environment verbinden, also nehmen wir die HTTP-Destination. Im ersten Schritt der Konfiguration müssen wir die System-URL zur Verfügung stellen. Diese findest du relativ leicht: Du musst dich nur einmal am Fiori Launchpad zum Beispiel anmelden und kannst diese URL dann kopieren und hier einfügen. Zum Abschluss geben wir dem System noch einen Namen. Hier können wir zum Beispiel die System-ID verwenden oder wir geben hier einen sprechenden Namen an, den wir später dann auch wiedersehen werden. Damit sind wir mit der Grundkonfiguration der Destination fertig und können im nächsten Schritt den Workspace erweitern.

 

Workspace

Im Workspace arbeiten wir dann mit den eigentlichen Objekten und Systemen. Um erst einmal ein System in den Workspace zu bekommen, müssen wir dieses hinzufügen. Suchen wir nach dem Kommando "ABAP add", finden wir aktuell drei verschiedene Ausführungen und haben verschiedene Möglichkeiten, Objekte in den Workspace einzuhängen. Über "Add Package as Folder" können wir ein spezifisches Paket aus dem System wählen, welches wir dann einbinden wollen. Über "Add Destination" können wir ein komplettes System hinzufügen; dieses wird dann gesplittet nach lokalen Objekten und Softwarekomponenten angezeigt. Und als dritte Option können wir nur die lokalen Daten eines Systems hinzufügen, wenn wir zum Beispiel testweise damit experimentieren wollen. Diese Option funktioniert allerdings nicht sehr gut mit dem ABAP Environment, da wir hier nicht mit $TMP arbeiten, sondern mit ZLOCAL als lokale Komponente.

Wählen wir die Option, um ein Paket hinzuzufügen. Dabei müssen wir im nächsten Schritt die Destination eingeben, mit der wir uns verbinden wollen. Hier werden wir danach gefragt, uns erst einmal am System zu authentifizieren; das machen wir dann über den Browser mit einem Klick auf die erste Option im Dialog. Nach erfolgreicher Authentifizierung können wir dann nach den Paketen im System suchen. Hier verwenden wir unser Demo-AI-Paket, welches wir dann in den Workspace einbinden wollen. Am Ende können wir uns noch aussuchen, wie der Name der Struktur des virtuellen Dateisystems benannt wird, in diesem Fall setzt sich dieser aus dem Paketnamen und dem Systemnamen zusammen. Diesen lassen wir erst einmal so und übernehmen das Ganze, um dann unseren Workspace zu haben, mit dem wir weiterarbeiten wollen.

Bevor wir allerdings mit dem Workspace arbeiten können, müssen wir uns an diesem anmelden. Das erkennen wir daran, dass hinter dem Namen noch ein Ausrufezeichen zu sehen ist, welches darauf hindeutet, dass wir noch nicht angemeldet sind. Dazu einfach rechtsklicken auf den Ordner und die erste Option "Logon to Destination" auswählen, um sich noch einmal gegen das System zu authentifizieren und damit die entsprechende Struktur zu laden. Das Paket ist nun offen, und wir sehen die ersten beiden Oberpakete, die hier vorhanden sind.

 

Skallierung

Da es sich bei Visual Studio Code um eine Anwendung basierend auf Webkomponenten handelt, können wir hier relativ einfach das UI skalieren, ohne dabei die IDE neustarten zu müssen oder etwas an der Skalierung des Systems vorzunehmen. Über Steuerung Plus können wir hier den Zoom aktivieren und eine Stufe höher stellen. Du findest im unteren Bereich des Editors ein entsprechendes Plus-Symbol, dort kannst du weitere Einstellungen vornehmen oder auf den Standard zurücksetzen. Wir setzen das hier noch eins höher, damit wir für das Video auch die Elemente besser lesen können. Bei Eclipse hatten wir in der Vergangenheit das Problem, dass wir zwar den Quelltext größer machen konnten, aber die einzelnen UI-Elemente sich nicht verändert haben, was bei Präsentationen und Vorführungen dann meistens zu Problemen mit der Lesbarkeit geführt hat.

 

Objekte

Was beim Öffnen des Paketes erst einmal auffällt, ist, dass es hier eine JSON-Datei gibt, die die Konfiguration für das Paket enthält. Das sind Objekte, die nicht auf dem System vorhanden sind, aber die eigentlichen Pakete beschreiben, also die Dateien. Öffnen wir dann das Paket, finden wir die altbekannten Strukturen, hier zum Beispiel die Source Code Library, die wir weiter öffnen können, um Klassen, Interfaces und andere Quellcode-basierte Objekte zu erhalten. Hier öffnen wir einmal als Beispiel den Reader und finden dort einige Dateien mehr darunter. Grundsätzlich können wir über den oberen Punkt nicht die Klasse öffnen, sondern müssen über eine der Dateien darunter gehen. Die erste Datei beschreibt die allgemeine Klasse mit dem ABAP-Code. Hier können wir normal scrollen und uns den ABAP-Code anschauen. Möchten wir dann zum Beispiel in die Testklasse wechseln, müssen wir dazu eine entsprechende andere Datei für die Testklassen öffnen. Die allgemeinen Eigenschaften findest du im entsprechenden JSON ebenfalls in der Struktur.

Woher kommt eigentlich diese Struktur? Dazu schauen wir uns das Git-Projekt für die ABAP File Formats an. Diese definieren die eigentliche Struktur jedes einzelnen Objektes. Dabei handelt es sich um ein Open-Source-Projekt, welches von der Community und der SAP vorangetrieben wird, um jedem einzelnen Objekt eine Struktur zu geben, um es später auch im Dateiformat ablegen zu können. Gehen wir einmal in die verschiedenen Dateiformate rein und schauen uns dazu die Klasse an. Die Klasse besteht aus unterschiedlichen Objekten, die die einzelnen Elemente beschreiben. Da eine Klasse vor allem aus Includes besteht und nicht in einer einzigen Datei zu finden ist, gibt es hier auch entsprechend viele Dateien. So sehen wir zum Beispiel eine Konfigurationsdatei, die beschreibt, was in der Klasse vorhanden ist, ebenfalls die Source-Code-Datei, die den allgemeinen Teil der Klasse definiert, dazu die verschiedenen Includes für die Definitions, Implementations, Makros und die Testklassen sowie weitere Includes für die Textelemente, die in einer Klasse vorhanden sind. Sind entsprechend viele Sprachen vorhanden, sind entsprechend viele Includes möglich. Im hinteren Teil findest du auch verschiedene Beispiele und kannst schauen, wie so eine Datei aufgebaut ist und wie sie aussieht.

 

Objekt anlegen

Legen wir nun im System ein neues Objekt an. Dazu gehen wir wieder über die Command Palette und suchen nach "ABAP: Create New ABAP Object". Im nächsten Schritt können wir aus den verfügbaren Dateitypen wählen. Hier sehen wir die aktuell angebundenen Typen in VS Code und können uns eine Übersicht schaffen. Dazu wollen wir eine neue Klasse anlegen und landen dazu im entsprechenden Wizard. Wir sehen im oberen Bereich, dass wir aktuell fünf Schritte durchgehen müssen, um eine neue Klasse zu definieren. Im ersten Schritt definieren wir das Paket, in dem wir die Klasse anlegen wollen, und im zweiten Schritt vergeben wir den Namen der eigentlichen Klasse. In Schritt 3 vergeben wir eine Beschreibung. Schritt 4 und 5 können wir mit Enter einfach bestätigen, hier geht es um die Superklasse und das Interface, welches wir einbinden können. Danach startet die Anlage der neuen Klasse und erhalten einen leeren Klassenrumpf, mit dem wir arbeiten können.

Als nächsten Schritt wollen wir das Interface für die ausführbare Klasse hinterlegen. Dazu müssen wir dann einfach nur die Interfaces implementieren und suchen dann nach dem ersten Statement nach "IF_OO". Dann können wir mit CTRL + Space die Autovervollständigung starten. Hier sehen wir dann beide Interfaces aus dem System und können unser Interface wählen. Allerdings fehlt hier noch die Option, um dann die Implementierung für die Methode anzulegen. Das heißt, die eigentliche Implementierung müssen wir manuell durchführen. Es fehlt noch die Komfortfunktion, die wir auch in Eclipse haben. Danach geben wir direkt etwas in die Konsole aus, um eine erste Ausgabe zu erzeugen. Über das Kontextmenü oder den entsprechenden Shortcut findest du "Format Document". Damit können wir den Pretty Printer für das Dokument starten und einmal formatieren lassen. Den ABAP Cleaner gibt es aktuell noch nicht, dieser ist aber auch für VS Code geplant, was die Formatierung von Dokumenten unheimlich vereinfachen würde und den Standard aus der neuen Welt zur Verfügung stellt. Im nächsten Schritt müssen wir das Objekt aktivieren. Dazu findest du über dem Editor einen Button zum Aktivieren des einzelnen Objektes. Möchtest du alle inaktiven Objekte aktivieren, findest du unter dem Editor ein "Activate All". Dieser startet ein entsprechendes Pop-up, und wir können auswählen, welche Objekte wir insgesamt aktivieren wollen. Danach läuft eine normale Aktivierung im System; die Klasse wurde angelegt. Um dann die Klasse ausführen zu können, kannst du über das Kontextmenü auf dem Objekt die Option wählen oder F5 drücken, um die Klasse zu starten und in der Konsole eine Ausgabe zu erzeugen. Damit haben wir eine neue Klasse angelegt, aktiviert und entsprechend direkt auch ausgeführt.

 

Debugging

Schauen wir uns einmal das Debugging im neuen Editor an. Dazu kannst du wie immer einen Breakpoint auf der entsprechenden Zeile setzen; diese wird markiert und so sehen wir dann auch den aktiven Breakpoint. Dazu führen wir als Nächstes die Applikation wieder mit F5 aus und landen dann direkt in der Debugging-Ansicht. Hier finden wir die Basistools des Debuggings wieder. Das beschreibt dann den Editor, der im mittleren Bereich zu finden ist. Auf der linken Seite findest du den Variablen-View, verschiedene Watchpoints und auch den Call Stack aus dem System. Im unteren Bereich findest du aktive Breakpoints im Source-Code. Schön ist auch: Im unteren Teil wird er noch einmal markiert, wenn wir uns im Debugging-Modus befinden, und zwar mit einer roten Zeile. Insgesamt wechseln wir auch das Tool: Auf der linken Seite siehst du, dass wir in den Bereich „Run and Debug“ gewechselt sind, was relativ ähnlich zu den Perspectives in Eclipse ist. Über die Variablen haben wir Zugriff auf die verschiedenen lokalen Variablen oder können auch neue Variablen hinzufügen. Diese können wir öffnen und uns über die Standard-Tools die Inhalte anschauen. Dies entspricht noch nicht ganz den Inhalten, die wir in Eclipse sehen, sondern ist reiner Standard aus VS Code.

Im oberen Bereich findest du eine kleine Palette für die verschiedenen Schritte, die wir auch im Debugging gehen können. Diese sieht ähnlich aus wie die Debugging-Tools im Chrome-Browser. Diese kannst du frei verschieben; sie bietet dir die verschiedenen Optionen, um durch den Quellcode zu laufen, einen Schritt zu überspringen oder an entsprechende andere Punkte zu springen. Diese Optionen entsprechen den gleichen Optionen wie auch im Debugger in Eclipse. Grundsätzlich musst du hier aber sehen, dass die Keyboard-Shortcuts komplett unterschiedlich zu denen sind, die du in Eclipse vorfindest. Mit F5 lassen wir den Debugger durchlaufen und verlassen damit das Debugging des Objektes. Grundsätzlich kann man aber sagen, dass hier erst einmal nur die Standard-Tools implementiert wurden und weitere Tools wie zum Beispiel eine detailliertere Variablenansicht oder bessere Debugging-Funktionalitäten und Einblicke erst später nachgeliefert werden. Grundsätzlich für Standard-Debugging und erste Schritte ist das aber völlig ausreichend.

 

ABAP Unit

Im nächsten Schritt schauen wir uns nun das Arbeiten mit den Unit-Tests an und wie wir diese ausführen und uns die Ergebnisse über die Coverage ansehen können. Dazu wechseln wir in den RSS-Reader. Dies ist eine Implementierung, welche wir per Agentic AI erstellt haben, um unseren RSS-Feed einlesen und aufbereiten lassen zu können. Im ersten Schritt wechseln wir dazu auf das Include für die Testklasse. Um zu sehen, dass es einen Unit-Test gibt. Dann können wir über die Command Palette nach "ABAP: Run" suchen und finden verschiedene Optionen, um zum Beispiel Unit-Tests auszuführen, aber auch das ABAP Test Cockpit im System. Anstatt eines einfachen Unit-Tests wollen wir diesmal einen Unit-Test mit Coverage erstellen, um uns auch die Visualisierung innerhalb des Editors anzuschauen. Der Test wird im UI des Editors visualisiert, was wir im unteren Bereich sehen. Danach wechseln wir in das Tool für das Testing und sehen hier die ausgeführte Testklasse. Wir sehen, dass die entsprechende Methode ausgeführt wurde und diese auch erfolgreich ist. Dahinter findest du entsprechende Laufzeiten, so wie du es auch aus Eclipse gewöhnt bist.

Darunter findest du auch eine Anzeige der Test Coverage hier, die auf circa 87 % ausgeführt wurde. Schauen wir uns dann die Klasse an, müssen wir zurück in den Explorer wechseln und wollen diesmal die Implementierung sehen. Hier findest du Formatierungen und Hervorhebungen auf den Zeilennummern und kannst mit der Maus über die Zeile hovern. Ein schöner Unterschied im Gegensatz zur Eclipse-Implementierung ist, dass man hier zum Beispiel auch sieht, wie oft die einzelnen Stellen aufgerufen wurden, das heißt durch unsere Unit-Tests, welche Stellen besonders intensiv getestet wurden und welche gar nicht ausgeführt wurden.

 

Navigation

Wie sieht es eigentlich bei dir aus, wenn wir zum Beispiel kein Seitenmenü für ein Objekt haben oder wenn wir schnell zwischen den verschiedenen Objekten wechseln wollen? Dazu öffnen wir noch einmal unsere Anfangsklasse, die wir angelegt haben. Im oberen Bereich über dem Texteditor findest du das sogenannte Breadcrumb-Menü. Dabei ist alles aufgelistet, vom Workspace über die verschiedenen Pakete hin zum eigentlichen Objekt, in dem wir uns befinden. Wenn wir unter dem Objekt auf das Element klicken, auf dem wir gerade sind, können wir so zum Beispiel auch innerhalb des Texteditors auf die Testklasse wechseln oder auf die anderen Includes und Artefakte, die zu dieser Klasse gehören.

Grundsätzlich können wir aber auch die Pfade verwenden, die auf höherer Ebene vorhanden sind. Klicken wir zum Beispiel auf die Klasse, können wir alle Klassen sehen, die sich aktuell auf der gleichen Ebene befinden, hier unser Datenbank-Reader und der RSS-Reader als zusätzliche Klassen. Öffnen wir den RSS-Reader, sehen wir dann auch wieder alle Includes beziehungsweise Dateien, die sich darin befinden, und können auch direkt zu dem Objekt in das entsprechende Include wechseln. Das Gleiche passiert auch mit den Optionen, die wir weiter oben finden. So können wir bis auf Paketebene hochgehen und dann in den anderen Paketen Objekte selektieren, um diese dann in unserem Editor aufzurufen. Das heißt, eine zweite Form der Navigation ist über das Breadcrumb-Menü im oberen Teil, welche die Suche und Auswahl beschleunigen kann.

 

Ausblick

In dieser Folge haben wir uns die praktische Arbeit mit Visual Studio Code angeschaut, vom Einbinden eines Systems über das Anlegen von Objekten und das Arbeiten im Debugger sowie das Thema Unit-Testing. Grundsätzlich bietet das Tool alle Basiskomponenten, die wir zum Arbeiten mit Quellcode und dem System benötigen, muss aber in Zukunft auch noch weiter verbessert werden. In der nächsten Folge werden wir uns dann das Thema Agentic AI anschauen, wie du es in Visual Studio Code einrichten kannst, und schauen uns dann verschiedene Beispiele an, wo uns AI heute schon aktiv unterstützen kann. Danke fürs Zuschauen und bis zum nächsten Mal.

 

YouTube
Video