Java-Entwicklerhandbuch für Azure Functions
Dieser Leitfaden enthält ausführliche Informationen, die Sie bei der erfolgreichen Entwicklung von Azure Functions mit Java unterstützen.
Wenn Sie als Java-Entwickler noch nicht mit Azure Functions vertraut sind, sollten Sie zunächst einen der folgenden Artikel lesen:
Erste Schritte | Konzepte | Szenarien/Beispiele |
---|---|---|
Grundlagen zu Java-Funktionen
Eine Java-Funktion ist eine public
-Methode, die mit der Anmerkung @FunctionName
versehen ist. Diese Methode definiert die Eingabe für eine Java-Funktion und muss in einem bestimmten Paket eindeutig sein. Das Paket kann mehrere Klassen mit mehreren öffentlichen Methoden enthalten, die mit @FunctionName
kommentiert sind. Ein einzelnes Paket wird für eine Funktions-App in Azure bereitgestellt. In Azure stellt die Funktions-App den Bereitstellungs-, Ausführungs- und Verwaltungskontext für Ihre einzelnen Java-Funktionen bereit.
Programmiermodell
Die Konzepte von Triggern und Bindungen sind für Azure Functions von grundlegender Bedeutung. Trigger starten die Ausführung Ihres Codes. Bindungen bieten Ihnen eine Möglichkeit, Daten an eine Funktion zu übergeben und von einer Funktion zurückgeben zu lassen, ohne benutzerdefinierten Datenzugriffscode schreiben zu müssen.
Erstellen von Java-Funktionen
Um das Erstellen von Java-Funktionen zu erleichtern, gibt es Maven-basierte Tools und Archetypen, die vordefinierte Java-Vorlagen verwenden, um Ihnen beim Erstellen von Projekten mit einem bestimmten Funktionstrigger zu helfen.
Maven-basierte Tools
Die folgenden Entwicklerumgebungen verfügen über Azure Functions-Tools, mit denen Sie Java-Funktionsprojekte erstellen können:
Diese Artikel zeigen Ihnen, wie Sie Ihre ersten Funktionen mithilfe einer IDE Ihrer Wahl erstellen.
Projektgerüstbau
Wenn Sie die Entwicklung mit der Befehlszeile über das Terminal bevorzugen, besteht die einfachste Möglichkeit für den Gerüstbau von Java-basierten Funktionsprojekten darin, Apache Maven
-Archetypes zu verwenden. Der Java Maven-Archetyp wird unter der folgenden groupId:artifactId veröffentlicht: com.microsoft.azure:azure-functions-archetype.
Mit dem folgenden Befehl wird ein neues Java-Funktionsprojekt mit diesem Archetyp generiert:
mvn archetype:generate \
-DarchetypeGroupId=com.microsoft.azure \
-DarchetypeArtifactId=azure-functions-archetype
Informationen zu den ersten Schritten bei der Verwendung dieses Archetyps finden Sie im Java-Schnellstart.
Ordnerstruktur
Im Folgenden wird die Ordnerstruktur eines Java-Projekts von Azure Functions gezeigt:
FunctionsProject
| - src
| | - main
| | | - java
| | | | - FunctionApp
| | | | | - MyFirstFunction.java
| | | | | - MySecondFunction.java
| - target
| | - azure-functions
| | | - FunctionApp
| | | | - FunctionApp.jar
| | | | - host.json
| | | | - MyFirstFunction
| | | | | - function.json
| | | | - MySecondFunction
| | | | | - function.json
| | | | - bin
| | | | - lib
| - pom.xml
Sie können die freigegebene Datei host.json zum Konfigurieren der Funktions-App verwenden. Jede Funktion verfügt über eine eigene Codedatei (JAVA-Datei) sowie über eine eigene Bindungskonfigurationsdatei („function.json“).
Sie können mehr als eine Funktion in einem Projekt haben. Sie sollten Ihre Funktionen jedoch nicht separaten JAR-Dateien hinzufügen. Die Verwendung mehrerer JAR-Dateien in einer einzelnen Funktions-App wird nicht unterstützt. Die FunctionApp
im Zielverzeichnis wird in Ihrer Funktions-App in Azure bereitgestellt.
Trigger und Anmerkungen
Funktionen werden durch einen Trigger, z.B. eine HTTP-Anforderung, einen Timer oder ein Datenupdate, aufgerufen. Ihre Funktion muss diesen Trigger und alle weiteren Eingaben verarbeiten, um mindestens eine Ausgabe zu erstellen.
Verwenden Sie die Java-Anmerkungen im Paket com.microsoft.azure.functions.annotation.*, um Eingaben und Ausgaben an Ihre Methoden zu binden. Weitere Informationen finden Sie in der Java-Referenzdokumentation.
Wichtig
Sie müssen ein Azure Storage-Konto in local.settings.json konfigurieren, um Trigger für Azure Blob Storage, Azure Queue Storage oder Azure Table Storage lokal auszuführen.
Beispiel:
public class Function {
public String echo(@HttpTrigger(name = "req",
methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS)
String req, ExecutionContext context) {
return String.format(req);
}
}
Hier wird die entsprechende Datei function.json
gezeigt, die durch azure-functions-maven-plugin generiert wurde:
{
"scriptFile": "azure-functions-example.jar",
"entryPoint": "com.example.Function.echo",
"bindings": [
{
"type": "httpTrigger",
"name": "req",
"direction": "in",
"authLevel": "anonymous",
"methods": [ "GET","POST" ]
},
{
"type": "http",
"name": "$return",
"direction": "out"
}
]
}
Java-Versionen
Die Version von Java, mit der Ihre Anwendung in Azure ausgeführt wird, wird in der Datei „pom.xml“ angegeben. Der Maven-Archetyp generiert aktuell eine Datei „pom.xml“ für Java 8, die Sie vor dem Veröffentlichen ändern können. Die Java-Version in „pom.xml“ sollte der Version entsprechen, mit der Sie Ihre App lokal entwickelt und getestet haben.
Unterstützte Versionen
Die folgende Tabelle zeigt die aktuell von den jeweiligen Hauptversionen der Functions Runtime unterstützte Java-Version nach Betriebssystem:
Functions-Version | Java-Versionen (Windows) | Java-Versionen (Linux) |
---|---|---|
4.x | 17 11 8 |
21 (Preview) 17 11 8 |
3.x | 11 8 |
11 8 |
2.x | 8 | – |
Wenn Sie keine Java-Version für die Bereitstellung angeben, wird der Maven-Archetyp bei der Bereitstellung in Azure standardmäßig auf Java 8 festgelegt.
Angeben des Bereitstellungsversion
Mithilfe des Parameters -DjavaVersion
können Sie die Java-Version steuern, auf die der Maven-Archetyp ausgerichtet ist. Der Wert dieses Parameters kann 8
, 11
, 17
oder 21
sein.
Der Maven-Archetyp generiert eine Datei vom Typ „pom.xml“ für die angegebene Java-Version. Die folgenden Elemente in „pom.xml“ geben die zu verwendende Java-Version an:
Element | Java 8-Wert | Java 11-Wert | Java 17-Wert | Java 21-Wert (Preview, Linux) | Beschreibung |
---|---|---|---|---|---|
Java.version |
1.8 | 11 | 17 | 21 | Version von Java, die vom maven-compiler-plugin verwendet wird. |
JavaVersion |
8 | 11 | 17 | 21 | Java-Version, die von der Funktions-App in Azure gehostet wird. |
Die folgenden Beispiele zeigen die Einstellungen für Java 8 in den relevanten Abschnitten der Datei „pom.xml“:
Java.version
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
<azure.functions.maven.plugin.version>1.6.0</azure.functions.maven.plugin.version>
<azure.functions.java.library.version>1.3.1</azure.functions.java.library.version>
<functionAppName>fabrikam-functions-20200718015742191</functionAppName>
<stagingDirectory>${project.build.directory}/azure-functions/${functionAppName}</stagingDirectory>
</properties>
JavaVersion
<runtime>
<!-- runtime os, could be windows, linux or docker-->
<os>windows</os>
<javaVersion>8</javaVersion>
<!-- for docker function, please set the following parameters -->
<!-- <image>[hub-user/]repo-name[:tag]</image> -->
<!-- <serverId></serverId> -->
<!-- <registryUrl></registryUrl> -->
</runtime>
Wichtig
Sie müssen die Umgebungsvariable JAVA_HOME ordnungsgemäß auf das JDK-Verzeichnis festlegen, das bei der Codekompilierung mit Maven verwendet wird. Stellen Sie sicher, dass die Version des JDK mindestens so hoch ist wie die Java.version
-Einstellung.
Angeben des Bereitstellungsbetriebssystems
Mit Maven können Sie auch das Betriebssystem angeben, unter dem ihre Funktions-App in Azure ausgeführt wird. Verwenden Sie das os
-Element, um das Betriebssystem auszuwählen.
Element | Windows | Linux | Docker |
---|---|---|---|
os |
windows |
linux |
docker |
Das folgende Beispiel zeigt die Betriebssystemeinstellung im Abschnitt runtime
der Datei „pom.xml“:
<runtime>
<!-- runtime os, could be windows, linux or docker-->
<os>windows</os>
<javaVersion>8</javaVersion>
<!-- for docker function, please set the following parameters -->
<!-- <image>[hub-user/]repo-name[:tag]</image> -->
<!-- <serverId></serverId> -->
<!-- <registryUrl></registryUrl> -->
</runtime>
Verfügbarkeit und Unterstützung der JDK-Runtime
Microsoft- und Adoptium-Builds von OpenJDK werden von Azure Functions für Java 8 (Adoptium), Java 11, 17 und 21 (MSFT) bereitgestellt und unterstützt. Diese Binärdateien werden als kostenlose, plattformübergreifende und produktionsbereite Distribution von OpenJDK für Azure bereitgestellt. Sie enthält alle Komponenten, die zum Erstellen und Ausführen von Java SE-Anwendungen benötigt werden.
Für lokale Entwicklung oder Tests können Sie den Microsoft-Build von OpenJDK oder die Adoptium Temurin-Binärdateien kostenlos herunterladen. Azure-Support bei Problemen mit den JDKs und Funktions-Apps steht mit einem qualifizierten Supportplan zur Verfügung.
Wenn Sie weiterhin die Binärdateien von Zulu für Azure in Ihrer Funktions-App verwenden möchten, konfigurieren Sie Ihre App entsprechend. Sie können weiterhin die Azul-Binärdateien für Ihre Website verwenden. Sicherheitspatches oder -verbesserungen sind jedoch nur in neuen Versionen von OpenJDK verfügbar. Aus diesem Grund sollten Sie diese Konfiguration letztlich entfernen, damit Ihre Apps die neueste verfügbare Version von Java verwenden.
Anpassen der JVM
Mit Functions können Sie die Java Virtual Machine (JVM) anpassen, mit der Sie Ihre Java-Funktionen ausführen. Die folgenden JVM-Optionen werden standardmäßig verwendet:
-XX:+TieredCompilation
-XX:TieredStopAtLevel=1
-noverify
-Djava.net.preferIPv4Stack=true
-jar
Sie können der JVM andere Argumente bereitstellen, indem Sie je nach Plantyp eine der folgenden Anwendungseinstellungen verwenden:
Plantyp | Einstellungsname | Comment |
---|---|---|
Verbrauchstarif | languageWorkers__java__arguments |
Diese Einstellung erhöht die Kaltstartzeiten für Java-Funktionen, die in einem Verbrauchsplan ausgeführt werden. |
Premium-Plan Dedizierter Plan |
JAVA_OPTS |
In den folgenden Abschnitten wird gezeigt, wie Sie diese Einstellungen hinzufügen. Weitere Informationen zum Arbeiten mit Anwendungseinstellungen finden Sie im Abschnitt Arbeiten mit Anwendungseinstellungen.
Azure-Portal
Verwenden Sie im Azure-Portal die Registerkarte Anwendungseinstellungen, um die Einstellung languageWorkers__java__arguments
oder JAVA_OPTS
hinzuzufügen.
Azure CLI
Sie können den Befehl az functionapp config appsettings set verwenden, um diese Einstellungen hinzuzufügen, wie im folgenden Beispiel für die Option -Djava.awt.headless=true
gezeigt:
az functionapp config appsettings set \
--settings "languageWorkers__java__arguments=-Djava.awt.headless=true" \
--name <APP_NAME> --resource-group <RESOURCE_GROUP>
In diesem Beispiel wird der monitorlose Modus aktiviert. Ersetzen Sie <APP_NAME>
durch den Namen Ihrer Funktions-App und <RESOURCE_GROUP>
durch die Ressourcengruppe.
Drittanbieterbibliotheken
Azure Functions unterstützt die Verwendung von Drittanbieterbibliotheken. Standardmäßig werden alle in der Projektdatei pom.xml
angegebenen Abhängigkeiten automatisch während des Ziels von mvn package
gebündelt. Bibliotheken, die nicht in der Datei pom.xml
als Abhängigkeiten angegeben sind, platzieren Sie in einem lib
-Verzeichnis im Stammverzeichnis der Funktion. Abhängigkeiten im Verzeichnis lib
werden dem Systemklassen-Ladeprogramm zur Laufzeit hinzugefügt.
Die Abhängigkeit com.microsoft.azure.functions:azure-functions-java-library
wird standardmäßig im Klassenpfad bereitgestellt und muss nicht in das Verzeichnis lib
eingeschlossen werden. Darüber hinaus fügt azure-functions-java-worker die hier aufgelisteten Abhängigkeiten dem Klassenpfad hinzu.
Datentypunterstützung
Zum Binden an Eingabe- oder Ausgabebindungen können Sie POJOs (Plain Old Java Objects), in azure-functions-java-library
definierte Typen oder primitive Datentypen wie z.B. „String“ und „Integer“ verwenden.
POJOs
Zum Konvertieren von Eingabedaten in POJO verwendet azure-functions-java-worker die gson-Bibliothek. Als Eingabe für Funktionen verwendete POJO-Typen müssen public
sein.
Binärdaten
Binden Sie binäre Eingaben oder Ausgaben an byte[]
, indem Sie das Feld dataType
in der Datei „function.json“ auf binary
festlegen:
@FunctionName("BlobTrigger")
@StorageAccount("AzureWebJobsStorage")
public void blobTrigger(
@BlobTrigger(name = "content", path = "myblob/{fileName}", dataType = "binary") byte[] content,
@BindingName("fileName") String fileName,
final ExecutionContext context
) {
context.getLogger().info("Java Blob trigger function processed a blob.\n Name: " + fileName + "\n Size: " + content.length + " Bytes");
}
Wenn Sie NULL-Werte erwarten, verwenden Sie Optional<T>
.
Bindungen
Eingabe- und Ausgabebindungen bieten eine deklarative Möglichkeit, aus Code heraus Verbindungen mit Daten herzustellen. Eine Funktion kann mehrere Eingabe- und Ausgabebindungen aufweisen.
Beispiel für eine Eingabebindung
package com.example;
import com.microsoft.azure.functions.annotation.*;
public class Function {
@FunctionName("echo")
public static String echo(
@HttpTrigger(name = "req", methods = { HttpMethod.PUT }, authLevel = AuthorizationLevel.ANONYMOUS, route = "items/{id}") String inputReq,
@TableInput(name = "item", tableName = "items", partitionKey = "Example", rowKey = "{id}", connection = "AzureWebJobsStorage") TestInputData inputData,
@TableOutput(name = "myOutputTable", tableName = "Person", connection = "AzureWebJobsStorage") OutputBinding<Person> testOutputData
) {
testOutputData.setValue(new Person(httpbody + "Partition", httpbody + "Row", httpbody + "Name"));
return "Hello, " + inputReq + " and " + inputData.getKey() + ".";
}
public static class TestInputData {
public String getKey() { return this.rowKey; }
private String rowKey;
}
public static class Person {
public String partitionKey;
public String rowKey;
public String name;
public Person(String p, String r, String n) {
this.partitionKey = p;
this.rowKey = r;
this.name = n;
}
}
}
Diese Funktion rufen Sie mit einer HTTP-Anforderung auf.
- Die Nutzlast der HTTP-Anforderung wird dem Argument
inputReq
alsString
übergeben. - Ein Eintrag wird aus Table Storage abgerufen und dem Argument
inputData
alsTestInputData
übergeben.
Sie können eine Bindung mit String[]
, POJO[]
, List<String>
oder List<POJO>
herstellen, um eine Reihe von Eingaben zu erhalten.
@FunctionName("ProcessIotMessages")
public void processIotMessages(
@EventHubTrigger(name = "message", eventHubName = "%AzureWebJobsEventHubPath%", connection = "AzureWebJobsEventHubSender", cardinality = Cardinality.MANY) List<TestEventData> messages,
final ExecutionContext context)
{
context.getLogger().info("Java Event Hub trigger received messages. Batch size: " + messages.size());
}
public class TestEventData {
public String id;
}
Diese Funktion wird immer dann ausgelöst, wenn im konfigurierten Event Hub neue Daten vorliegen. Da die cardinality
auf MANY
festgelegt ist, empfängt die Funktion einen Batch von Nachrichten vom Event Hub. EventData
aus Event Hub wird für die Ausführung der Funktion in TestEventData
konvertiert.
Beispiel für eine Ausgabebindung
Mit $return
können Sie eine Ausgabebindung an den Rückgabewert binden.
package com.example;
import com.microsoft.azure.functions.annotation.*;
public class Function {
@FunctionName("copy")
@StorageAccount("AzureWebJobsStorage")
@BlobOutput(name = "$return", path = "samples-output-java/{name}")
public static String copy(@BlobTrigger(name = "blob", path = "samples-input-java/{name}") String content) {
return content;
}
}
Wenn mehrere Ausgabebindungen vorhanden sind, verwenden Sie den Rückgabewert für nur eine davon.
Um mehrere Ausgabewerte zu senden, verwenden Sie OutputBinding<T>
gemäß der Definition im Paket azure-functions-java-library
.
@FunctionName("QueueOutputPOJOList")
public HttpResponseMessage QueueOutputPOJOList(@HttpTrigger(name = "req", methods = { HttpMethod.GET,
HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
@QueueOutput(name = "itemsOut", queueName = "test-output-java-pojo", connection = "AzureWebJobsStorage") OutputBinding<List<TestData>> itemsOut,
final ExecutionContext context) {
context.getLogger().info("Java HTTP trigger processed a request.");
String query = request.getQueryParameters().get("queueMessageId");
String queueMessageId = request.getBody().orElse(query);
itemsOut.setValue(new ArrayList<TestData>());
if (queueMessageId != null) {
TestData testData1 = new TestData();
testData1.id = "msg1"+queueMessageId;
TestData testData2 = new TestData();
testData2.id = "msg2"+queueMessageId;
itemsOut.getValue().add(testData1);
itemsOut.getValue().add(testData2);
return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + queueMessageId).build();
} else {
return request.createResponseBuilder(HttpStatus.INTERNAL_SERVER_ERROR)
.body("Did not find expected items in CosmosDB input list").build();
}
}
public static class TestData {
public String id;
}
Diese Funktion rufen Sie für ein HttpRequest
-Objekt auf. Sie schreibt mehrere Werte in Queue Storage.
HttpRequestMessage und HttpResponseMessage
Diese sind in azure-functions-java-library
definiert. Dies sind Hilfstypen, um mit HttpTrigger-Funktionen zu arbeiten.
Spezialisierter Typ | Ziel | Typische Verwendung |
---|---|---|
HttpRequestMessage<T> |
HTTP-Trigger | Ruft die Methode, Header oder Abfragen ab |
HttpResponseMessage |
HTTP-Ausgabebindung | Gibt einen anderen Status als 200 zurück |
Metadaten
Einige Trigger senden Triggermetadaten zusammen mit den Eingabedaten. Sie können die Anmerkung @BindingName
für die Bindung an Triggermetadaten verwenden.
package com.example;
import java.util.Optional;
import com.microsoft.azure.functions.annotation.*;
public class Function {
@FunctionName("metadata")
public static String metadata(
@HttpTrigger(name = "req", methods = { HttpMethod.GET, HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) Optional<String> body,
@BindingName("name") String queryValue
) {
return body.orElse(queryValue);
}
}
Im vorherigen Beispiel ist queryValue
an den Abfragezeichenfolgen-Parameter name
in der HTTP-Anforderungs-URL http://{example.host}/api/metadata?name=test
gebunden. Es folgt ein weiteres Beispiel für die Bindung an die Id
aus den Metadaten des Warteschlangentriggers.
@FunctionName("QueueTriggerMetadata")
public void QueueTriggerMetadata(
@QueueTrigger(name = "message", queueName = "test-input-java-metadata", connection = "AzureWebJobsStorage") String message,@BindingName("Id") String metadataId,
@QueueOutput(name = "output", queueName = "test-output-java-metadata", connection = "AzureWebJobsStorage") OutputBinding<TestData> output,
final ExecutionContext context
) {
context.getLogger().info("Java Queue trigger function processed a message: " + message + " with metadataId:" + metadataId );
TestData testData = new TestData();
testData.id = metadataId;
output.setValue(testData);
}
Hinweis
Der in der Anmerkung angegebene Name muss der Metadateneigenschaft entsprechen.
Ausführungskontext
Der in der azure-functions-java-library
definierte ExecutionContext
enthält Hilfsmethoden für die Kommunikation mit der Funktionsruntime. Weitere Informationen finden Sie im Referenzartikel zur Schnittstelle „ExecutionContext“.
Protokollierungstool
Verwenden Sie den im ExecutionContext
definierten getLogger
zum Schreiben von Protokollen aus Funktionscode.
Beispiel:
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.*;
public class Function {
public String echo(@HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) String req, ExecutionContext context) {
if (req.isEmpty()) {
context.getLogger().warning("Empty request body received by function " + context.getFunctionName() + " with invocation " + context.getInvocationId());
}
return String.format(req);
}
}
Anzeigen von Protokollen und Ablaufverfolgung
Mit der Azure CLI können Sie die Java-Protokollierung von stdout und stderr sowie andere Anwendungsprotokolle streamen.
Nachfolgend wird erläutert, wie Sie Ihre Funktions-App so konfigurieren, dass die Anwendungsprotokollierung mithilfe der Azure CLI geschrieben wird:
az webapp log config --name functionname --resource-group myResourceGroup --application-logging true
Zum Streaming der Protokollausgabe Ihrer Funktions-App mithilfe der Azure CLI öffnen Sie eine neue Eingabeaufforderungs-, Bash- oder Terminalsitzung und geben den folgenden Befehl ein:
Der Befehl az webapp log tail ermöglicht das Filtern der Ausgabe mithilfe der Option --provider
.
Zum Herunterladen der Protokolldateien als eine einzelne ZIP-Datei mithilfe der Azure CLI öffnen Sie eine neue Eingabeaufforderungs-, Bash- oder Terminalsitzung, und geben Sie den folgenden Befehl ein:
az webapp log download --resource-group resourcegroupname --name functionappname
Die Dateisystemprotokollierung muss im Azure-Portal oder in der Azure CLI aktiviert sein, bevor Sie diesen Befehl ausführen können.
Umgebungsvariablen
In Functions werden App-Einstellungen, z.B. Dienstverbindungszeichenfolgen, während der Ausführung als Umgebungsvariablen verfügbar gemacht. Sie können über System.getenv("AzureWebJobsStorage")
auf diese Einstellungen zugreifen.
Im folgenden Beispiel wird die Anwendungseinstellung mit dem Schlüssel myAppSetting
ermittelt:
public class Function {
public String echo(@HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) String req, ExecutionContext context) {
context.getLogger().info("My app setting value: "+ System.getenv("myAppSetting"));
return String.format(req);
}
}
Verwenden der Abhängigkeitsinjektion in Java-Funktionen
Azure Functions Java unterstützt das Softwareentwurfsmuster „Abhängigkeitsinjektion“ (Dependency Injection, DI). Damit kann eine Umkehrung der Steuerung (Inversion of Control, IoC) zwischen Klassen und ihren Abhängigkeiten erreicht werden. Java Azure Functions bietet einen Hook für die Integration in gängige Dependency Injection-Frameworks in Ihren Funktions-Apps. Azure Functions Java SPI enthält die Schnittstelle FunctionInstanceInjector. Durch die Implementierung dieser Schnittstelle können Sie eine Instanz Ihrer Funktionsklasse zurückgeben, und Ihre Funktionen werden für diese Instanz aufgerufen. Dies bietet Frameworks wie Spring, Quarkus, Google Guice, Dagger usw. die Möglichkeit, die Funktionsinstanz zu erstellen und in ihrem IOC-Container zu registrieren. Dies bedeutet, dass Sie diese Dependency Injection-Frameworks verwenden können, um Ihre Funktionen auf natürliche Weise zu verwalten.
Hinweis
Microsoft Azure Functions Java SPI-Typen (azure-function-java-spi) ist ein Paket, das alle SPI-Schnittstellen enthält, die Drittanbietern für die Interaktion mit Microsoft Azure Functions Runtime ermöglichen.
Funktionsinstanzinjektor für Abhängigkeitsinjektion
azure-function-java-spi enthält die Schnittstelle „FunctionInstanceInjector“
package com.microsoft.azure.functions.spi.inject;
/**
* The instance factory used by DI framework to initialize function instance.
*
* @since 1.0.0
*/
public interface FunctionInstanceInjector {
/**
* This method is used by DI framework to initialize the function instance. This method takes in the customer class and returns
* an instance create by the DI framework, later customer functions will be invoked on this instance.
* @param functionClass the class that contains customer functions
* @param <T> customer functions class type
* @return the instance that will be invoked on by azure functions java worker
* @throws Exception any exception that is thrown by the DI framework during instance creation
*/
<T> T getInstance(Class<T> functionClass) throws Exception;
}
Weitere Beispiele, die FunctionInstanceInjector zur Integration in Dependency Injection-Frameworks verwenden, finden Sie in diesem Repository.
Nächste Schritte
Weitere Informationen zur Java-Entwicklung für Azure Functions finden Sie in den folgenden Ressourcen:
- Bewährte Methoden für Azure Functions
- Entwicklerreferenz zu Azure Functions
- Trigger und Bindungen in Azure Functions
- Lokale Entwicklung und Debuggen mit Visual Studio Code, IntelliJ und Eclipse
- Remotedebuggen von Java-Funktionen mit Visual Studio Code
- Maven-Plug-In für Azure Functions
- Optimieren der Erstellung von Funktionen mithilfe des Ziels
azure-functions:add
und Vorbereiten eines Stagingverzeichnisses für die Bereitstellung von ZIP-Dateien.