Diese Seite wurde von der Cloud Translation API übersetzt.

Java-Callout erstellen

Sie sehen die Dokumentation zu Apigee Edge.
Zur Apigee X-Dokumentation weitere Informationen

Was ist ein Java-Callout?

Apigee Edge bietet eine Reihe von Richtlinien für allgemeine API-Verwaltungsanforderungen wie Sicherheit, Datentransformation, Traffic-Verwaltung und andere.

Es gibt jedoch Fälle, in denen Ihre API benutzerdefiniertes Verhalten benötigt, das nicht in einer Standardrichtlinie implementiert ist. In diesen Fällen bietet Apigee verschiedene Optionen, mit denen Sie ein Skript- oder benutzerdefiniertes API-Verhalten erstellen können. Ein Ansatz besteht darin, das gewünschte Verhalten in Java zu implementieren.

Informationen zu den unterstützten Java-Versionen findest du unter Unterstützte Software und unterstützte Versionen.

Wie verwende ich Java-Code in einem Proxy?

Mit einer Java-Callout-Richtlinie können Sie Java-Code aus einem ausgeführten Proxyablauf aufrufen. Ihr Java-Code muss bestimmte Edge-spezifische Java-Schnittstellen implementieren, die es dem Code ermöglichen, mit dem ausführenden Proxy zu interagieren. Beispielsweise finden Sie Java-Methoden zum Abrufen und Festlegen von Headern, Abfrageparameter, Flussvariablen und anderen Entitäten im aktuellen Ablaufkontext des Proxys.

Wann sollte ich Java-Callouts verwenden?

Sehen wir uns nun Situationen an, in denen Java-Callouts nützlich sind, und Situationen, in denen Sie andere Ansätze berücksichtigen sollten.

Alternative Ansätze berücksichtigen

Bevor Sie ein Java-Callout verwenden, gibt es möglicherweise alternative Ansätze, die Sie stattdessen verwenden können. Beispiel:

Für einfache Vorgänge wie HTTP API-Aufrufe für Remote-Dienste sollten Sie die ServiceCallout-Richtlinie verwenden. Siehe Service Callout-Richtlinie.
Bei relativ einfachen Interaktionen mit Nachrichteninhalten, z. B. zum Ändern oder Extrahieren von HTTP-Headern, Parametern oder Nachrichteninhalten, können Sie JavaScript- oder Python-Sprachen verwenden.

Was in Java-Code möglich ist

Ein Java-Callout unterstützt die folgenden grundlegenden Vorgänge:

Anfrage- oder Antwortnachrichten untersuchen oder bearbeiten.
Ablaufvariablen abrufen und festlegen. Sie können Java-Methoden verwenden, um auf Edge-Flussvariablen zuzugreifen. Wenn Sie auf Informationen zu Key Value Map (KVM) zugreifen möchten, verwenden Sie eine KVM-Richtlinie und weisen den Ablaufvariablen KVM-Werte zu. Daraufhin können Sie auf die Ablaufvariablen innerhalb des Java-Callouts zugreifen.
Externe Dienste aufrufen
Fehlerantworten generieren
Fehlermeldungen und Statuscodes bearbeiten

Was in Java-Code nicht möglich ist

Die meisten Systemaufrufe sind nicht zulässig. Das können Sie nicht tun:

Internes Dateisystem für Lese- oder Schreibvorgänge konfigurieren Das bedeutet, dass Sie keine Java-Pakete zum Lesen/Schreiben in interne Dateisysteme verwenden können. Sie können jedoch externe Remoteaufrufe ausführen.
Informationen zum aktuellen Prozess, zur Prozessliste oder zur CPU-/Speicherauslastung auf der Maschine abrufen.
Auf den Quellcode in „expressions-1.0.0.jar“ und „message-flow-1.0.0.jar“ zugreifen.

Auch wenn einige dieser Aufrufe funktionieren, werden sie nicht unterstützt und können jederzeit deaktiviert werden. Vermeiden Sie diese Aufrufe in Ihrem Code.

Verwenden Sie keine Java-Bibliotheken, die in Apigee Edge enthalten sind. Diese Bibliotheken dienen nur der Funktion von Edge-Produkten. Es gibt keine Garantie, dass eine Bibliothek von Release zu Release verfügbar ist. Wenn Sie diese Bibliotheken verwenden, dann nur in Demonstrationen; nicht in der Produktionsumgebung.

„Hello Java“-Callout

Sehen wir uns ein einfaches Beispiel für eine Java-Erweiterung mit „Hello World” an. In diesem Beispiel erstellen wir einen einfachen Proxy mit einem Java-Callout, der eine „Hello World”-Antwort zurückgibt. Der Proxy kann eine von zwei möglichen Antworten zurückgeben:

Wenn Sie einen „username“-Header mit einem „name“-Wert übergeben, gibt der Proxy Folgendes zurück:
```
Hello, <name>!
```
Wenn Sie den Header weglassen, gibt der Proxy einfach Folgendes zurück:
```
"Hello, Guest!"
```

Startprojekt herunterladen

Der Einfachheit halber haben wir auf GitHub im Apigee-Repository api-platform-samples ein einfaches Projekt vorbereitet.

Laden Sie api-platform-samples in Ihr System herunter oder klonen Sie es.
Wechseln Sie in einem Terminal oder Code-Editor Ihrer Wahl zum api-platform-samples/doc-samples/java-hello-Projekt.

Java-Code schreiben

Öffnen Sie die Java-Quelldatei: java-hello/callout/src/main/java/HelloJava.java. Diese Datei ist eine Basisversion der Java-Hauptklasse, die wir implementieren werden. Die importierten Pakete sind für den Edge-Java-Callout-Code erforderlich. Diese Klassen bieten Methoden zum Zugreifen auf den Kontext der Proxyausführung. Die Schritte zum Kompilieren und Bereitstellen dieses Codes werden weiter unten erläutert.

package com.apigeesample;

import com.apigee.flow.execution.ExecutionContext;
import com.apigee.flow.execution.ExecutionResult;
import com.apigee.flow.execution.spi.Execution;
import com.apigee.flow.message.MessageContext;


public class HelloJava implements Execution {

        public ExecutionResult execute(MessageContext messageContext, ExecutionContext executionContext) {
                
                try {

                        // Your code here.
            
            return ExecutionResult.SUCCESS;

                } catch (Exception e) {
                        return ExecutionResult.ABORT;
                }
        }

}

Ersetzen Sie die kommentierte Zeile // Your code here durch den folgenden Code:
```
String name = messageContext.getMessage().getHeader("username");

if (name != null && name.length()>0) {
        messageContext.getMessage().setContent("Hello, " + name + "!");
        messageContext.getMessage().removeHeader("username");
} else {
        messageContext.getMessage().setContent("Hello, Guest!");
}
```
Hinweis: Hinweis: Mit dem Objekt MessageContext können Sie auf Entitäten innerhalb des Ablaufs zugreifen, in dem die Java-Callout-Richtlinie ausgeführt wird. Nehmen wir an, die Java-Callout-Richtlinie ist an den Proxy Endpoint-Antwortablauf angehängt. Der oben aufgeführte Code ruft das HTTP-Nachrichtenobjekt für diesen Ablaufkontext ab. Das Message-Objekt wiederum bietet Zugriff auf Header, Abfrageparameter, Textinhalt und Flussvariablen.
Speichern Sie die Datei.

Code mit Maven kompilieren

Das Projekt ist so eingerichtet, dass Sie es mit Maven kompilieren können. Wenn Sie javac verwenden möchten, fügen wir ein Beispiel gemäß dem Maven-Beispiel hinzu.

Maven muss installiert sein:
```
mvn -version
```
Führen Sie das java-hello/buildsetup.sh-Skript aus: Mit diesem Skript werden die erforderlichen JAR-Abhängigkeiten in Ihrem lokalen Maven-Repository installiert.
cd in das java-hello/callout-Verzeichnis.
Führen Sie Maven aus:
```
mvn clean package
```
Hinweis: Wenn Sie einen Maven-Fehler erhalten, prüfen Sie, ob Sie sich im Verzeichnis java-hello/callout befinden.
Prüfen Sie bei Bedarf, ob die edge-custom-policy-java-hello.jar-JAR-Datei nach java-hello/apiproxy/resources/java kopiert wurde. Dies ist der erforderliche Speicherort für JAR-Dateien, die Sie mit einem Proxy bereitstellen möchten.

Mit Javac kompilieren (optional)

Im vorherigen Abschnitt generieren Sie die erforderliche Java JAR-Datei automatisch mit einem Maven-Befehl. Wenn Sie javac zum Kompilieren des Codes verwenden möchten, können Sie auch Folgendes ausführen (im Verzeichnis java-hello). Die erforderlichen JAR-Dateien werden im java-hello/lib-Verzeichnis für Sie bereitgestellt.

cd in api-platform-samples/doc-samples/java-hello.
Achten Sie darauf, dass Ihr Pfad javac enthält.
```
javac -version
```

Führen Sie den folgenden javac-Befehl aus:

javac -d . -classpath ./lib/expressions-1.0.0.jar:./lib/message-flow-1.0.0.jar:. callout/src/main/java/HelloJava.java

Damit wird com/apigeesample/HelloJava.class erstellt.

Erstellen Sie eine JAR-Datei mit der kompilierten Klasse im Verzeichnis apiproxy/resources/java. Dies ist der erforderliche Speicherort für JAR-Dateien, die Sie mit einem Proxy bereitstellen möchten. Dazu können Sie den folgenden Befehl im Verzeichnis java-hello ausführen. Vergessen Sie dabei nicht den Punkt am Ende.
```
jar cvf apiproxy/resources/java/edge-custom-policy-java-hello.jar -C com .
```

Proxy bereitstellen und aufrufen

Ein Bereitstellungsskript wird im ./java-hello-Verzeichnis bereitgestellt. Bevor Sie es ausführen, müssen Sie jedoch eine schnelle Einrichtung vornehmen.

CD zu api-platform-samples/doc-samples/java-hello
Falls noch nicht geschehen, öffnen Sie die Datei ../../setup/setenv.sh und bearbeiten Sie sie wie angegeben mit Ihren Apigee-Kontoinformationen: Ihrem Nutzernamen (die mit Ihrem Konto verknüpfte E-Mail-Adresse), dem Namen Ihrer Organisation und der Domain, die Sie für API-Verwaltungsaufrufe verwenden. Für Edge Cloud ist die Domain beispielsweise https://api.enterprise.apigee.com. Ihre Domain kann sich jedoch unterscheiden, wenn Sie Edge Private Cloud verwenden.
Speichern Sie die Datei setenv.sh.
Führen Sie das Bereitstellungsskript aus:
```
./deploy.sh
```
Wenn die Bereitstellung erfolgreich ist, führen Sie das Aufrufskript aus:
```
./invoke.sh
```
Das Aufrufskript ruft einen cURL-Befehl auf, der so aussieht:
```
curl  http://$org-$env.$api_domain/java-hello -H "username:Will"
```
Daraufhin wird „Hello, Will!“ zurückgegeben.

Sie können das Skript invoke.sh bearbeiten, um den Namen zu ändern. Wenn Sie den cURL-Aufruf ändern, um den Header zu entfernen, gibt der Befehl „Hello, Guest!“ zurück.

Info zum Proxy

Sehen wir uns kurz die Richtlinien an, die in diesem Proxy verwendet werden. Achten Sie darauf, wo die Richtlinien im Proxyablauf platziert sind und warum.

Richtlinie „AssignMessage“

Die Richtlinie „AssignMessage“ ist mit dem ProxyEndpoint-Anfrageablauf verknüpft. Sie kopiert den Nutzernamen-Header aus der Anfrage und weist ihn der Antwort zu. Aufgrund dieses Vorgangs kann die mit dem Antwortablauf verknüpfte JavaCallout-Richtlinie auf den Nutzernamen-Header zugreifen und einen benutzerdefinierten Antworttext mit dem Wert dieses Headers erstellen.

<AssignMessage async="false" continueOnError="false" enabled="true" name="CopyHeader">     
    <DisplayName>CopyHeader</DisplayName>     
    <Copy source="request">         
        <Headers>             
          <Header name="username"/>         
        </Headers>     
    </Copy>     
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>     
    <AssignTo createNew="false" transport="http" type="response"/> 
</AssignMessage>

JavaCallout-Richtlinie

Die Java-Callout-Richtlinie ist an den Antwortablauf angehängt. Dies liegt daran, dass der benutzerdefinierte Java-Code Änderungen an den Antwortheadern und der Nachricht vornimmt. Das ClassName-Element der Richtlinie gibt die Hauptklasse an, die von der Richtlinie ausgeführt wird. Das ResourceURL-Element ist der Name der JAR-Datei, die Sie erstellt und dem Verzeichnis resources/java des Proxys hinzugefügt haben.

<JavaCallout name="hello-java">         
    <ClassName>com.apigeesample.HelloJava</ClassName>         
    <ResourceURL>java://edge-custom-policy-java-hello.jar</ResourceURL> 
</JavaCallout>

Wissenswertes zu Java-Callouts

Wichtige Hinweise zur Implementierung eines Java-Callouts:

Importiert Klassen aus den Paketen com.apigee.flow.execution und com.apigee.flow.message. Diese Pakete müssen in der JAR-Datei enthalten sein und bereitgestellt werden. Sie können Ihre Java-JAR über den Management-UI-Proxy-Editor hochladen oder die Datei in das Verzeichnis /resources/java in API-Proxys aufnehmen, die Sie lokal entwickeln.
Implementiert die Ausführungsschnittstelle. Jeder Java-Code, der in einem API-Proxy ausgeführt wird, muss Ausführungen implementieren.
Eine Java-Callout-Richtlinie enthält keinen tatsächlichen Code. Stattdessen verweist eine Java-Callout-Richtlinie auf eine Java-„Ressource“, die Sie in eine JAR-Datei verpacken müssen.
Zu vermeidende Paketnamen: Verwenden Sie in Java-Callouts nicht io.apigee oder com.apigee als Paketnamen. Diese sind für die Verwendung durch andere Apigee-Module reserviert.
Wenn Ihr Java-Callout auf zusätzliche Bibliotheken von Drittanbietern verweist, die als unabhängige JAR-Dateien verpackt werden, legen Sie diese JAR-Dateien ebenfalls im Verzeichnis /resources/java ab, damit sie zur Laufzeit ordnungsgemäß geladen werden.
Wenn es mehrere JARs gibt, fügen Sie diese einfach als zusätzliche Ressourcen hinzu. Sie müssen die Richtlinienkonfiguration nicht ändern, um auf zusätzliche JAR-Dateien zu verweisen. Es ist ausreichend, sie in /resources/java aufzunehmen.
Informationen zum Hochladen von Java-JARs finden Sie unter Ressourcendateien.