Diese Seite wurde von der Cloud Translation API übersetzt.

Java-Callout erstellen

<ph type="x-smartling-placeholder"></ph> Sie sehen die Dokumentation zu Apigee Edge.
Gehen Sie zur Apigee X-Dokumentation. Weitere Informationen

Was ist ein Java-Callout?

Apigee Edge bietet eine Reihe von Richtlinien, die gängige API-Verwaltungsanforderungen erfüllen, z. B. Sicherheit, Datentransformation, Traffic-Verwaltung usw.

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 finden Sie unter Unterstützte Software und unterstützten 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 muss bestimmte Edge-spezifische Java-Schnittstellen implementieren, mit denen der Code interagieren kann. mit dem ausführenden Proxy. 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, und verlassen Sie sich auch nicht darauf. Diese Bibliotheken sind nur für die Funktionen des Edge-Produkts. Es kann nicht garantiert werden, dass eine Bibliothek verfügbar ist. von Release zu Release. 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 „Nutzernamen“ einen Titel mit einem „Namen“ 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. Das importierte -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:Der 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. Die Message -Objekt wiederum bietet Ihnen Zugriff auf Header, Suchparameter, Textinhalte und Datenfluss Variablen.
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, achten Sie darauf, dass Sie sich im java-hello/callout.
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

Dadurch 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
Öffnen Sie die Datei ../../setup/setenv.sh und bearbeiten Sie sie, falls Sie das noch nicht getan haben. wie mit Ihren Apigee-Kontoinformationen angegeben: Ihr Nutzername (die E-Mail-Adresse) die mit Ihrem Konto verknüpft sind), den Namen Ihrer Organisation und die Domain, die Sie zur Erstellung der API Anrufverwaltung. Bei Edge Cloud ist die Domain beispielsweise https://api.enterprise.apigee.com; Ihre Domain kann jedoch anders sein, wenn Sie mit Edge Private Cloud.
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 oder das cURL-Aufruf, um den Header zu entfernen, gibt der Befehl „Hello, Guest!“ zurück.

Über den 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.