Teilen über

Java-Entwicklerhandbuch für Azure Functions

  • Artikel

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 als String übergeben.
  • Ein Eintrag wird aus Table Storage abgerufen und dem Argument inputData als TestInputData ü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 metadaId:" + 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:

az webapp log tail --name webappname --resource-group myResourceGroup

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: