Erste Schritte mit Apex
Lernziele
Nachdem Sie diese Lektion abgeschlossen haben, sind Sie in der Lage, die folgenden Aufgaben auszuführen:
- Beschreiben der wichtigsten Merkmale der Programmiersprache Apex
- Speichern einer Apex-Klasse und Aufrufen von Methoden mit anonymem Apex-Code
- Verwenden Sie Web Console (Webkonsole), um Debug-Protokolle zu prüfen.
Bevor Sie loslegen
Wir freuen uns darauf, Sie bei der Einführung in Apex zu begleiten. In diesem Modul werden zwar grundlegende Informationen zur Programmiersprache vermittelt, dennoch geht es auch schnell in die Tiefe. Wenn Sie in diesem Modul zum ersten Mal mit Apex in Berührung kommen, empfehlen wir Ihnen dringend, zunächst das Projekt Schnelleinstieg: Apex durchzuarbeiten. Kehren Sie dann hierher zurück. Wir warten auf Sie!
Was ist Apex?
Apex ist eine Programmiersprache, die Java-ähnliche Syntax verwendet und wie in einer Datenbank gespeicherte Verfahren arbeitet. Apex ermöglicht es Entwicklern, Geschäftslogik in Systemereignisse zu integrieren. Dazu gehören Klicks auf Schaltflächen, die Aktualisierung verknüpfter Datensätze und Visualforce-Seiten.
Als Sprache zeichnet sich Apex durch folgende Eigenschaften aus:
-
Gehostet: Apex wird auf dem Server – der Salesforce Platform – gespeichert, kompiliert und ausgeführt.
-
Objektorientiert: Apex unterstützt Klassen, Schnittstellen und Vererbung.
-
Streng typisiert: Apex prüft Verweise auf Objekte zur Kompilierzeit.
-
Mandantenbewusst: Da Apex auf einer mandantenfähigen Plattform ausgeführt wird, schützt es sich strikt vor unkontrolliertem Code, indem es Obergrenzen durchsetzt. Diese Einschränkungen tragen dazu bei, dass Code an der Monopolisierung gemeinsam genutzter Ressourcen gehindert wird.
-
In der Datenbank integriert – Zugriff auf und Bearbeitung von Datensätzen sind ein Kinderspiel. Apex bietet direkten Zugriff auf Datensätze und deren Felder und stellt Anweisungen und Abfragesprachen zur Bearbeitung dieser Datensätze bereit.
-
Datenorientiert: Apex bietet transaktionalen Zugriff auf die Datenbank, sodass Sie Vorgänge per Rollback zurücksetzen können.
-
Benutzerfreundlich: Apex basiert auf Java-Idiomen.
-
Einfach zu testen: Apex bietet integrierte Unterstützung für die Erstellung, Durchführung und Codeabdeckung von Einheitentests.
-
Mit Versionsangabe: Benutzerdefinierter Apex-Code kann jetzt für verschiedene Versionen der API gespeichert werden.

Besondere Merkmale der Sprache Apex
Wie andere objektorientierte Programmiersprachen unterstützt Apex unter anderem folgende Sprachkonstrukte:
- Klassen, Schnittstellen, Eigenschaften und Sammlungen (Listen, Maps und Sets).
- Objekt- und Arraynotation
- Ausdrücke, Variablen und Konstanten
- Bedingte Anweisungen (if-then-else) und Steuerflussanweisungen (For-Schleifen und While-Schleifen)
Im Gegensatz zu anderen objektorientierten Programmiersprachen unterstützt Apex Folgendes:
- Cloud-Entwicklung, da Apex in der Cloud gespeichert, kompiliert und ausgeführt wird
- Auslöser, die Auslösern in Datenbanksystemen ähneln
- Datenbankanweisungen, mit denen Sie direkte Datenbankaufrufe vornehmen können, und Abfragesprachen zum Abfragen und Suchen von Daten
- Transaktionen und Rollbacks
- Den Zugriffsmodifikator "
global", der großzügiger ist als der Modifikator "public" und Zugriff auf alle Namespaces und Anwendungen gewährt
- Versionsverwaltung von benutzerdefiniertem Code
Darüber hinaus ist Apex eine Sprache, bei der nicht zwischen Groß- und Kleinschreibung unterschieden wird.
Entwicklungstools
Mithilfe von Salesforce Extensions for Visual Studio Code können Sie Apex auf Ihrem Client-Computer schreiben und debuggen. Mehr dazu finden Sie in Einfaches Entwickeln mit Salesforce-Erweiterungen (in englischer Sprache).
Sie können auch direkt im Browser auf der Salesforce-Benutzeroberfläche Apex schreiben und auf Debugging-Informationen zugreifen. Web Console (Webkonsole) ist eine moderne, schlanke, browserbasierte integrierte Entwicklungsumgebung (IDE), die die Lücke zwischen veralteten Legacy-Tools und ressourcenintensiven Entwicklungsumgebungen schließt. Weitere Informationen finden Sie in der Entwicklerdokumentation zu Web Console (Webkonsole).
Sie können die Web Console (Webkonsole) über das Schnellzugriffsmenü (
) öffnen.

Datentypen – Übersicht
Apex unterstützt verschiedene Datentypen, einschließlich eines Salesforce-spezifischen Datentyps – des Datentyps "sObject".
Apex unterstützt die folgenden Datentypen:
-
Primitive Objekte, wie "Integer", "Double", "Long", "Date", "Datetime", "String", "ID", "Boolean" usw.
- Ein sObject, entweder als generisches sObject oder als spezifisches sObject, wie "Account", "Contact" oder "MyCustomObject__c". (sObjects werden in einer späteren Lektion ausführlicher behandelt.)
- Eine Sammlung, wie etwa:
-
Eine Liste – eine geordnete, indizierte Sammlung von Elementen. Listenelemente können beliebige Datentypen aufweisen, darunter primitive Typen, Sammlungen, sObjects, benutzerdefinierte Typen und vom System bereitgestellte (integrierte) Apex-Typen.
- Ein Set – eine ungeordnete Sammlung von Elementen. Set-Elemente können ebenfalls beliebige Datentypen aufweisen und dürfen keine doppelten Werte enthalten.
- Eine Map – eine Sammlung von Schlüssel-Wert-Paaren, die jeden Datentyp aufweisen können.
- Eine eingegebene Liste von Werten, auch als Enumeration bezeichnet
- Benutzerdefinierte Apex-Klassen
- Vom System bereitgestellte (integrierte) Apex-Klassen
Apex-Sammlungen: Liste
Listen enthalten eine geordnete Sammlung von Daten desselben Typs.
Die folgenden beiden Deklarationen sind synonym. Die Variable "colors" wird mithilfe der Listensyntax deklariert.
List<String> colors = new List<String>();
Alternativ kann die Variable colors mit der Array-Notation deklariert werden.
String[] colors = new List<String>();
Erweitern Sie Sammlungen nach Bedarf, indem Sie mithilfe der Methode List.add() neue Elemente hinzufügen. Sie können die Array-Notation mit eckigen Klammern verwenden, um nach Index auf vorhandene Elemente in der Sammlung zu verweisen. Mithilfe der Array-Notation mit eckigen Klammern können Sie jedoch keine weiteren Elemente hinzufügen.
Dieses Beispiel zeigt, wie Sie einer Liste Elemente hinzufügen, wenn Sie sie erstellen, und dann mithilfe der Methode add() weitere Elemente hinzufügen können.
// Create a list and add elements to it in one step
List<String> colors = new List<String> { 'red', 'green', 'blue' };
// Add elements to a list after it has been created
List<String> moreColors = new List<String>();
moreColors.add('orange');
moreColors.add('purple');Listenelemente können durch Angabe eines Index in eckigen Klammern, die sogenannte Array-Notation, ausgelesen werden. Sie können zum Auslesen eines Listenelements auch die Methode "get()" verwenden. Dieses Beispiel basiert auf den im vorherigen Beispiel erstellten Listen und zeigt, wie Listenelemente mit den beiden Methoden ausgelesen werden. Das Beispiel zeigt außerdem, wie Listenelemente mithilfe einer Schleife durchlaufen werden.
// Get elements from a list
String color1 = moreColors.get(0);
String color2 = moreColors[0];
System.assertEquals(color1, color2);
// Iterate over a list to read elements
System.debug('Print out the colors in moreColors:');
for(String color : moreColors) {
// Write value to the debug log
System.debug(color);
}Über die Grundlagen hinaus
Apex unterstützt zwei weitere Sammlungstypen: "Set" und "Map". Nähere Informationen zu diesen Typen finden Sie im Abschnitt Collections (Sammlungen) im Apex Developer’s Guide.
Apex-Klassen
Einer der Vorteile von Apex-Klassen ist die Wiederverwendung von Code. Klassenmethoden können durch Auslöser und andere Klassen aufgerufen werden. Das folgende Lernprogramm erläutert Schritt für Schritt, wie Sie eine Beispielklasse in Ihrer Organisation speichern, diese Klasse zum Aktualisieren von Account-Beschreibungen verwenden und Debug-Protokolle prüfen.
Speichern einer Apex-Klasse
Die Klasse AccountProcessor verfügt über eine öffentliche Methode updateAccountDescriptions(). Diese Methode nimmt eine Liste von Accounts und aktualisiert deren Beschreibung gemäß dem in der privaten Hilfsmethode applyStandardFormatting() festgelegten Format. Private Hilfsmethoden können nicht extern aufgerufen werden; sie müssen innerhalb der Klasse aufgerufen werden. Die Klasse AccountProcessor enthält außerdem die private Hilfsmethode inspectResults(), die die Ergebnisse des Datenbank-Aktualisierungsvorgangs prüft.
Speichern Sie die Klasse AccountProcessor in Ihrer Trailhead-Organisation.
- Öffnen Sie Web Console (Webkonsole) über das Schnellzugriffsmenü (
).
- Drücken Sie in der Web Console (Webkonsole) Strg+Umschalt+P (Windows) oder ⌘+Shift+P (macOS), um die Command Palette (Befehlspalette) zu öffnen.
- Geben Sie
SFDX: Create Apex Class(SFDX: Apex-Klasse erstellen) ein und drücken Sie die Eingabetaste.
- Wählen Sie als Vorlagentyp DefaultApexClass aus und drücken Sie dann die Eingabetaste.
- Geben Sie als Klassenname
AccountProcessorein und drücken Sie die Eingabetaste.
- Wählen Sie für das Ausgabeverzeichnis force-app/main/default/classes aus und drücken Sie dann die Eingabetaste.
- Ersetzen Sie den Standardtext der Klasse durch das Beispiel für die Klasse
AccountProcessor.
public with sharing class AccountProcessor {
/**
* Applies a standard formatting to the descriptions of accounts in the list,
* and updates each account.
*/
public void updateAccountDescriptions(List<Account> acctList) {
if (acctList == null || acctList.isEmpty()) {
System.debug('Account list is null or empty.');
return;
}
for (Account acc : acctList) {
applyStandardFormatting(acc);
}
Database.SaveResult[] srList = Database.update(acctList,
false,
AccessLevel.USER_MODE);
inspectResults(srList);
}
/**
* Private helper method to handle the description formatting logic.
*/
private static void applyStandardFormatting(Account acc) {
String timestamp = String.valueOf(Datetime.now());
if (String.isBlank(acc.Description)) {
acc.Description = 'Account updated on: ' + timestamp;
} else {
acc.Description += ' | Last processed: ' + timestamp;
}
}
/*
* Private helper method to inspect the returned results.
*/
private static void inspectResults(Database.SaveResult[] results) {
for (Database.SaveResult sr : results) {
if (sr.isSuccess()) {
System.debug('Successfully updated account. Account ID: ' + sr.getId());
} else {
for (Database.Error err : sr.getErrors()) {
System.debug('The following error has occurred.');
System.debug(err.getStatusCode() + ': ' + err.getMessage());
System.debug('Account fields that affected this error: ' +
err.getFields());
}
}
}
}
}- Um Ihre Klasse zu speichern, drücken Sie Strg+S (Windows) oder ⌘+S (macOS).
Beim Speichern kompiliert Salesforce Ihre Klasse und stellt sie bereit.
Über die Grundlagen hinaus
Die eben gespeicherte Klasse verwendet objektorientierte Programmierung (OOP). Die Klasse umfasst die Methoden, die sich auf die Verwaltung von E-Mails beziehen. Um als Musterbeispiel für OOP zu gelten, würde die Klasse zudem Mitgliedsvariablen (Attribute) und Zugriffsmethoden für den Zugriff auf diese Attribute enthalten, der Einfachheit halber weist unsere Klasse diese jedoch nicht auf.
Aufrufen einer Methode zum Aktualisieren einer Account-Beschreibung
Rufen Sie die öffentliche Methode auf. Wir verwenden dazu die Ausführung von anonymem Apex-Code. Mit anonymem Apex-Code können Sie Codezeilen sofort ausführen. Dies ist eine praktische Möglichkeit zum Aufrufen von Apex, insbesondere zum Testen von Funktionen. Wie bei jeder anderen Apex-Ausführung wird auch hier ein Debug-Protokoll mit den Ergebnissen generiert.
- Drücken Sie in der Web Console (Webkonsole) Strg+Umschalt+P (Windows) oder ⌘+Shift+P (macOS), um die Command Palette (Befehlspalette) zu öffnen.
- Geben Sie
SFDX: Create Anonymous Apex Script(SFDX: Anonymes Apex-Skript erstellen) ein und drücken Sie die Eingabetaste.
- Geben Sie als Klassenname
UpdateAccountsein und drücken Sie die Eingabetaste.
- Wählen Sie für das Ausgabeverzeichnis scripts/apex aus und drücken Sie dann die Eingabetaste.
- Geben Sie diesen Code ein:
// Create new accounts
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Second New Account'));
// Insert them into the database
try {
insert as user newAccts;
System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Instantiate an AccountProcessor object
AccountProcessor myAcctProcessor = new AccountProcessor();
// Pass the original list to update the account descriptions
myAcctProcessor.updateAccountDescriptions(newAccts);- Um Ihr Skript zu speichern, drücken Sie Strg+S (Windows) oder ⌘+S (macOS).
- Um das Skript auszuführen, klicken Sie mit der rechten Maustaste in den Texteditor und wählen SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Anonymes Apex mit dem aktuell geöffneten Editor ausführen) aus.
- Öffnen Sie in Salesforce die Datensatz-Detailseiten von "My New Account" (Mein neuer Account) und "My Second New Account" (Mein zweiter neuer Account).
Das Feld "Description" (Beschreibung) von "My New Account" (Mein neuer Account) sollte Original Description | Last processed: 2026-01-01 00:00:00 (Ursprüngliche Beschreibung | Zuletzt bearbeitet am: 2026-01-01 00:00:00) und das Feld "Description" (Beschreibung) von "My Second New Account" (Mein zweiter neuer Account) sollte Account updated on: 2026-01-01 00:00:00 (Account wurde aktualisiert am: 2026-01-01 00:00:00) lauten, wobei beide Zeitstempel den Zeitpunkt und das Datum widerspiegeln, zu dem Sie die anonyme Apex-Transaktion ausgeführt haben.
Prüfen von Debug-Protokollen
Debug-Protokolle sind nützlich zum Debuggen Ihres Codes. Wenn Apex-Methoden ausgeführt werden, werden die Aufrufe im Debug-Protokoll eingetragen. Sie können auch Ihre eigenen Debug-Meldungen ins Protokoll schreiben, was beim Debuggen Ihres Codes hilft, sollten Fehler auftreten. Die Hilfsmethode inspectResults(), die von updateAccountDescriptions() aufgerufen wird, schreibt mithilfe der Methode System.debug() Meldungen ins Protokoll, die angeben, ob der Vorgang zum Aktualisieren der Datenbank erfolgreich war oder Fehler auftraten. Sie können diese Meldungen im Debug-Protokoll einsehen, das generiert wurde, nach Sie die Methode ausgeführt haben.
- Nachdem Sie das UpdateAccounts-Skript in der Web Console (Webkonsole) ausgeführt haben, öffnen Sie den Bereich Output (Ausgabe).
- Wählen Sie Debug Only (Nur Debug) aus, um das Protokoll so zu filtern, dass nur Protokollzeilen für "
System.debug()"-Anweisungen angezeigt werden.
- Geben Sie in das Feld filter (Filter) oben im Bereich "Output" (Ausgabe)
USER_DEBUGein, um das Protokoll so zu filtern, dass nur Protokollzeilen fürSystem.debug()-Anweisungen angezeigt werden.
- Sie können sich auch das Debug-Protokoll im Verzeichnis .sfdx/tools/debug/logs ansehen.

In der gefilterten Protokollansicht werden folgende Meldungen angezeigt, vorausgesetzt, das Skript wurde ohne Fehler ausgeführt.
DEBUG|Successfully inserted 2 accounts.
DEBUG|Successfully updated account. Account ID: {id}
DEBUG|Successfully updated account. Account ID: {id}Aufrufen einer statischen Methode
Da die Methode updateAccountDescriptions() in unserer Klasse auf keine Klassenmitgliedsvariablen zugreift, muss es sich nicht um eine Instanzmethode handeln. Ändern Sie sie in eine statische Methode, indem Sie das Schlüsselwort "static" zu ihrer Deklaration hinzufügen. Statische Methoden können leichter aufgerufen werden als Instanzmethoden, da sie nicht für eine Instanz der Klasse aufgerufen werden müssen, sondern direkt für den Klassennamen aufgerufen werden.
- Öffnen Sie in der Web Console (Webkonsole) die Klassendatei
AccountProcessor.cls.
- Ändern Sie die erste Zeile der Definition von
updateAccountDescriptions(). Als einzige Änderung wird das Schlüsselwortstatichinzugefügt.
public static void updateAccountDescriptions(List<Account> acctList) {- Um Ihre Klasse zu speichern, drücken Sie Strg+S (Windows) oder ⌘+S (macOS). Die Klasse wird beim Speichern neu bereitgestellt.
- Öffnen Sie die anonyme Apex-Skriptdatei
UpdateAccounts.apex.
- Ersetzen Sie den aktuellen Code durch den folgenden Code, damit das Skript die statische Methode über den Klassennamen aufruft.
// Create new accounts
// For clarity, use different account names than the ones you used previously
List<Account> newAccts = new List<Account>();
newAccts.add(new Account(Name='My Third New Account', Description='Original Description'));
newAccts.add(new Account(Name='My Fourth New Account'));
// Insert them into the database
try {
insert as user newAccts;
System.debug('Successfully inserted ' + newAccts.size() + ' accounts.');
} catch (Exception e) {
System.debug('An error inserting the records occurred: ' + e.getMessage());
}
// Pass the original list to update the account descriptions
// The static method is called directly on the class
AccountProcessor.updateAccountDescriptions(newAccts);- Um Ihr Skript zu speichern, drücken Sie Strg+S (Windows) oder ⌘+S (macOS).
- Um das Skript auszuführen, klicken Sie mit der rechten Maustaste in den Texteditor und wählen SFDX: Execute Anonymous Apex with Currently Open Editor (SFDX: Anonymes Apex mit dem aktuell geöffneten Editor ausführen) aus. Nachdem diese Methode ausgeführt wurde, können Sie die aktualisierten Account-Beschreibungen in Salesforce überprüfen und optional auch das Debug-Protokoll wie in den vorherigen Schritten.
Ressourcen
- Apex Developer Guide: Introducing Apex
- Apex Developer Guide: Schleifen
- Salesforce Developers: Verwenden von anonymem Apex
- Web Console (Webkonsole): Debuggen von Apex-Code
