Erfassen Sie Ihre Fortschritte
Trailhead-Startseite
Trailhead-Startseite

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

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://IhreInstanz.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://IhreInstanz.salesforce.com/services/apexrest/. Für Ihre Organisation könnte er https://IhreInstanz.salesforce.com/services/apexrest/Account/* lauten.

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://IhreInstanz.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.

  1. Klicken Sie auf das Setup-Zahnradsymbol (Setup-Zahnradsymbol) und wählen Sie Entwicklerkonsole aus.
  2. Klicken Sie in der Entwicklerkonsole auf File | New | Apex Class.
  3. Geben Sie als Klassennamen CaseManager ein und klicken Sie auf OK.
  4. 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;
        }    
    
    }
  5. 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, werfen aber später auch einen Blick auf cURL.

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.

  1. Navigieren Sie zu https://workbench.developerforce.com/login.php.
  2. Wählen Sie als Umgebung Production aus.
  3. Wählen Sie in der Dropdown-Liste API Version die neueste API-Version aus.
  4. Akzeptieren Sie die Bedingungen des Dienstes und klicken Sie auf Login with Salesforce.
  5. Um der Workbench Zugang zu Ihren Informationen zu gewähren, klicken Sie auf Allow.
  6. Geben Sie Ihre Anmeldeinformationen ein und klicken Sie auf Log in to Salesforce (Bei Salesforce anmelden).
  7. Wählen Sie nach dem Anmelden utilities | REST Explorer (Dienstprogramme -> REST Explorer) aus.
  8. Wählen Sie POST aus.
  9. 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/.
  10. Fügen Sie als Anforderungstext die folgende JSON-Zeichenfolgendarstellung des einzufügenden Objekts ein.
    {
      "subject" : "Bigfoot Sighting!",
      "status" : "New",
      "origin" : "Phone",
      "priority" : "Low"
    }
  11. 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.
  12. 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.

  1. Wählen Sie in Workbench GET aus.
  2. Geben Sie den URI /services/apexrest/Cases/<Datensatz-ID> ein und ersetzen Sie <Datensatz-ID> durch die ID des Datensatzes, den Sie im vorherigen Schritt erstellt haben.
  3. 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.

  4. 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"
    }
    

Abrufen von Daten mithilfe von cURL

Jeder gute Entwickler sollte mindestens drei Dinge draufhaben: 1.) Erstellen eines animierten GIF von sich selbst beim Eis essen, 2.) den Wert von pi bis zur 25. Dezimalstelle und 3. das Arbeiten mit cURL. Die ersten beiden würden den Rahmen dieses Moduls sprengen, weshalb wir uns auf die letzte Fähigkeit konzentrieren möchten.

cURL ist ein Befehlszeilentool für das Abrufen oder Senden von Dateien mithilfe von URL-Syntax. Das ist ziemlich praktisch, wenn mit REST-Endpunkten gearbeitet wird. Anstelle der Verwendung von Workbench für Ihren Apex-REST-Service verwenden Sie cURL zum Abrufen der HTTP-Methode GET. Bei jedem Aufruf Ihres REST-Endpunkts mit cURL übergeben Sie die Sitzungs-ID zur Autorisierung. In Workbench wurden Sie verwöhnt, da das Tool die Sitzungs-ID für Sie im Hintergrund übergeben hat, nachdem Sie sich angemeldet hatten.

Um eine Sitzungs-ID zu erhalten, erstellen Sie zuerst eine verbundene Anwendung in Ihrer Salesforce-Organisation und aktivieren OAuth. Ihre Client-Anwendung, in diesem Fall cURL, nutzt die verbundene Anwendung für die Verbindung zu Salesforce. Folgen Sie dieser Anleitung, um eine verbundene Anwendung zu erstellen, die den Verbraucherschlüssel und das Verbrauchergeheimnis für Sie bereitstellt, die Sie zum Erhalt Ihrer Sitzungs-ID benötigen. Bei der Auswahl der OAuth-Umfänge für Ihre verbundene Anwendung wählen Sie den Umfang "Zugriff auf Ihre Daten und Datenverwaltung (api)" aus. Die Einrichtung der verbundenen Anwendung kann 5 bis 10 Minuten dauern. Wenn die Anwendung bereit ist, verwenden Sie den folgenden cURL-Befehl mit Ihren Anmeldeinformationen und der verbundenen Anwendung.

curl -v https://login.salesforce.com/services/oauth2/token -d "grant_type=password" -d "client_id=<your_consumer_key>" -d "client_secret=<your_consumer_secret>" -d "username=<your_username>" -d "password=<your_password_and_security_token>" -H 'X-PrettyPrint:1'

Wenn alle Schritte erfolgreich ausgeführt wurden, enthält das Ergebnis ein "access_token", das aus Ihrer Sitzungs-ID und dem "instance_url" für Ihre Organisation besteht.

cURL-Antwort mit Zugriffstoken

Geben Sie jetzt Ihren cURL-Befehl ein, der ähnlich wie der folgende lautet, um Ihren Apex-REST-Service aufzurufen und die Kundenvorgangsinformationen zurückzugeben.

curl https://yourInstance.salesforce.com/services/apexrest/Cases/<Record_ID> -H "Authorization: Bearer <your_session_id>" -H "X-PrettyPrint:1"

Nach Drücken der EINGABETASTE sollten Sie etwas Ähnliches wie das Folgende sehen: Nun da Sie die Befehlszeile beherrschen, nutzen Sie cURL, jq, sed, awk und grep ganz nach Gusto. Weitere Informationen zu cURL finden Sie im Abschnitt Ressourcen.

cURL und Antwort über die Befehlszeile

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:
  1. Wählen Sie in Workbench REST Explorer PUT aus.
  2. Geben Sie als URI /services/apexrest/Cases/ ein.
  3. 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"
    }
    Hinweis

    Hinweis

    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.

  4. Klicken Sie auf Execute (Ausführen).

    Diese Anforderung ruft die upsertCase-Methode in Ihrem REST-Service auf. Die Felder Status, Subject, and 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://IhreInstanz.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, da es NULL 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:
  1. Klicken Sie in Workbench REST Explorer auf PATCH.
  2. Geben Sie als URI /services/apexrest/Cases/<Datensatz-ID> ein. Ersetzen Sie <Datensatz-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.

  3. 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://IhreInstanz.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.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.

  1. Klicken Sie in der Entwicklerkonsole auf File | New | Apex Class.
  2. Geben Sie als Klassennamen CaseManagerTest ein und klicken Sie auf OK.
  3. 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.salesforce.com/services/apexrest/Cases/'
                + recordId;
            request.httpMethod = 'GET';
            RestContext.request = request;
            // Call the method to test
            Case thisCase = CaseManager.getCaseById();
            // Verify results
            System.assert(thisCase != null);
            System.assertEquals('Test record', thisCase.Subject);
        }
    
        @isTest static void testCreateCase() {
            // Call the method to test
            ID thisCaseId = CaseManager.createCase(
                'Ferocious chipmunk', 'New', 'Phone', 'Low');
            // Verify results
            System.assert(thisCaseId != null);
            Case thisCase = [SELECT Id,Subject FROM Case WHERE Id=:thisCaseId];
            System.assert(thisCase != null);
            System.assertEquals(thisCase.Subject, 'Ferocious chipmunk');
        }
    
        @isTest static void testDeleteCase() {
            Id recordId = createTestRecord();
            // Set up a test request
            RestRequest request = new RestRequest();
            request.requestUri =
                'https://yourInstance.salesforce.com/services/apexrest/Cases/'
                + recordId;
            request.httpMethod = 'GET';
            RestContext.request = request;
            // Call the method to test
            CaseManager.deleteCase();
            // Verify record is deleted
            List<Case> cases = [SELECT Id FROM Case WHERE Id=:recordId];
            System.assert(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
            System.assert(Case1Id != null);
            Case case1 = [SELECT Id,Subject FROM Case WHERE Id=:case1Id];
            System.assert(case1 != null);
            System.assertEquals(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
            System.assertEquals(case1Id, case2Id);
            Case case2 = [SELECT Id,Status FROM Case WHERE Id=:case2Id];
            System.assert(case2 != null);
            System.assertEquals(case2.Status, 'Working');
        }    
    
        @isTest static void testUpdateCaseFields() {
            Id recordId = createTestRecord();
            RestRequest request = new RestRequest();
            request.requestUri =
                'https://yourInstance.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
            System.assert(thisCaseId != null);
            Case thisCase = [SELECT Id,Status FROM Case WHERE Id=:thisCaseId];
            System.assert(thisCase != null);
            System.assertEquals(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;
        }          
    
    }
  4. Drücken Sie STRG+S, um zu speichern.
  5. 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 "sObject" 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.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.