Az Azure Functions Java fejlesztői útmutatója

Ez az útmutató részletes információkat tartalmaz az Azure Functions Java használatával történő sikeres fejlesztéséhez.

Java-fejlesztőként, ha még csak most ismerkedik az Azure Functions szolgáltatással, érdemes elolvasnia az alábbi cikkek egyikét:

Java-függvények alapjai

A Java-függvények a public széljegyzetekkel @FunctionNamedíszített metódusok. Ez a metódus egy Java-függvény bejegyzését határozza meg, és egyedinek kell lennie egy adott csomagban. A csomag több osztályt is tartalmazhat, amelyekhez több nyilvános metódust is jegyzetelnek @FunctionName. Egyetlen csomag van üzembe helyezve egy függvényalkalmazásban az Azure-ban. Az Azure-ban a függvényalkalmazás biztosítja az egyes Java-függvények üzembe helyezési, végrehajtási és felügyeleti környezetét.

Programozási modell

Az eseményindítók és kötések fogalmai alapvető fontosságúak az Azure Functionsben. Az eseményindítók elindítják a kód végrehajtását. A kötések lehetővé teszik, hogy adatokat továbbítson és visszaadjon egy függvényből anélkül, hogy egyéni adatelérési kódot kellene írnia.

Java-függvények létrehozása

A Java-függvények létrehozásának megkönnyítése érdekében vannak Maven-alapú eszközök és archetípusok, amelyek előre definiált Java-sablonokat használnak egy adott függvényindítóval rendelkező projektek létrehozásához.

Maven-alapú eszközhasználat

Az alábbi fejlesztői környezetek Azure Functions-eszközkészlettel rendelkeznek, amelyekkel Java-függvényprojekteket hozhat létre:

• Visual Studio Code
• Eclipse
• IntelliJ

Ezek a cikkek bemutatják, hogyan hozhatja létre első függvényeit a választott IDE használatával.

Projektállványok

Ha a terminál parancssori fejlesztését részesíti előnyben, a legegyszerűbben úgy építheti ki a Java-alapú függvényprojekteket, ha archetípusokat használ Apache Maven . Az Azure Functions Java Maven-archetípusa a következő groupId:artifactId: com.microsoft.azure:azure-functions-archetype alatt érhető el.

A következő parancs létrehoz egy új Java-függvényprojektet ezzel az archetípussal:

mvn archetype:generate \
    -DarchetypeGroupId=com.microsoft.azure \
    -DarchetypeArtifactId=azure-functions-archetype

mvn archetype:generate ^
    -DarchetypeGroupId=com.microsoft.azure ^
    -DarchetypeArtifactId=azure-functions-archetype

Az archetípus használatának megkezdéséhez tekintse meg a Java rövid útmutatót.

Mappastruktúra

Egy Azure Functions Java-projekt mappastruktúrája:

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

A függvényalkalmazás konfigurálásához használhat megosztott host.json fájlt. Minden függvény saját kódfájllal (.java) és kötéskonfigurációs fájllal (function.json) rendelkezik.

Egy projektben több függvény is lehet. A függvényeket azonban ne helyezze külön üvegekbe. Több jars használata egyetlen függvényalkalmazásban nem támogatott. A FunctionApp célkönyvtárban az lesz üzembe helyezve a függvényalkalmazás az Azure-ban.

Eseményindítók és széljegyzetek

A függvényeket eseményindítók, például HTTP-kérések, időzítők vagy adatfrissítések hívják meg. A függvénynek feldolgoznia kell ezt az eseményindítót és minden más bemenetet egy vagy több kimenet létrehozásához.

A com.microsoft.azure.functions.annotation.* csomagban található Java-széljegyzetekkel a bemeneteket és kimeneteket a metódusokhoz kötheti. További információkért tekintse meg a Java referencia-dokumentációt.

Példa:

public class Function {
    public String echo(@HttpTrigger(name = "req", 
      methods = {HttpMethod.POST},  authLevel = AuthorizationLevel.ANONYMOUS) 
        String req, ExecutionContext context) {
        return String.format(req);
    }
}

Az azure-functions-maven-beépülő modul által létrehozottfunction.json:

{
  "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-verziók

A Java azon verziója, amelyen az alkalmazás az Azure-ban fut, a pom.xml fájlban van megadva. A Maven archetípus jelenleg egy pom.xml hoz létre a Java 8-hoz, amelyet a közzététel előtt módosíthat. Az pom.xml Java-verziójának meg kell egyeznie az alkalmazás helyi fejlesztésével és tesztelésével.

Támogatott verziók

Az alábbi táblázat a Functions-futtatókörnyezet minden főverziójához az aktuálisan támogatott Java-verziókat mutatja be operációs rendszer szerint:

Ha nem ad meg Java-verziót az üzembe helyezéshez, a Maven archetípusa alapértelmezés szerint Java 8 lesz az Azure-ba való üzembe helyezés során.

Az üzembehelyezési verzió megadása

A Paraméterrel -DjavaVersion szabályozhatja a Maven-archetípus által megcélzott Java-verziót. Ennek a paraméternek az értéke lehet 8, 1117 vagy 21.

A Maven archetípus létrehoz egy pom.xml, amely a megadott Java-verziót célozza. A pom.xml következő elemei a használni kívánt Java-verziót jelölik:

Az alábbi példák a Java 8 beállításait mutatják be a pom.xml fájl megfelelő szakaszaiban:

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>

Az üzembehelyezési operációs rendszer megadása

A Maven azt az operációs rendszert is megadja, amelyen a függvényalkalmazás fut az Azure-ban. os Az elem használatával válassza ki az operációs rendszert.

Az alábbi példa az operációs rendszer beállítását mutatja be a runtime pom.xml fájl szakaszában:

<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>

JDK-futtatókörnyezet rendelkezésre állása és támogatása

Az OpenJDK Microsoft- és Adoptium-buildjei a Java 8-hoz (Adoptium), Java 11-hez, 17-hez és 21-hez készült Függvényeken (MSFT) érhetők el és támogatottak. Ezek a bináris fájlok az Azure-hoz készült OpenJDK költségmentes, többplatformos, éles használatra kész disztribúciójaként érhetők el. A Java SE-alkalmazások létrehozásához és futtatásához szükséges összes összetevőt tartalmazzák.

A helyi fejlesztéshez vagy teszteléshez ingyenesen letöltheti az OpenJDK vagy az Adoptium Temurin bináris fájlok Microsoft-buildét. A JDK-kkal és a függvényalkalmazásokkal kapcsolatos problémák Azure-támogatás minősített támogatási csomaggal érhetők el.

Ha továbbra is használni szeretné a Zulu for Azure bináris fájlokat a függvényalkalmazásban, ennek megfelelően konfigurálja az alkalmazást. A webhelyhez továbbra is használhatja az Azul bináris fájlokat. A biztonsági javítások és fejlesztések azonban csak az OpenJDK új verzióiban érhetők el. Emiatt végül el kell távolítania ezt a konfigurációt, hogy az alkalmazások a Java legújabb elérhető verzióját használják.

JVM testreszabása

A Functions lehetővé teszi a Java-függvények futtatásához használt Java virtuális gép (JVM) testreszabását. Alapértelmezés szerint a következő JVM-beállításokat használja a rendszer:

• -XX:+TieredCompilation
• -XX:TieredStopAtLevel=1
• -noverify
• -Djava.net.preferIPv4Stack=true
• -jar

A JVM-nek más argumentumokat is megadhat a következő alkalmazásbeállítások egyikével, a csomag típusától függően:

Az alábbi szakaszok bemutatják, hogyan adhatja hozzá ezeket a beállításokat. Az alkalmazásbeállítások használatával kapcsolatos további információkért tekintse meg az Alkalmazásbeállítások használata című szakaszt .

Azure Portal

Az Azure Portalon az Alkalmazásbeállítások lapon adja hozzá a beállítást vagy a languageWorkers__java__arguments JAVA_OPTS beállítást.

Azure CLI

Az az functionapp config appsettings set paranccsal hozzáadhatja ezeket a beállításokat, ahogyan az a következő példában látható a -Djava.awt.headless=true beállításhoz:

az functionapp config appsettings set \
    --settings "languageWorkers__java__arguments=-Djava.awt.headless=true" \
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

az functionapp config appsettings set ^
    --settings "languageWorkers__java__arguments=-Djava.awt.headless=true" ^
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

az functionapp config appsettings set \
    --settings "JAVA_OPTS=-Djava.awt.headless=true" \
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

az functionapp config appsettings set ^
    --settings "JAVA_OPTS=-Djava.awt.headless=true" ^
    --name <APP_NAME> --resource-group <RESOURCE_GROUP>

Ez a példa lehetővé teszi a fej nélküli módot. Cserélje le <APP_NAME> a függvényalkalmazás nevére és <RESOURCE_GROUP> az erőforráscsoportra.

Külső kódtárak

Az Azure Functions támogatja a külső kódtárak használatát. Alapértelmezés szerint a projektfájlban megadott összes függőséget a rendszer pom.xml automatikusan kötegeli a mvn package cél során. A fájlban pom.xml függőségként nem megadott kódtárak esetén helyezze őket a függvény gyökérkönyvtárába.lib A címtárban lib elhelyezett függőségek futásidőben lesznek hozzáadva a rendszerosztály-betöltőhöz.

A com.microsoft.azure.functions:azure-functions-java-library függőség alapértelmezés szerint az osztályúton van megadva, és nem kell szerepelnie a lib címtárban. Emellett az azure-functions-java-worker hozzáadja az itt felsorolt függőségeket az osztályúthoz.

Adattípus támogatása

A bemeneti vagy kimeneti kötésekhez egyszerű régi Java-objektumokat (POJO-kat), a benne definiált azure-functions-java-librarytípusokat vagy a primitív adattípusokat, például a Sztringet és az Egész számot használhatja.

POJO-k

A bemeneti adatok POJO-ra való konvertálásához az azure-functions-java-worker a gson-kódtárat használja. A függvények bemeneteként használt POJO-típusoknak a következőknek kell lenniük public: .

Bináris adatok

Bináris bemenetek vagy kimenetek kötése a következőhöz byte[]a function.json binarymezőjének beállításávaldataType:

   @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");
    }

Ha null értékre számít, használja a következőt Optional<T>: .

Kötések

A bemeneti és kimeneti kötések deklaratív módon csatlakozhatnak a kódon belüli adatokhoz. Egy függvény több bemeneti és kimeneti kötéssel is rendelkezhet.

Példa bemeneti kötésre

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;
        }
    }
}

Ezt a függvényt HTTP-kéréssel hívhatja meg.

• A HTTP-kérés hasznos adatai az argumentum inputReqrészeként String kerülnek átadásra.
• A rendszer egy bejegyzést kér le a Table Storage-ból, és átadja TestInputData az argumentumnak inputData.

A bemenetek kötegének fogadásához kapcsolódhat String[]a , POJO[], List<String>vagy List<POJO>.

@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;
}

Ez a függvény akkor aktiválódik, amikor új adatok találhatók a konfigurált eseményközpontban. Mivel a cardinality beállítás értéke MANY, a függvény üzenetköteget fogad az eseményközpontból. EventData az eseményközpontból a függvény végrehajtásához konvertálódik TestEventData .

Példa kimeneti kötésre

A kimeneti kötéseket a visszatérési értékhez kötheti a használatával $return.

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;
    }
}

Ha több kimeneti kötés is van, csak az egyiknél használja a visszatérési értéket.

Több kimeneti érték küldéséhez használja OutputBinding<T> a csomagban definiált azure-functions-java-library értéket.

@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;
    }

Ezt a függvényt egy HttpRequest objektumon hívja meg. Több értéket ír a Queue Storage-ba.

HttpRequestMessage és HttpResponseMessage

Ezek a következőben vannak definiálva azure-functions-java-library: . Ezek segédtípusok a HttpTrigger-függvények használatához.

Metaadatok

Kevés eseményindító küld eseményindító metaadatokat a bemeneti adatokkal együtt. A metaadatok aktiválásához széljegyzeteket @BindingName használhat.

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);
    }
}

Az előző példában a queryValue http-kérelem URL-címében található lekérdezési sztring paraméterhez name van kötve. http://{example.host}/api/metadata?name=test Íme egy másik példa, amely bemutatja, hogyan lehet csatlakozni az Id üzenetsor-eseményindító metaadataihoz.

 @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);
    }

Végrehajtás környezete

ExecutionContext, definiálva a azure-functions-java-libraryfüggvények futtatókörnyezetével való kommunikáció segítő módszereit tartalmazza. További információ: ExecutionContext referenciacikk.

Tuskózó

A függvénykód naplóinak írásához használja getLoggera benne ExecutionContextdefiniált naplókat.

Példa:

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);
    }
}

Naplók és nyomkövetés megtekintése

Az Azure CLI használatával streamelheti a Java stdout- és stderr-naplózást, valamint egyéb alkalmazásnaplózást.

Így konfigurálhatja a függvényalkalmazást alkalmazásnaplózás írására az Azure CLI használatával:

az webapp log config --name functionname --resource-group myResourceGroup --application-logging true

az webapp log config --name functionname --resource-group myResourceGroup --application-logging true

Ha az Azure CLI használatával szeretné streamelni a függvényalkalmazás naplózási kimenetét, nyisson meg egy új parancssort, Bash-t vagy terminál-munkamenetet, és írja be a következő parancsot:

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

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

Az az webapp log tail parancs lehetőségekkel szűri a kimenetet a --provider beállítás használatával.

Ha a naplófájlokat egyetlen ZIP-fájlként szeretné letölteni az Azure CLI használatával, nyisson meg egy új parancssort, Basht vagy Terminál munkamenetet, és írja be a következő parancsot:

az webapp log download --resource-group resourcegroupname --name functionappname

A parancs futtatása előtt engedélyeznie kell a fájlrendszer naplózását az Azure Portalon vagy az Azure CLI-ben.

Környezeti változók

A Functionsben az alkalmazásbeállítások, például a szolgáltatás kapcsolati sztring környezeti változókként jelennek meg a végrehajtás során. Ezeket a beállításokat a következővel érheti el: System.getenv("AzureWebJobsStorage").

Az alábbi példa lekéri az alkalmazásbeállítást a következő kulccsal myAppSetting:

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);
    }
}

Függőséginjektálás használata a Java Functionsben

Az Azure Functions Java támogatja a függőséginjektálási (DI) szoftvertervezési mintát, amely az osztályok és függőségeik közötti vezérlési (IoC) inverzió elérésének technikája. A Java Azure Functions egy horoggal integrálható a Népszerű függőséginjektálási keretrendszerekkel a Functions Appsben. Az Azure Functions Java SPI egy FunctionInstanceInjector felületet tartalmaz. Ennek az interfésznek a implementálásával visszaadhatja a függvényosztály egy példányát, és a függvényeket a rendszer meghívja ezen a példányon. Ez olyan keretrendszereket biztosít, mint a Spring, a Quarkus, a Google Guice, a Tőr stb. a függvénypéldány létrehozására és regisztrálására az IOC-tárolóban. Ez azt jelenti, hogy ezeket a függőséginjektálási keretrendszereket használhatja a függvények természetes kezeléséhez.

Függvénypéldány injektálója függőséginjektáláshoz

az azure-function-java-spi egy FunctionInstanceInjector interfészt tartalmaz

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; 

} 

További példákért, amelyek a FunctionInstanceInjectort használják a függőséginjektálási keretrendszerekkel való integrálásra, tekintse meg ezt az adattárat.

Következő lépések

Az Azure Functions Java fejlesztésével kapcsolatos további információkért tekintse meg a következő erőforrásokat:

• Azure Functions – ajánlott eljárások
• Az Azure Functions fejlesztői segédanyagai
• Az Azure Functions eseményindítói és kötései
• Helyi fejlesztés és hibakeresés a Visual Studio Code, az IntelliJ és az Eclipse használatával
• Java-függvények távoli hibakeresése a Visual Studio Code használatával
• Maven beépülő modul az Azure Functionshez
• Egyszerűsítse a függvények létrehozását a azure-functions:add célon keresztül, és készítsen elő egy átmeneti könyvtárat a ZIP-fájlok üzembe helyezéséhez.