Erstellen von SOQL-Abfragen in Apex-Klassen

Lernziele

Nachdem Sie diese Lektion abgeschlossen haben, sind Sie in der Lage, die folgenden Aufgaben auszuführen:

Erstellen einer SOQL-Abfrage in einer Methode
Bearbeiten der von einer SOQL-Abfrage zurückgegebenen Daten

Hinweis

Lernen Sie auf Deutsch? Beginnen Sie die Aufgabe in einem Trailhead Playground in der Sprache Deutsch und verwenden Sie für die Navigation die in Klammern angegebenen Übersetzungen. Kopieren und fügen Sie nur die Angaben in Englisch ein, da zur Überprüfung der Aufgabe Daten in Englisch benötigt werden. Wenn Sie die Aufgabe in Ihrer deutschen Organisation nicht bestehen, empfehlen wir Ihnen folgende Vorgehensweise: (1) Stellen Sie das Gebietsschema auf USA um, (2) legen Sie Englisch als Sprache fest (Anweisungen dazu finden Sie hier) und (3) klicken Sie erneut auf die Schaltfläche "Check Challenge" (Aufgabe überprüfen).

Weitere Details dazu, wie Sie die übersetzte Trailhead-Umgebung optimal nutzen können, finden Sie unter dem Badge "Trailhead in Ihrer Sprache".

Mit Trail Together einem Dozenten folgen

Möchten Sie bei diesem Schritt einem Experten folgen? Schauen Sie sich dieses Video an, das Teil der Reihe "Trail Together" auf Trailhead Live ist.

(Dieser Clip beginnt bei Minute 17:32, für den Fall, dass Sie zurückspringen und den Anfang des Schritts noch einmal sehen möchten.)

Einführung

Nachdem Sie sich mit den Grundzügen einer SOQL-Abfrage vertraut gemacht haben, können Sie nun Ihr Wissen über Formelfelder auf SOQL-Abfragen anwenden.

Unsere Abfrage ist ziemlich einfach: SELECT FirstName, LastName FROM Contact

Wir benötigen nun ein Objekt, in dem wir die resultierenden Daten speichern können. Da SOQL-Abfragen Daten stets in Form einer Liste zurückgeben, erstellen wir eine Apex-Liste. Wie Sie in Apex – Grundlagen für Administratoren gelernt haben, benötigen Sie zum Deklarieren einer Liste ein paar Dinge: das reservierte Wort List, den Datentyp (in < >-Zeichen) und einen Namen für die neue Liste. Für diese Abfrage ist der Datentyp "Contact" und wir nennen die neue Liste listOfContacts. Die Deklaration der Liste sieht wie folgt aus:

List<Contact> listofContacts

Um die Ergebnisse der Abfrage der neuen Liste zuzuweisen, setzen wir einen Zuweisungsoperator, das Gleichheitszeichen ( = ), zwischen Listendeklaration und Abfrage, etwa so:

List<Contact> listofContacts = [SELECT FirstName, LastName FROM Contact];

Beachten Sie die Syntax. Die Abfrage ist in eckigen Klammern [ ] eingeschlossen, die Anweisung endet mit einem Semikolon ( ; ).

Lassen Sie uns das jetzt in der Developer Console ausprobieren. Zu Testzwecken übermitteln wir die Liste der Kontakte an das Debug-Protokoll, damit wir uns ansehen können, wie der Code funktioniert.

Testen des Codes in der Developer Console

Klicken Sie in der Developer Console auf Debug | Open Execute Anonymous Window (Debuggen | Fenster für die anonyme Ausführung öffnen).
Weisen Sie im Fenster "Execute Anonymous" (Anonym ausführen) die Ergebnisse der Abfrage der neuen Liste zu:
```
List<Contact> listOfContacts = [SELECT FirstName, LastName FROM Contact LIMIT 2];
```
Übermitteln Sie in der nächsten Zeile die Liste listOfContacts an das Debug-Protokoll:
```
system.debug(listOfContacts);
```
Aktivieren Sie das Kontrollkästchen Open Log (Protokoll öffnen).
Klicken Sie auf Execute (Ausführen).
Aktivieren Sie unten im Fenster "Execution Log" (Ausführungsprotokoll) das Kontrollkästchen Debug Only (Nur debuggen).
Die ersten beiden Einträge im Debug-Protokoll sollten wie folgt aussehen:
Falls eine Abfrage keine Ergebnisse findet, wird dennoch eine Liste zurückgegeben, die allerdings leer ist:

[2]|DEBUG|()

Was passiert hier eigentlich?

SELECT FirstName, LastName FROM Contact LIMIT 2 mit einem Pfeil, der auf das Symbol des Objekts 'Contact' in einer Wolke zeigt. Ein zweiter Pfeil, der der Abfrage entsprechende Daten an die Apex-Klasse übermittelt, zeigt auf eine Liste mit Kontakten. 1. FirstName = Rose, LastName = Gonzalez. 2. FirstName = Sean, LastName = Forbes.

Wenn unser Code ausgeführt wird, verarbeitet er zunächst die Abfrage:

SELECT FirstName, LastName FROM Contact LIMIT 2

Die Abfrage findet alle Kontakte und ruft aus jedem Datensatz den Vor- und Nachnamen ab. Dann fügt unser Code die ausgewählten Daten aus diesen Kontaktdatensätzen in eine Liste namens listOfContacts ein.

Schließlich wird in Zeile 2 in System.debug der Inhalt von listOfContacts angezeigt.

Ausführen von SOQL-Abfragen in Apex

In der vorherigen Einheit haben Sie mithilfe des Abfrage-Editors Daten in einer Tabelle zurückgegeben. In dieser Einheit haben Sie im Fenster "Execute Anonymous" (Anonym ausführen) eine Abfrage ausgeführt und die Ergebnisse an das Debug-Protokoll übermittelt. Das ist im Moment zwar prima, aber Ihre Benutzer werden Abfragen wohl kaum in der Developer Console durchführen. Sie benötigen eine Möglichkeit, Daten auf der Benutzeroberfläche Ihrer Organisation zurückzugeben. Dazu dienen Apex-Klassen und -Methoden. Sehen wir uns an, wie Sie eine SOQL-Abfrage ausführen und ihre Ergebnisse in Apex bearbeiten können.

Wir beginnen mit dem Erstellen einer Apex-Methode in einer Apex-Klasse. Die Apex-Methode führt unsere Abfrage zum Auswählen der gewünschten Daten aus.

Klicken Sie in der Developer Console auf File (Datei) | New (Neu) | Apex Class (Apex-Klasse).
Nennen Sie die Klasse ContactUtility und klicken Sie auf OK.
Die Klasse wird geöffnet, zeigt den Code zum Deklarieren der Klasse an und lässt Platz für den Rumpf der Klasse.
Fügen Sie in Zeile 2 eine Methode namens viewContacts hinzu.
```
public static void viewContacts(){
}
```
Fügen Sie in Zeile 3 innerhalb der Methode viewContacts den Code zum Ausführen der Abfrage und zum Zuweisen der Ergebnisse zu einer neuen Liste ein:
```
List<Contact> listOfContacts = [SELECT FirstName, LastName FROM Contact];
```
Speichern Sie die Klasse.

Jetzt befinden sich die gewünschten Daten in der Liste listOfContacts. Wir verwenden eine FOR-Schleife, um durch die Liste zu iterieren und das gewünschte Format für unsere Ausgabe zu erstellen.

Verwenden einer FOR-Schleife zum Iterieren durch eine Liste

In Objektorientierte Programmierung für Administratoren haben Sie gelernt, wie Sie die Elemente einer Liste mithilfe einer FOR-Schleife nacheinander verarbeiten können. Hier kombinieren wir in einer FOR-Schleife den Vor- und Nachnamen jedes Kontakts, um den vollständigen Namen des Kontakts zu erhalten. Lassen Sie uns zunächst die Schleife erstellen und dann jeden Datensatz innerhalb der Schleife verarbeiten.

Zum Deklarieren einer FOR-Schleife benötigen wir den Namen einer Variablen, ihren Datentyp und den Namen der Liste, durch die die Schleife iteriert.

In einer FOR-Schleife verweisen wir nicht direkt auf bestimmte Objekte. Stattdessen erstellen wir eine Variable, die die Listenelemente innerhalb der Schleife nacheinander darstellt. Die Variable dient als Platzhalter für jedes Element in der Liste. Sie können jeden beliebigen Namen wählen, aber wir möchten das Ganze einfach halten. Wir verwenden con. Dann benötigen wir den Datentyp der Variablen, nämlich "Contact", und den Namen der Liste, nämlich listOfContacts. Zusammengefasst sieht das so aus:

for (Contact con : listOfContacts){ //Schleifenrumpf}

Deklarieren einer FOR-Schleife

Fügen Sie in der Methode viewContacts hinter der SOQL-Abfrage diesen Code ein:
```
for (Contact con : listOfContacts){
    //loop body
}
```
Speichern Sie die Klasse.

Wir haben die Datenbank abgefragt (1), Daten ausgewählt, die Daten in einer Liste gespeichert (2) und eine FOR-Schleife erstellt (3).

1. Die Abfrage, Select FirstName, LastName FROM Contact LIMIT 2, füllt die Liste listOfContacts (2). 3. Die FOR-Schleife, die die Kontakte in der Liste listOfContacts verarbeitet: for(Contact con : listOfContacts){ //Logik hier platzieren}

Als Nächstes verarbeiten wir innerhalb der Schleife die Einträge in der Liste. Schließlich möchten wir jeden Kontakt in listOfContacts in diesem Format anzeigen:

First Name:<contact's first name>, Last Name: <contact's last name> (Vorname:<Vorname des Kontakts>, Nachname: <Nachname des Kontakts>)

Um auf ein Feld eines Elements in einer Liste zu verweisen, verwenden Sie die Punktnotation, um das Objekt und sein Feld anzugeben (Objekt.Feld). Beispielsweise verweisen Sie auf das Feld FirstName des Objekts "Contact" in der Liste listOfContacts, indem Sie einen Punkt zwischen "con" (Objektvariable) und "FirstName" (Feld) setzen, etwa so:

con.FirstName

Die Liste enthält separate Felder für den Vor- und Nachnamen. In Apex kombinieren wir Feldwerte (und mitunter auch Literaltext) mithilfe von Verkettung. (In Apex – Grundlagen für Administratoren haben Sie die Verkettung bereits kennengelernt.)

Beim Verketten werden die Felddaten als Objekt.Feld dargestellt. Literaltext wird in einfache Anführungszeichen gesetzt. Vergessen Sie nicht, bei Bedarf Leerzeichen am Anfang und Ende des Literaltexts einzufügen. Verwenden Sie das Pluszeichen ( + ), um Felder zu kombinieren oder um ein Feld und Literaltext zu kombinieren.

Lassen Sie uns den Rumpf unserer FOR-Schleife ausfüllen. Zunächst kombinieren wir für jedes Element in der Liste listOfContacts "FirstName" und "LastName" in einer neuen Variablen namens "fullName":

String fullName = 'First Name: ' + con.FirstName + ', Last Name: ' + con.LastName;

Beachten Sie das Leerzeichen zwischen FirstName und LastName. Die Ausgabe sollte so aussehen:

First Name: Angela, Last Name: Carter

nicht

FirstName:Angela,LastName:Carter

Nachdem der Wert für die Variable fullName (Datentyp: String) zugewiesen wurde, fügen wir diese Variable in die Debug-Anweisung in der nächsten Zeile ein:

system.debug(fullName);

Verarbeiten von Listenelementen in der FOR-Schleife

Ersetzen Sie in der Methode viewContacts //loop body durch diesen Code:

String fullName = 'First Name: ' + con.FirstName + ', Last Name: ' + con.LastName;
system.debug(fullName);

Speichern Sie die Klasse.

Ihr Code sollte wie folgt aussehen:

public class ContactUtility {
    public static void viewContacts(){
        List<Contact> listOfContacts = [SELECT FirstName, LastName FROM Contact];
        for (Contact con : listOfContacts){
            String fullName = 'First Name: ' + con.FirstName + ', Last Name: ' + con.LastName;
            system.debug(fullName);
        }
    }
}

Wir verfügen nun über eine Klasse, Methode und SOQL-Abfrage. Lassen Sie uns den Code ausführen und sehen, ob er funktioniert. Um Apex-Code im Fenster "Execute Anonymous" (Anonym ausführen) auszuführen, geben wir die Klasse und Methode mittels Punktnotation an.

Öffnen Sie das Fenster "Execute Anonymous" (Anonym ausführen).
Ersetzen Sie im Fenster "Enter Apex Code" (Apex-Code eingeben) den vorhandenen Code durch diesen Code:
```
ContactUtility.viewContacts();
```
Vergewissern Sie sich, dass Open Log (Protokoll öffnen) aktiviert ist
Klicken Sie auf Execute (Ausführen).
Wählen Sie Debug Only (Nur debuggen) aus.

Die ersten sechs Zeilen Ihrer Ergebnisse sollten wie folgt lauten:

Ausführungsprotokoll
Ereignis	Details
USER_DEBUG	[5]\|DEBUG\|First Name: Rose, Last Name: Gonzalez
USER_DEBUG	[5]\|DEBUG\|First Name: Sean, Last Name: Forbes
USER_DEBUG	[5]\|DEBUG\|First Name: Jack, Last Name: Rogers
USER_DEBUG	[5]\|DEBUG\|First Name: Pat, Last Name: Stumuller
USER_DEBUG	[5]\|DEBUG\|First Name: Andy, Last Name: Young
USER_DEBUG	[5]\|DEBUG\|First Name: Tim, Last Name: Barr

Sehen Sie sich das an! Mithilfe von SOQL, einer FOR-Schleife und Verkettung haben Sie Kontaktdaten abgerufen, die Daten einer Liste zugewiesen, die Liste iteriert und die erwarteten Ergebnisse generiert. Gut gemacht!

Benötigen Sie Hilfe?

Mehr entdecken