ABAP Tools - VS Code (Quick Start)
Die ABAP Development Tools für VS Code sind nun verfügbar und in diesem kleinen Guide schauen wir uns an, was du alles brauchst, um mit der Arbeit zu starten.
Inhaltsverzeichnis
In diesem Artikel schauen wir uns die Installation und die Verwendung von Visual Studio Code im Kontext von ABAP an. Das Plugin wurde nun released und ist offiziell verfügbar, sodass wir einen ersten Blick darauf werfen können.
Einleitung
Die ABAP Development Tools waren vor allem erst einmal nur für Eclipse verfügbar und wurden die letzten Jahre als Plugin dort entwickelt. Im letzten Jahr wurde bekannt, dass auch eine Erweiterung für VS Code zur Verfügung gestellt wird. Diese wurde gestern, am 28.05., freigegeben. Dabei wurde die grundsätzliche Architektur umgebaut und ABAP als Language Server zur Verfügung gestellt. Neben dem Language Server findest du auch direkt einen ABAP MCP-Server, der lokal mit integriert ist. Dies war auch der Grund, wieso die ABAP Development Tools im letzten Update für Eclipse so lange benötigt haben, weil vor allem die Architektur sich im Hintergrund geändert hat.
Mit VS Code besteht nun die Möglichkeit, in einer IDE die komplette Full-Stack-Entwicklung von RAP-Services über das UI in einer IDE durchführen zu können. Dabei werden in der Initialversion vor allem die neuesten Artefakte für ein Full-Stack-Szenario unterstützt. Weitere Artefakte werden mit den nächsten Releases zur Verfügung gestellt und langsam der gleiche Stand ausgerollt.
Installation
Beginnen wir erst einmal mit der Installation des Tools und dann das entsprechende Plugins, um mit der Entwicklung beginnen zu können.
VS Code
Im ersten Schritt musst du VS Code auf deinem Rechner installieren. Dafür steht dir die offizielle Webseite zur Verfügung, auf der du den Client herunterladen und installieren kannst. Falls du in einem Unternehmensnetzwerk arbeitest oder keine Administratorrechte auf deinem Computer hast, kann es sein, dass dir die Software von deinem Administrator zur Verfügung gestellt werden muss. Grundsätzlich benötigst du den Editor, um das Plugin überhaupt installieren zu können. Der Editor kommt nicht von SAP, daher wird auch keine Wartung zur Verfügung gestellt.
Wenn du die IDE zum ersten Mal öffnest, hast du eigentlich immer den gleichen Aufbau. Auf der linken Seite findest du das Menü mit verschiedenen Tools, die in deiner Entwicklungsumgebung zur Verfügung stehen. Je nach installierten Plugins können hier mehr oder weniger Icons angezeigt werden.
Im oberen Teil findest du die eigentliche Command Palette. Dort gibst du Kommandos ein, die gewisse Aktionen in deiner IDE triggern. Je nach Plugin stehen dir auch dort verschiedene Befehle zur Verfügung. Im unteren, großen Hauptbereich befinden sich die verschiedenen Editoren, die später geöffnet werden können. Hier ist der Aufbau erst einmal relativ ähnlich zu einer Eclipse-Installation, nur dass diese IDE deutlich schneller lädt.
Plugin
Über die Seitenleiste öffnest du das Extensions-Menü. Dort kannst du nach verschiedenen Erweiterungen suchen, siehst aber auch alle bereits installierten Extensions in deiner IDE. Wir suchen dort nun nach den "ABAP Development Tools" und sollten verschiedene ABAP-Plugins finden. Auf dem Screenshot ganz oben ist das offizielle Plugin der SAP gelistet, welches aktuell bereits über 500 Installationen aufweist. Über den Install-Button kannst du die Installation in deiner IDE starten und das Plugin zur Verfügung stellen.
Light Theme
Da wir ein Freund des hellen Designs sind und die Dark Themes wegen des Kontrasts nicht so sehr mögen, kann es sein, dass wir erst einmal das Theme umstellen müssen, falls die IDE automatisch im Dark Theme startet. Dazu gehen wir mit dem Cursor in die Command Palette und suchst nach "Preferences: Color Theme". Dabei spielt das Größer-als Zeichen eine wichtige Rolle, um die verschiedenen Kommandos überhaupt starten zu können. Geh dann auf diesen Menüpunkt, um zwischen den verschiedenen Themes auszuwählen. Dort kannst du dich zwischen verschiedenen Dark- und Light-Themes entscheiden und sie ganz auf deine Bedürfnisse anpassen.
System verbinden
Der nächste wichtige Punkt ist eigentlich, wie wir uns mit einem SAP-System verbinden, um mit unserer Arbeit beginnen zu können. Wenn du dir die Informationen im Plugin durchliest, wirst du bereits erste Hinweise erhalten, wie die Verbindung mit dem System funktioniert. Gehen wir dieses Kapitel einmal Schritt für Schritt durch und verbinden uns mit einem ersten System.
Verbinden
Dazu müssen wir uns im ersten Schritt mit dem System verbinden, indem wir eine neue Verbindung oder in diesem Fall eine Destination in unserer IDE anlegen. Als Kommando findest du unter dem ABAP-Bereich den Punkt "New Destination" (siehe Screenshot). Diese wählen wir aus, um den Wizard zu starten.
Im nächsten Schritt müssen wir uns entscheiden, ob wir ein Cloud-System anbinden, in diesem Fall über eine HTTP-Konfiguration, oder ob wir ein On-Premise-System über unsere Launchpad Konfiguration anbinden. Im Fall eines On-Prem Systems werden hier die verschiedenen Daten wie System-ID, User und Sprache abgefragt, bevor wir uns mit dem System verbinden. Allerdings wird für On-Prem aktuell nur SSO für die Anmeldung unterstützt. In unserem Beispiel verbinden wir uns mit einem ABAP Environment und wählen den Punkt "HTTP" für die Verbindung.
Hier trägst du die URL des eigentlichen Systems ein. Das System weiß dann, mit welchem Backend es sich verbinden und welche Konfigurationsparameter es verwenden muss.
Im zweiten Schritt fragt dich der Wizard, welchen Alias du verwenden willst. Dieser Alias wird später als Systemname angezeigt und ist auch in deine Ordnerstruktur eingebunden. Daher solltest du einen entsprechenden Namen wählen, um das System später leicht wiederzufinden, vor allem, wenn du mit sehr vielen Systemen arbeitest.
Einbinden
Nachdem wir nun die Verbindung hergestellt haben, können wir das System oder unser erstes Paket in den Workspace einbinden. Dazu benötigen wir ein neues Kommando. Suchst du in der Command Palette nach "ABAP Add", findest du drei verschiedene Optionen, um ABAP-Objekte zu deinem Workspace hinzuzufügen. Der Workspace ist der Bereich, mit dem du arbeitest. So kannst du zum Beispiel entscheiden, ob du eine Destination hinzufügen willst, dann wird das komplette System eingefügt. Oder du überlegst, ob du ein Paket hinzufügen willst, das ist ähnlich der Favoriten-Funktion von Eclipse, wo du ein bestimmtes Paket mit allen Unterobjekten deinem Workspace hinzufügst.
In diesem Fall wollen wir einmal ein Paket hinzufügen. Nachdem wir dieses Kommando gewählt haben, fragt uns der Wizard, für welches System (Destination) wir das tun wollen, und wir müssen uns im nächsten Schritt erst authentifizieren. Da wir gegen ein ABAP-Environment arbeiten, erfolgt die Authentifizierung im Browser. Nachdem die Authentifizierung durchgeführt wurde, können wir nach den Paketen suchen, die wir hinzufügen wollen. In diesem Fall suchen wir nach unserem Demopaket. Wenn dieses sich auf dem System befindet, erhalten wir alle Vorschläge mit dem Demopaket. Wählen wir das Paket aus, können wir dann einen Namen vergeben, der dem Workspace hinzugefügt wird, in diesem Fall Paketname plus System.
In diesem Beispiel haben wir einmal unser Paket hinzugefügt und einmal das komplette System. Du findest nun beide Einträge im Workspace auf der linken Seite deines Editors. Aktuell siehst du an den Ausrufezeichen, dass du nicht mit dem System verbunden bist. Das heißt, wenn du die Ordner öffnest, siehst du erst aktuell nichts, du musst dich zuerst am System anmelden.
Einloggen
Um die Anmeldung zu starten, klickst du per Rechtsklick auf den Eintrag und wählst dann "Logon to Destination" aus. Dabei wird wieder der Wizard gestartet und wir können die Anmeldung durchführen. In diesem Fall wird unser Browser gestartet und wir melden uns an, beziehungsweise wenn wir schon angemeldet sind, werden wir automatisch authentifiziert. Haben wir ein System hier eingestellt und eine RFC-Authentifizierung vorgenommen, dann passiert das Single Sign-On und wir sollten automatisch angemeldet sein.
Wir können nun die Ordnerstruktur aufklappen und sollten alle Unterpakete sehen, die in unserem Demopaket vorhanden sind. Da es so viele Pakete sind, ist hier nur ein Ausschnitt von einigen unserer Open-Source-Projekte zu sehen, die wir bereits in der Vergangenheit umgesetzt haben. Unter anderem finden wir die weiteren Demopakete hier.
Development
Führen wir nun einmal einige Grundfunktionen aus. Dabei wollen wir eine neue Klasse anlegen, eine erste Implementierung vornehmen, einen Unit-Test schreiben und beides am Ende ausführen, um die verschiedenen Wege durchzuspielen
Klasse
Um nun eine neue Klasse im System anzulegen, müssen wir wieder über die Command Palette gehen. Dort suchen wir nach dem Kommando "Create ABAP Repository Object". Damit können wir den Wizard für die Anlage eines neuen Objekts im System starten.
Als Erstes müssen wir dabei den Objekttypen auswählen. Hier werden die verschiedensten unterstützten Objekte angezeigt. Da wir eine neue Klasse auswählen und erstellen wollen, können wir so entweder nach "class" suchen oder aus der Liste der Objekte wählen, um den passenden Wizard für die Klasse zu starten.
Hierbei werden wir wieder durch die verschiedenen Schritte geführt, um eine Klasse zu definieren. Wir werden gefragt, in welchem Paket und auf welchem System wir das Objekt anlegen wollen. Ebenfalls werden wir nach einer Beschreibung gefragt, ob wir eine Superklasse definieren wollen oder ein Interface. Am Ende erfolgt noch mal ein Zwischenschritt, denn wenn wir in einem Paket arbeiten, welches einen Transport erfordert, fragt uns das System ebenfalls noch, ob wir einen neuen Transport anlegen wollen, oder schlägt uns bereits Transporte vor, die wir dafür haben.
Am Ende wird die Klasse direkt im Editor geöffnet. Im oberen Teil sehen wir den Pfad vom System über die verschiedenen Bibliotheken. Im Editor finden wir den eigentlich generierten Code für die Klasse. Damit können wir direkt mit der Arbeit an der Klasse beginnen.
Editieren
Erweitern wir zuerst einmal die Klasse, um ein Interface für den Class Runner zu implementieren. Dabei geben wir das Interface an und fangen mit dem Namen des Interfaces an. STRG + LEERTASTE startet wie immer den Wizard, der uns Vorschläge macht, welche Objekte wir hier verwenden können. So haben wir eine einfache Möglichkeit, den Namen von dem Interface zu finden, auch wenn wir den Namen nicht so 100 % kennen. Diese Funktion ist ähnlich wie in den ABAP Development Tools für Eclipse.
Aktuell scheint es keine einfache Möglichkeit zu geben, dass automatisch aus der Methodendefinition die Methoden-Implementierung generiert wird, hier müssen wir manuell nacharbeiten, beziehungsweise hilft uns "Joule for Developers", der auf diesem System aktiv ist, indem er uns Vorschläge für den Code macht. So können wir relativ leicht auch eine zusätzliche Methode implementieren, wo uns bereits ein Dummy-Text vorgeschlagen wird. Auch bei der Implementierung der Methode hilft uns Joule mit einem Vorschlag für den Code, der entsprechend die Methode aufruft und das Ergebnis in die Konsole ausgibt
CLASS zcl_bs_demo_vscode DEFINITION
PUBLIC
FINAL
CREATE PUBLIC .
PUBLIC SECTION.
INTERFACES: if_oo_adt_classrun.
PROTECTED SECTION.
PRIVATE SECTION.
METHODS get_hardcoded_text
RETURNING VALUE(result) TYPE string.
ENDCLASS.
CLASS zcl_bs_demo_vscode IMPLEMENTATION.
METHOD if_oo_adt_classrun~main.
out->write( get_hardcoded_text( ) ).
ENDMETHOD.
METHOD get_hardcoded_text.
result = 'Hello World'.
ENDMETHOD.
ENDCLASS.
Aktivieren
Da wir nun unsere Implementierung abgeschlossen haben, wollen wir den Code der Klasse aktivieren. Dazu gibt es aktuell drei Optionen. Über dem Editor findest du ein Icon für die Aktivierung des aktuellen Objektes. In der Fußzeile findest du ein Icon, um alle inaktiven Objekte zu aktivieren, oder du verwendest die Standardkombination STRG + F3, um die Aktivierung zu starten.
Ausführen
Um nun die Klasse als Konsolenanwendung starten zu können, hast du zwei Möglichkeiten. Entweder du machst einen Rechtsklick auf den Source Code und findest im Menü die Ausführoption "Run ABAP Application (Console)", oder du drückst im Objekt F5, um die Klasse zu starten. Ohne Debugger erfolgt entsprechend eine Ausgabe in die Konsole hier im unteren Teil unserer IDE.
Debugging
Als Nächstes wollen wir einmal den Debugger in unserer IDE starten. Dazu können wir wieder einen Breakpoint setzen und müssen dafür nur vor die Zeile gehen. Es wird ein entsprechender Punkt gesetzt, und wir erhalten die Information, dass wir hier einen Breakpoint aktivieren können. Diesen setzen wir auch, damit wir gleich ins Debugging starten können.
Beim nächsten Schritt können wir die Applikation mit F5 wieder starten und sollten direkt im Debugging landen. Die Debugging-Perspektive ist hier etwas anders als in anderen IDEs wie Eclipse. Auf der linken Seite findest du Informationen zu den verschiedenen Variablen, Watchpoints und dem Call-Stack. Ganz unten sind verschiedene Breakpoints die wir gesetzt haben. Wir sehen unseren Hauptcode und dem aktuelle Punkt, wo wir aktuell debuggen, und im oberen Teil findest du das Menü, um durch die Punkte durchschalten zu können. Dies entspricht den Optionen des Debuggings, wie wir sie auch aus Eclipse kennen, allerdings sind hier die Tastenkombinationen etwas anders. Per Mouse-Over findest du Informationen zu den Tastenkombinationen im Standard.
Unit Test
Damit wir für unsere Klasse einen Unit-Test schreiben können, müssen wir zuerst ins Test-Include kommen. Hier findest du unter dem Editor keine verschiedenen Reiter, sondern du musst im Baum auf der linken Seite schauen. Dort finden wir die verschiedenen Includes unterhalb der Klasse und müssen das Test-Include wählen.
Eine Template-Funktion zur Anlage der Testklasse haben wir im ersten Schritt nicht gefunden. Deshalb implementieren wir den Code manuell. Hierbei konnte uns wieder J4D helfen, der uns Vorschläge gemacht hat, was wir testen, wie wir es testen und nutzen können. Am Ende sieht unsere Testklasse im System wie folgt aus:
CLASS ltc_test DEFINITION FINAL
FOR TESTING
DURATION SHORT
RISK LEVEL HARMLESS.
PRIVATE SECTION.
METHODS:
first_test FOR TESTING.
ENDCLASS.
CLASS zcl_bs_demo_vscode DEFINITION LOCAL FRIENDS ltc_test.
CLASS ltc_test IMPLEMENTATION.
METHOD first_test.
DATA(cut) = NEW zcl_bs_demo_vscode( ).
DATA(result) = cut->get_hardcoded_text( ).
cl_abap_unit_assert=>assert_equals( exp = 'Hello World' act = result ).
ENDMETHOD.
ENDCLASS.
Zum Abschluss möchten wir den Unit Test dann auch noch ausführen. Hier haben wir nach einer Option gesucht und erst per Rechtsklick im Baum versucht. Hier gibt es auch "Run Tests", die wir ausführen können. Zusätzlich haben wir es über die Command Palette versucht und finden dort verschiedene Kommandos, um zum Beispiel den Unit-Test oder das ABAP Test Cockpit auszuführen. Diese Option startet dann auch unseren aktuellen Unit-Test, den wir offen haben.
Das Ergebnis des Unit-Tests erhalten wir dann wiederum. Einmal in der Konsole als Zusammenfassung, aber wir finden auch einen entsprechenden Test-Viewer auf der linken Seite, der geöffnet wird. Wenn wir diesen aufklappen, finden wir die eine Testmethode, die wir haben, dass sie erfolgreich durchgelaufen ist und welche Zeit sie benötigt hat. Grundsätzlich findest du darüber weitere Optionen, um den Test zu wiederholen.
Fazit
Die ABAP Development Tools in VS Code unterstützen einen ersten Use Case in Form von den neuesten Objekten in der ABAP-Entwicklung. Dabei können wir schon heute sehen, welches Potenzial das Tool zur Verfügung stellt, vor allem im Zusammenhang mit Agentic AI, welches von SAP angekündigt wurde und bereits heute über andere Coding Agents zur Verfügung steht. Mit diesem Artikel solltest du vor allem einen Schnelleinstieg in das Thema bekommen, wie du die IDE zum Laufen bekommst und wie du am Ende damit die ersten Schritte machen kannst.
