Apex-Webservices

Lernziele

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

Beschreiben der beiden Typen von Apex-Webservices und Bereitstellen eines allgemeinen Überblicks über diese Services
Erstellen einer Apex-REST-Klasse mit Methoden für jede HTTP-Methode
Aufrufen einer benutzerdefinierten Apex-REST-Methode mit einem Endpunkt
Übergeben von Daten an eine benutzerdefinierte Apex-REST-Methode durch Senden eines Anforderungstexts im JSON-Format
Schreiben einer Apex-REST-Methode und Festlegen von Eigenschaften in einer REST-Testanforderung
Schreiben einer Apex-REST-Methode durch Aufrufen der Methode mit Parameterwerten

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 01:07:03, für den Fall, dass Sie zurückspringen und den Anfang des Schritts noch einmal sehen möchten.)

Verfügbarmachen Ihrer Apex-Klasse als Webservice

Sie können Ihre Apex-Klassenmethoden als REST- oder SOAP-Webservicevorgang verfügbar machen. Indem Sie Ihre Methoden über das Web aufrufbar machen, können Ihre externen Anwendungen in Salesforce integriert werden, um alle Arten von ausgetüftelten Vorgängen auszuführen.

Angenommen, das Callcenter Ihres Unternehmens nutzt eine interne Anwendung zum Verwalten lokaler Ressourcen. Von Mitarbeitern des Kundensupports wird erwartet, dass sie dieselbe Anwendung zum Erledigen ihrer täglichen Arbeit nutzen, einschließlich der Verwaltung von Kundenvorgangs-Datensätzen in Salesforce. Auf einer Oberfläche können Mitarbeiter Kundenvorgangs-Datensätze anzeigen und aktualisieren sowie auf interne Ressourcen zugreifen. Die Anwendung ruft eine Apex-Webserviceklasse zum Verwalten von Salesforce-Kundenvorgangs-Datensätzen auf.

Verfügbarmachen einer Klasse als REST-Service

Das Verfügbarmachen Ihrer Apex-Klasse als REST-Webservice ist ganz einfach. Definieren Sie Ihre Klasse als "global" und Methoden als "global static". Fügen Sie der Klasse und den Methoden Anmerkungen hinzu. Beispiel: Diese Apex-REST-Beispielklasse nutzt eine Methode. Die getRecord-Methode ist ein benutzerdefinierter REST-API-Aufruf. Sie ist mit der Anmerkung @HttpGet versehen und wird für eine GET-Anforderung aufgerufen.

@RestResource(urlMapping='/Account/*')
global with sharing class MyRestResource {
    @HttpGet
    global static Account getRecord() {
        // Add your code
    }
}

Wie Sie erkennen können, ist die Klasse mit der Anmerkung @RestResource(urlMapping='/Account/*) versehen. Der Basisendpunkt für Apex-REST ist https://yourInstance.my.salesforce.com/services/apexrest/. Die URL-Zuordnung wird an den Basisendpunkt angefügt, um den Endpunkt für Ihren REST-Service zu bilden. Beim Klassenbeispiel lautet der REST-Endpunkt https://yourInstance.my.salesforce.com/services/apexrest/. Für Ihre Organisation könnte er z. B. https://yourInstance.my.salesforce.com/services/apexrest/Account/* lauten.

Wenn Sie in diesem Modul in Links oder Code "yourInstance" sehen, müssen Sie dies durch Ihre Salesforce-Organisation ersetzen.

Bei der URL-Zuordnung wird Groß- und Kleinschreibung berücksichtigt und sie darf Platzhalterzeichen (*) enthalten.

Definieren Sie jede verfügbar gemachte Methode als global static und fügen Sie eine Anmerkung hinzu, um sie einer HTTP-Methode zuzuordnen. Die folgenden Anmerkungen stehen zur Verfügung. Sie können in jeder Apex-Klasse jede Anmerkung nur einmal verwenden.

Anmerkung	Aktion	Details
`@HttpGet`	Lesen	Dient zum Lesen oder Abrufen von Datensätzen.
`@HttpPost`	Erstellen	Dient zum Erstellen von Datensätzen.
`@HttpDelete`	Löschen	Dient zum Löschen von Datensätzen.
`@HttpPut`	Aktualisieren und einfügen	Dient zumeist zum Aktualisieren vorhandener Datensätze oder Erstellen neuer Datensätze.
`@HttpPatch`	Aktualisieren	Dient zumeist zum Aktualisieren von Feldern in vorhandenen Datensätzen.

Verfügbarmachen einer Klasse als SOAP-Service

Das Verfügbarmachen Ihrer Apex-Klasse als SOAP-Webservice ist ebenso einfach wie bei REST. Definieren Sie Ihre Klasse als global. Fügen Sie jeder Methode, die Sie verfügbar machen möchten, das Schlüsselwort webservice und den Definitionsmodifizierer static hinzu. Das Schlüsselwort webservice ermöglicht den globalen Zugriff auf die Methode, der es hinzugefügt wird.

Hier ist eine Beispielklasse mit einer Methode. Die getRecord-Methode ist ein benutzerdefinierter SOAP-API-Aufruf, der einen Accountdatensatz zurückgibt.

global with sharing class MySOAPWebService {
    webservice static Account getRecord(String id) {
        // Add your code
    }
}

Die externe Anwendung kann Ihre benutzerdefinierten Apex-Methoden als Webservice-Vorgänge aufrufen, indem die WSDL-Datei der Klasse genutzt wird. Generieren Sie diese WSDL-Datei für Ihre Klasse auf der Seite mit den Klassendetails, auf die in Setup über die Seite "Apex-Klassen" zugegriffen wird. Sie senden die WSDL-Datei in der Regel an externe Entwickler (oder nutzen Sie selbst), um Integrationen für Ihren Webservice zu schreiben.

Da die Sicherheit der Plattform bei Salesforce oberste Priorität hat, fordert Ihr Webservice eine Authentifizierung an. Zusätzlich zur WSDL der Apex-Klasse müssen externe Anwendungen entweder die Unternehmens-WSDL oder Partner-WSDL für die Anmeldefunktionalität verwenden.

Schrittweise Anleitung für Apex REST

Jetzt endlich zu den interessanten Dingen. In den nächsten Schritten durchlaufen Sie den Prozess zum Erstellen eines Apex-REST-Service. Zuerst erstellen Sie die Apex-Klasse, die als REST-Service verfügbar gemacht wird. Dann versuchen Sie, vom Client aus einige Methoden aufzurufen, und schreiben schließlich Einheitentests. Das ist ganz schön viel Code, doch es lohnt sich unbedingt!

Ihre Apex-Klasse dient zum Verwalten von Kundenvorgangs-Datensätzen. Die Klasse enthält fünf Methoden, von denen jede einer HTTP-Methode entspricht. Wenn beispielsweise die Clientanwendung einen REST-Aufruf der HTTP-Methode GET auslöst, wird die getCaseById-Methode aufgerufen.

Da die Klasse mit der URL-Zuordnung /Cases/* definiert ist, ist der Endpunkt zum Aufrufen dieses REST-Service ein beliebiger URI, der mit https://yourInstance.my.salesforce.com/services/apexrest/Cases/ beginnt.

Wir schlagen außerdem eine Versionsverwaltung für Ihre API-Endpunkte vor, damit Sie Funktionalität aktualisieren können, ohne vorhandenen Code zu stören. Zum Implementieren dieser Funktionalität können Sie zwei Klassen mit den URL-Zuordnungen /Cases/v1/* und /Cases/v2/* erstellen.

Lassen Sie uns hierfür mit dem Erstellen einer Apex-REST-Klasse beginnen.

Klicken Sie auf das Setup-Zahnradsymbol () und wählen Sie "Developer Console (Entwicklerkonsole)" aus.
Klicken Sie in der Developer Console auf File (Datei) | New (Neu) | Apex Class (Apex-Klasse).
Geben Sie als Klassennamen CaseManager ein und klicken Sie auf OK.

Ersetzen Sie den automatisch generierten Code durch die folgende Klassendefinition.

@RestResource(urlMapping='/Cases/*')
global with sharing class CaseManager {
    @HttpGet
    global static Case getCaseById() {
        RestRequest request = RestContext.request;
        // grab the caseId from the end of the URL
        String caseId = request.requestURI.substring(
          request.requestURI.lastIndexOf('/')+1);
        Case result =  [SELECT CaseNumber,Subject,Status,Origin,Priority
                        FROM Case
                        WHERE Id = :caseId];
        return result;
    }
    @HttpPost
    global static ID createCase(String subject, String status,
        String origin, String priority) {
        Case thisCase = new Case(
            Subject=subject,
            Status=status,
            Origin=origin,
            Priority=priority);
        insert thisCase;
        return thisCase.Id;
    }
    @HttpDelete
    global static void deleteCase() {
        RestRequest request = RestContext.request;
        String caseId = request.requestURI.substring(
            request.requestURI.lastIndexOf('/')+1);
        Case thisCase = [SELECT Id FROM Case WHERE Id = :caseId];
        delete thisCase;
    }
    @HttpPut
    global static ID upsertCase(String subject, String status,
        String origin, String priority, String id) {
        Case thisCase = new Case(
                Id=id,
                Subject=subject,
                Status=status,
                Origin=origin,
                Priority=priority);
        // Match case by Id, if present.
        // Otherwise, create new case.
        upsert thisCase;
        // Return the case ID.
        return thisCase.Id;
    }
    @HttpPatch
    global static ID updateCaseFields() {
        RestRequest request = RestContext.request;
        String caseId = request.requestURI.substring(
            request.requestURI.lastIndexOf('/')+1);
        Case thisCase = [SELECT Id FROM Case WHERE Id = :caseId];
        // Deserialize the JSON string into name-value pairs
        Map<String, Object> params = (Map<String, Object>)JSON.deserializeUntyped(request.requestbody.tostring());
        // Iterate through each parameter field and value
        for(String fieldName : params.keySet()) {
            // Set the field and value on the Case sObject
            thisCase.put(fieldName, params.get(fieldName));
        }
        update thisCase;
        return thisCase.Id;
    }
}

Drücken Sie STRG+S, um zu speichern.

Erstellen eines Datensatzes mit einer POST-Methode

Lassen Sie uns mit der Apex-REST-Klasse arbeiten, die Sie zuvor erstellt haben. Zuerst rufen wir die POST-Methode zum Erstellen eines Kundenvorgangs-Datensatzes auf.

Zum Aufrufen Ihres REST-Service müssen Sie natürlich einen REST-Client verwenden! Sie können den REST-Client Ihrer Wahl nutzen, z. B. Ihren eigenen API-Client, das Befehlszeilentool cURL oder die cURL-Bibliothek für PHP. Wir nutzen das Tool Workbench als unsere REST-Clientanwendung.

Apex REST unterstützt zwei Formate zur Darstellung von Ressourcen: JSON und XML. JSON-Darstellungen werden standardmäßig im Text einer Anforderung oder Antwort übergeben. Ihr Format wird von der Content-Type-Eigenschaft im HTTP-Header angegeben. Da JSON einfacher zu lesen und zu verstehen ist als XML, kommt in dieser Einheit ausschließlich JSON zum Einsatz. In diesem Schritt senden Sie einen Kundenvorgangs-Datensatz im JSON-Format.

Apex REST unterstützt OAuth 2.0 und Sitzungsauthentifizierungsmechanismen. Das heißt einfach gesagt, dass wir Branchenstandards nutzen können, um Ihre Anwendung und Daten sicher zu halten. Zum Glück können wir mit Workbench unsere Tests vereinfachen. Workbench ist eine leistungsstarke, webbasierte Sammlung von Tools für Administratoren und Entwickler zur Interaktion mit Organisationen über Lightning Platform-APIs. Bei Verwenden von Workbench nutzen Sie die Sitzungsauthentifizierung beim Anmelden bei Salesforce mit Ihrem Benutzernamen und Kennwort. Mit dem REST Explorer rufen Sie Ihren REST-Service auf.

navigieren Sie dann zu https://workbench.developerforce.com/login.php.
Wählen Sie als Umgebung Production aus.
Wählen Sie in der Dropdown-Liste API Version die neueste API-Version aus.

Möglicherweise müssen Sie eine andere API-Version auswählen, wenn die neueste Version Probleme aufweist.

Akzeptieren Sie die Bedingungen des Dienstes und klicken Sie auf Login with Salesforce.
Um der Workbench Zugang zu Ihren Informationen zu gewähren, klicken Sie auf Allow.
Geben Sie Ihre Anmeldeinformationen ein und klicken Sie auf Log in to Salesforce (Bei Salesforce anmelden).
Wählen Sie nach dem Anmelden utilities | REST Explorer (Dienstprogramme -> REST Explorer) aus.
Wählen Sie POST aus.
Der URL-Pfad, den REST Explorer akzeptiert, ist relativ zur Instanz-URL Ihrer Organisation. Geben Sie nur den Pfad an, der an den Instanz-URL angefügt wird. Ersetzen Sie im Eingabefeld für den relativen URI den Standard-URI durch /services/apexrest/Cases/.
Fügen Sie als Anforderungstext die folgende JSON-Zeichenfolgendarstellung des einzufügenden Objekts ein.
```
{
  "subject" : "Bigfoot Sighting!",
  "status" : "New",
  "origin" : "Phone",
  "priority" : "Low"
}
```
Klicken Sie auf Execute (Ausführen).
Durch diesen Aufruf wird die Methode aufgerufen, die der HTTP-Methode POST zugeordnet ist, nämlich die createCase-Methode.
Wenn Sie die zurückgegebene Antwort sehen möchten, klicken Sie auf Show Raw Response (Rohantwort anzeigen).
Die zurückgegebene Antwort sieht in etwa so aus. Die Antwort enthält die ID des neuen Kundenvorgangs-Datensatzes. Ihr ID-Wert ist wahrscheinlich anders als 50061000000t7kYAAQ. Speichern Sie Ihren ID-Wert, den Sie in den nächsten Schritten benötigen.
```
HTTP/1.1 200 OK
Date: Wed, 07 Oct 2015 14:18:20 GMT
Set-Cookie: BrowserId=F1wxIhHPQHCXp6wrvqToXA;Path=/;Domain=.salesforce.com;Expires=Sun, 06-Dec-2015 14:18:20 GMT
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Content-Type: application/json;charset=UTF-8
Content-Encoding: gzip
Transfer-Encoding: chunked
"50061000000t7kYAAQ"
```

Abrufen von Daten mit einer benutzerdefinierten GET-Methode

Führen Sie in Workbench ähnliche Schritte wie zuvor aus, um die HTTP-Methode GET aufzurufen.

Wählen Sie in Workbench GET aus.
Geben Sie den URI /services/apexrest/Cases/<Record ID> ein und ersetzen Sie Record ID> durch die ID des Datensatzes, den Sie im vorherigen Schritt erstellt haben.
Klicken Sie auf Execute (Ausführen). Durch diesen Aufruf wird die Methode aufgerufen, die der HTTP-Methode GET zugeordnet ist, nämlich die getCaseById-Methode.

Wenn Sie die zurückgegebene Antwort sehen möchten, klicken Sie auf Show Raw Response (Rohantwort anzeigen).
Die zurückgegebene Antwort sieht in etwa so aus. Die Antwort enthält die Felder, die die Methode im neuen Kundenvorgangs-Datensatz abgefragt hat.

HTTP/1.1 200 OK
Date: Wed, 07 Oct 2015 14:28:20 GMT
Set-Cookie: BrowserId=j5qAnPDdRxSu8eHGqaRVLQ;Path=/;Domain=.salesforce.com;Expires=Sun, 06-Dec-2015 14:28:20 GMT
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Content-Type: application/json;charset=UTF-8
Content-Encoding: gzip
Transfer-Encoding: chunked
{
  "attributes" : {
    "type" : "Case",
    "url" : "/services/data/v34.0/sobjects/Case/50061000000t7kYAAQ"
  },
  "CaseNumber" : "00001026",
  "Subject" : "Bigfoot Sighting!",
  "Status" : "New",
  "Origin" : "Phone",
  "Priority" : "Low",
  "Id" : "50061000000t7kYAAQ"
}

Aktualisieren von Daten mit einer benutzerdefinierten PUT- oder PATCH-Methode

Sie können Datensätze mit den HTTP-Methoden PUT und PATCH aktualisieren. Die PUT-Methode dient zum Aktualisieren der gesamten Ressource, sofern vorhanden, oder Erstellen der Ressource, falls nicht vorhanden. PUT ist im Wesentlichen eine sog. Upsert-Methode (Update/Insert; dt. Aktualisieren/Einfügen). Die PATCH-Methode aktualisiert nur die angegebenen Teile einer vorhandenen Ressource. In Apex werden von Aktualisierungsvorgängen nur die angegebenen Felder aktualisiert, ohne dass der gesamte Datensatz überschrieben wird. Wir schreiben Apex-Code, um zu bestimmen, ob bei unseren Methoden ein Aktualisierungs- oder Upsert-Vorgang erfolgt.

Aktualisieren von Daten mit der PUT-Methode

Die upsertCase-Methode, die Sie der CaseManager-Klasse hinzugefügt haben, implementiert die PUT-Aktion. Diese Methode ist hier zu Referenzzwecken aufgeführt. Die Methode nutzt die integrierte Apex-DML-Methode upsert entweder zum Erstellen oder Überschreiben von Kundenvorgangsfeldern, indem ein Abgleich mit dem ID-Wert erfolgt. Wird eine ID im Text der Anforderung gesendet, wird das sObject des Kundenvorgangs damit aufgefüllt. Andernfalls wird das sObject des Kundenvorgangs ohne ID erstellt. Die upsert-Methode wird mit dem aufgefüllten sObject des Kundenvorgangs aufgerufen und die DML-Anweisung übernimmt den Rest. Voilà!

@HttpPut
global static ID upsertCase(String subject, String status,
    String origin, String priority, String id) {
    Case thisCase = new Case(
        Id=id,
        Subject=subject,
        Status=status,
        Origin=origin,
        Priority=priority);
    // Match case by Id, if present.
    // Otherwise, create new case.
    upsert thisCase;
    // Return the case ID.
    return thisCase.Id;
}

So rufen Sie die PUT-Methode auf:

Wählen Sie in Workbench REST Explorer PUT aus.
Geben Sie als URI /services/apexrest/Cases/ ein.
Die upsertCase-Methode erwartet, dass die Feldwerte an den Anforderungstext übergeben werden. Fügen Sie Folgendes als Anforderungstext hinzu und ersetzen Sie <Record ID> durch die ID des Kundenvorgang-Datensatzes, den Sie zuvor erstellt haben.
```
{
  "id": "<Record_ID>",
  "status" : "Working",
  "subject" : "Bigfoot Sighting!",
  "priority" : "Medium"
}
```

Die Feld "ID" ist optional. Lassen Sie zum Erstellen eines Kundenvorgang-Datensatzes dieses Feld weg. In unserem Beispiel übergeben Sie dieses Feld, da Sie den Kundenvorgang-Datensatz aktualisieren möchten.

Klicken Sie auf Execute (Ausführen).
Diese Anforderung ruft die upsertCase-Methode in Ihrem REST-Service auf. Die Felder "Status", "Subject" und "Priority" werden aktualisiert. Der Betreff wird aktualisiert, obwohl sein Wert dem alten Betreff entspricht. Auch weil der Anforderungstext keinen Wert für das Feld "Case Origin" enthielt, ist der origin-Parameter in der upsertCase-Methode NULL. Deshalb wird das Feld "Origin" bei einer Aktualisierung des Datensatzes geleert. Zum Überprüfen dieser Felder zeigen Sie diesen Datensatz in Salesforce an, indem Sie zu https://yourInstance.my.salesforce.com/<Datensatz-ID> navigieren.

Aktualisieren von Daten mit der PATCH-Methode

Nutzen Sie die PATCH-Methode als Alternative zur PUT-Methode zum Aktualisieren von Datensatzfeldern. Sie können die PATCH-Methode auf unterschiedliche Weisen implementieren. Eine Möglichkeit ist das Angeben von Parametern in der Methode für alle zu aktualisierenden Felder. Sie können z. B. eine Methode erstellen, um die Priorität eines Kundenvorgangs mithilfe dieser Signatur zu aktualisieren: updateCasePriority(String priority). Um mehrere Felder zu aktualisieren, können Sie alle gewünschten Felder als Parameter auflisten.

Ein anderer Ansatz mit mehr Flexibilität ist das Übergeben der Felder als JSON-Name-Wert-Paare im Anforderungstext. Auf diese Weise kann die Methode eine beliebige Anzahl von Parametern akzeptieren, wobei die Parameter in der Signatur der Methode nicht festgesetzt werden. Ein weiterer Vorteil dieses Ansatzes ist, dass kein Feld versehentlich geleert wird, weil es nicht Bestandteil der JSON-Zeichenfolge ist. Die updateCaseFields-Methode, die Sie der CaseManager-Klasse hinzugefügt haben, befolgt diesen zweiten Ansatz. Die Methode deserialisiert die JSON-Zeichenfolge aus dem Anforderungstext in eine Zuordnung von Name-Wert-Paaren und verwendet die put-Methode des sObjects zum Festlegen der Felder.

@HttpPatch
global static ID updateCaseFields() {
    RestRequest request = RestContext.request;
    String caseId = request.requestURI.substring(
        request.requestURI.lastIndexOf('/')+1);
    Case thisCase = [SELECT Id FROM Case WHERE Id = :caseId];
    // Deserialize the JSON string into name-value pairs
    Map<String, Object> params = (Map<String, Object>)JSON.deserializeUntyped(request.requestbody.tostring());
    // Iterate through each parameter field and value
    for(String fieldName : params.keySet()) {
        // Set the field and value on the Case sObject
        thisCase.put(fieldName, params.get(fieldName));
    }
    update thisCase;
    return thisCase.Id;
}

So rufen Sie die PATCH-Methode auf:

Klicken Sie in Workbench REST Explorer auf PATCH.
Geben Sie als URI /services/apexrest/Cases/<Record ID> ein. Ersetzen Sie <Record ID> durch die ID des Kundenvorgang-Datensatzes, den Sie zuvor erstellt haben. Geben Sie den folgenden JSON-Text in den Anforderungstext ein.
```
{
  "status" : "Escalated",
  "priority" : "High"
}
```
Dieser JSON-Code hat zwei Feldwerte: "status" und "priority". Die updateCaseFields-Methode ruft diese Werte aus dem übermittelten JSON-Text ab, die zum Angeben der Felder dienen, die im Objekt aktualisiert werden sollen.
Klicken Sie auf Execute (Ausführen).
Diese Anforderung ruft die updateCaseFields-Methode in Ihrem REST-Service auf. Die Felder "Status" und "Priority" des Kundenvorgang-Datensatzes werden in neue Werte geändert. Zum Überprüfen dieser Felder zeigen Sie diesen Datensatz in Salesforce an, indem Sie zu https://yourInstance.my.salesforce.com/<Datensatz-ID> navigieren.

Testen Ihrer Apex-REST-Klasse

Das Testen Ihrer Apex-REST-Klasse entspricht dem Testen anderer Apex-Klassen. Rufen Sie lediglich die Klassenmethoden auf, indem Sie Parameterwerte übergeben und dann die Ergebnisse überprüfen. Für Methoden, die keine Parameter verwenden oder von Informationen in der REST-Anforderung abhängen, erstellten Sie eine REST-Testanforderung.

Im Allgemeinen werden Apex-REST-Services wie folgt getestet. Zum Simulieren einer REST-Anforderung erstellen Sie eine RestRequest-Anforderung in der Testmethode und legen dann Eigenschaften für die Anforderung wie folgt fest. Sie können auch Parameter hinzufügen, die Sie an die Anforderung übergeben, um URI-Parameter zu simulieren.

// Set up a test request
RestRequest request = new RestRequest();
// Set request properties
request.requestUri =
    'https://yourInstance.my.salesforce.com/services/apexrest/Cases/'
    + recordId;
request.httpMethod = 'GET';
// Set other properties, such as parameters
request.params.put('status', 'Working');
// more awesome code here....
// Finally, assign the request to RestContext if used
RestContext.request = request;

Wenn die Methode, die Sie testen, auf Anforderungswerte über RestContext zugreift, weisen Sie die Anforderung RestContext zu, um das Element aufzufüllen (RestContext.request = request;).

Lassen Sie uns nun in der Entwicklerkonsole die gesamte Klasse speichern und die Ergebnisse ausführen.

Klicken Sie in der Developer Console auf File (Datei) | New (Neu) | Apex Class (Apex-Klasse).
Geben Sie als Klassennamen CaseManagerTest ein und klicken Sie auf OK.

Ersetzen Sie den automatisch generierten Code durch die folgende Klassendefinition.

@IsTest
private class CaseManagerTest {
    @isTest static void testGetCaseById() {
        Id recordId = createTestRecord();
        // Set up a test request
        RestRequest request = new RestRequest();
        request.requestUri =
            'https://yourInstance.my.salesforce.com/services/apexrest/Cases/'
            + recordId;
        request.httpMethod = 'GET';
        RestContext.request = request;
        // Call the method to test
        Case thisCase = CaseManager.getCaseById();
        // Verify results
        Assert.isTrue(thisCase != null);
        Assert.areEqual('Test record', thisCase.Subject);
    }
    @isTest static void testCreateCase() {
        // Call the method to test
        ID thisCaseId = CaseManager.createCase(
            'Ferocious chipmunk', 'New', 'Phone', 'Low');
        // Verify results
        Assert.isTrue(thisCaseId != null);
        Case thisCase = [SELECT Id,Subject FROM Case WHERE Id=:thisCaseId];
        Assert.isTrue(thisCase != null);
        Assert.areEqual(thisCase.Subject, 'Ferocious chipmunk');
    }
    @isTest static void testDeleteCase() {
        Id recordId = createTestRecord();
        // Set up a test request
        RestRequest request = new RestRequest();
        request.requestUri =
            'https://yourInstance.my.salesforce.com/services/apexrest/Cases/'
            + recordId;
        request.httpMethod = 'DELETE';
        RestContext.request = request;
        // Call the method to test
        CaseManager.deleteCase();
        // Verify record is deleted
        List<Case> cases = [SELECT Id FROM Case WHERE Id=:recordId];
        Assert.isTrue(cases.size() == 0);
    }
    @isTest static void testUpsertCase() {
        // 1. Insert new record
        ID case1Id = CaseManager.upsertCase(
                'Ferocious chipmunk', 'New', 'Phone', 'Low', null);
        // Verify new record was created
        Assert.isTrue(Case1Id != null);
        Case case1 = [SELECT Id,Subject FROM Case WHERE Id=:case1Id];
        Assert.isTrue(case1 != null);
        Assert.areEqual(case1.Subject, 'Ferocious chipmunk');
        // 2. Update status of existing record to Working
        ID case2Id = CaseManager.upsertCase(
                'Ferocious chipmunk', 'Working', 'Phone', 'Low', case1Id);
        // Verify record was updated
        Assert.areEqual(case1Id, case2Id);
        Case case2 = [SELECT Id,Status FROM Case WHERE Id=:case2Id];
        Assert.isTrue(case2 != null);
        Assert.areEqual(case2.Status, 'Working');
    }
    @isTest static void testUpdateCaseFields() {
        Id recordId = createTestRecord();
        RestRequest request = new RestRequest();
        request.requestUri =
            'https://yourInstance.my.salesforce.com/services/apexrest/Cases/'
            + recordId;
        request.httpMethod = 'PATCH';
        request.addHeader('Content-Type', 'application/json');
        request.requestBody = Blob.valueOf('{"status": "Working"}');
        RestContext.request = request;
        // Update status of existing record to Working
        ID thisCaseId = CaseManager.updateCaseFields();
        // Verify record was updated
        Assert.isTrue(thisCaseId != null);
        Case thisCase = [SELECT Id,Status FROM Case WHERE Id=:thisCaseId];
        Assert.isTrue(thisCase != null);
        Assert.areEqual(thisCase.Status, 'Working');
    }
    // Helper method
    static Id createTestRecord() {
        // Create test record
        Case caseTest = new Case(
            Subject='Test record',
            Status='New',
            Origin='Phone',
            Priority='Medium');
        insert caseTest;
        return caseTest.Id;
    }
}

Drücken Sie STRG+S, um zu speichern.
Um alle Tests in Ihrer Organisation auszuführen, klicken Sie auf Test | Run All.

Die Testergebnisse werden auf der Registerkarte "Tests" angezeigt. Überprüfen Sie nach der Testausführung im Bereich "Overall Code Coverage" (Gesamte Codeabdeckung) die Zeile "CaseManager". Die Abdeckung ist 100 %.

Weitere Infos...

Erfahren Sie mehr über unterstützte Datentypen und Namespaces in Apex REST, Salesforce-APIs und Sicherheitsaspekte.

Unterstützte Datentypen für Apex REST

Apex REST unterstützt diese Datentypen für Parameter und Rückgabewerte.

Primitive Apex-Datentypen (mit Ausnahme von "Objekt" und "Blob").
sObjects
Listen oder Zuordnungen von primitiven Apex-Datentypen oder sObjects (nur Zuordnungen zu "String"-Schlüsseln werden unterstützt).
Benutzerdefinierte Datentypen mit Mitgliedsvariablen der oben aufgeführten Typen.

Namespaces in Apex-REST-Endpunkten

Apex-REST-Methoden können in verwalteten und nicht verwalteten Paketen verwendet werden. Beim Aufrufen von Apex-REST-Methoden, die in einem verwalteten Paket enthalten sind, müssen Sie den Namespace des verwalteten Pakets in den URL des REST-Aufrufs einbeziehen. Wenn beispielsweise die Klasse in einem Namespace eines verwalteten Pakets namens packageNamespace enthalten ist und die Apex-REST-Methoden die URL-Zuordnung /MyMethod/* verwenden, hat der URL, der über REST zum Aufrufen dieser Methoden verwendet wird, das Format https://instance.my.salesforce.com/services/apexrest/packageNamespace/MyMethod/.

Benutzerdefinierte Apex-Webservices und Salesforce-APIs

Anstatt benutzerdefinierten Apex-Code für REST- und SOAP-Services zu nutzen, können externe Anwendungen mithilfe der REST- und SOAP-APIs von Salesforce in Salesforce integriert werden. Mithilfe dieser APIs können Sie Datensätze erstellen, aktualisieren und löschen. Der Vorteil von Apex-Webservices ist jedoch, dass Apex-Methoden komplexe Logik kapseln können. Die Logik bleibt der nutzenden Anwendung verborgen. Darüber hinaus können Apex-Klassenvorgänge schneller erfolgen als individuelle API-Aufrufe, da weniger Roundtrips zwischen dem Client und den Salesforce-Servern anfallen. Beim Aufruf eines Apex-Webservice wird nur eine Anforderung gesendet, wobei alle Vorgänge in der Methode auf dem Server erfolgen.

Sicherheitsaspekte für Apex-Webservices

Der Sicherheitskontext, in dem Apex-Webservicemethoden ausgeführt werden, unterscheidet sich vom Sicherheitskontext von Salesforce-APIs. Im Gegensatz zu Salesforce-APIs werden Apex-Webservicemethoden mit Systemberechtigungen ausgeführt, ohne die Objekt- und Feldberechtigungen des Benutzers zu beachten. Apex-Webservicemethoden erzwingen allerdings Freigaberegeln, wenn die Deklaration mit dem Schlüsselwort with sharing erfolgt.

Benötigen Sie Hilfe?

Mehr entdecken