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:

Első lépések Fogalmak Forgatókönyvek/minták

Java-függvények alapjai

A Java-függvény egy public aannotációval @FunctionNamedíszített metódus. 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, amelyek több nyilvános metódusra vannak annotálva @FunctionName-vel. 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:

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

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 JAR fájlokba. Több jars használata egyetlen függvényalkalmazásban nem támogatott. Az FunctionApp a célkönyvtárban kerül üzembe helyezésre a függvényalkalmazásodhoz 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.

Fontos

Konfigurálnia kell egy Azure Storage-fiókot a local.settings.json az Azure Blob Storage, az Azure Queue Storage vagy az Azure Table Storage eseményindítóinak helyi futtatásához.

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

** Íme a(z) function.json által generált megfelelő :

{
  "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 fájlban meg van jelölve az a Java verzió, amelyen az alkalmazásod Azure-ban pom.xml fut. Ha nem jelölsz meg Java verziót a projekt generálásakor, a Maven archetípus generál egy pom.xml fájlt a Java 17-hez. A Java verziónak pom.xml meg kell egyeznie azzal a Java verzióval, amelyen helyben fejleszted és teszteled az alkalmazásodat.

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:

Függvények verziója Java-verziók (Windows) Java-verziók (Linux)
4.x 21
17
11
8		 21
17
11
8
3.x 11
8		 11
8
2.x 8 n.a.

Fontos

Ha egy meglévő Java 8, 11 vagy 17 alkalmazás Linux Elastic Premium vagy Dedikált (App Service) csomagon Debian Bullseye által kezelt képet használ, frissítse az alkalmazást Ubuntu Noble képre, hogy továbbra is támogatott Linux disztribúción maradjon.

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 meg kell egyeznie a támogatott Java-verziókkal.

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:

Elem Java 8-érték Java 11-érték Java 17-érték Java 21-érték Leírás
Java.version 1.8 11 17 21 A Maven-compiler-plugin által használt Java-verzió.
JavaVersion 8 11 17 21 Az Azure-ban a függvényalkalmazás által üzemeltetett Java-verzió.

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>

Fontos

A JAVA_HOME környezeti változót helyesen kell beállítania a Maven használatával végzett kódírás során használt JDK-könyvtárra. Győződjön meg arról, hogy a JDK verziója legalább olyan magas, mint a Java.version beállítás.

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.

Elem Windows Linux Docker
os windows linux docker

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:

Konstrukció típusa Név beállítása Megjegyzés
Használati terv languageWorkers__java__arguments Ez a beállítás növeli a fogyasztási tervben futó Java-függvények hideg kezdési idejét.
Prémium csomag
Dedikált terv		 JAVA_OPTS

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 Portálon az Alkalmazásbeállítások lapon adja hozzá vagy a languageWorkers__java__arguments, vagy a JAVA_OPTS beállítást.

Azure CLI

Az functionapp config appsettings set parancs segítségével 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>

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önyvtárak

Az Azure Functions támogatja a külső kódtárak használatát. Alapértelmezés szerint a projekt pom.xml fájlban megadott összes függőséget a rendszer automatikusan kötegeli a mvn package művelet során. A pom.xml fájlban nem függőségként megadott könyvtárak esetén helyezze őket egy lib könyvtárba, amely a függvény gyökérkönyvtárában található. A lib könyvtárban elhelyezett függőségek futásidőben lesznek hozzáadva a rendszer osztálybetö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

Használhat egyszerű régi Java-objektumokat (POJO-kat), a azure-functions-java-library keretrendszerben definiált típusokat, illetve primitív adattípusokat, mint például a String és a Integer a bemeneti vagy kimeneti kötésekhez való kötéshez.

Feljegyzés

Az SDK-típusokhoz való kötés támogatása jelenleg előzetes verzióban érhető el, és az Azure Blob Storage SDK-ra korlátozódik. További információ: SDK-típusok a Java-referenciacikkben.

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 hozzárendelése a(z) byte[]-hez, a function.json fájlban a dataType mezőt beállítva binary-re.

   @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>: .

SDK-típusok (előzetes verzió)

Jelenleg ezeket a Blob Storage SDK-típusokat használhatja a kötésekben: BlobClient és BlobContainerClient.

Ha engedélyezve van az SDK-típusok támogatása, a függvények az Azure SDK-ügyféltípusok használatával közvetlenül a tárolóból származó streamekként férhetnek hozzá a blobokhoz, ami a POJ-k vagy bináris típusok esetében nyújtja ezeket az előnyöket:

  • Kisebb késés
  • Csökkentett memóriaigény
  • Eltávolítja a kérelemalapú méretkorlátokat (a szolgáltatás alapértelmezéseit használja)
  • Hozzáférést biztosít a teljes SDK-felülethez: metaadatokhoz, ACL-ekhez, jogi visszatartásokhoz és egyéb SDK-specifikus adatokhoz.

Követelmények

  • Állítsa be az JAVA_ENABLE_SDK_TYPES alkalmazásbeállítást az true SDK-típusok engedélyezéséhez.
  • azure-functions-maven-plugin (vagy Gradle beépülő modul) 1.38.0 vagy magasabb verzió.

Példák

Az BlobClient használatával a blob tulajdonságaihoz hozzáférő blob-trigger.

@FunctionName("processBlob")
public void run(
        @BlobTrigger(
                name = "content",
                path = "images/{name}",
                connection = "AzureWebJobsStorage") BlobClient blob,
        @BindingName("name") String file,
        ExecutionContext ctx)
{
    ctx.getLogger().info("Size = " + blob.getProperties().getBlobSize());
}

Blob-eseményindító, amely a tárolóban lévő blobok adatainak eléréséhez használja BlobContainerClient .

@FunctionName("containerOps")
public void run(
        @BlobTrigger(
                name = "content",
                path = "images/{name}",
                connection = "AzureWebJobsStorage") BlobContainerClient container,
        ExecutionContext ctx)
{
    container.listBlobs()
            .forEach(b -> ctx.getLogger().info(b.getName()));
}

A blob bemeneti kötése, amely a végrehajtást kiváltó blob információinak összeszedésére szolgál, BlobClient használja.

@FunctionName("checkAgainstInputBlob")
public void run(
        @BlobInput(
                name = "inputBlob",
                path = "inputContainer/input.txt") BlobClient inputBlob,
        @BlobTrigger(
                name = "content",
                path = "images/{name}",
                connection = "AzureWebJobsStorage",
                dataType = "string") String triggerBlob,
        ExecutionContext ctx)
{
    ctx.getLogger().info("Size = " + inputBlob.getProperties().getBlobSize());
}

Megfontolások

  • A dataType beállítás figyelmen kívül van hagyva, amikor az SDK-típushoz való kötés történik @BlobTrigger.
  • Jelenleg csak egy SDK-típus használható egyszerre egy adott függvénydefinícióban. Ha egy függvény rendelkezik blog-eseményindítóval vagy bemeneti kötéssel és Blob kimeneti kötéssel is, az egyik kötés SDK-típust (például BlobClient) használhat, a többinek pedig natív típust vagy POJO-t kell használnia.
  • A felügyelt identitásokat SDK-típusok használatával is használhatja.

Hibaelhárítás

Ezek olyan lehetséges hibák, amelyek SDK-típusok használatakor fordulhatnak elő:

Kivétel Értelmezés
SdkAnalysisException A build beépülő modul nem tudott metaadatokat létrehozni. Ennek oka lehet, hogy egyetlen függvénydefinícióban duplikált SDK-típusok, nem támogatott paramétertípus vagy valamilyen más helytelen konfiguráció szerepel.
SdkRegistryException A futtatókörnyezet nem ismeri fel a tárolt Teljesen Kvalifikált Osztálynevet (FQCN), amelyet a kódtár eltérő verziói okozhatnak.
SdkHydrationException A Middleware nem tudta létrehozni az SDK-ügyfelet, amely a hiányzó környezeti változók, tükröződési hibák, hitelesítő adatok hibái és hasonló futtatókörnyezeti problémák miatt fordulhat elő.
SdkTypeCreationException A Factory nem tudta a metaadatokat a végső SDK-típussá alakítani, amelyet általában casting-problémák okoznak.

A pontos ok további részleteiért tekintse meg a belső üzenetet. Az SDK-típusok legtöbb problémáját hibásan írt környezeti változónevek vagy hiányzó függőségek okozzák.

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ési adatcsomag az argumentum String részeként inputReq kerül á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[], 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. Az eseményközpontból EventData-t alakítanak át TestEventData-re a függvény végrehajtásához.

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 a OutputBinding<T> csomagban definiált 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;
    }

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 HTTP-triggerfüggvények használatához tervezett segédtípusok a következőkben azure-functions-java-libraryvannak definiálva:

Specializált típus Cél Tipikus használat
HttpRequestMessage<T> HTTP-eseményindító Lehívja a metódusokat, fejléceket vagy lekérdezéseket
HttpResponseMessage HTTP kimeneti kötés 200-nál nem régebbi állapotot ad vissza

Metaadatok

Kevés eseményindító küld eseményindító metaadatokat a bemeneti adatokkal együtt. A kioldó metaadatokhoz való kötéshez használhatja a @BindingName jelölést.

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 a HTTP-kérelem URL-címében szereplő 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 kötést létrehozni az Id várólistaindító metaadataival.

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

Feljegyzés

A megjegyzésben megadott névnek meg kell egyeznie a metaadatok tulajdonságával.

Végrehajtás környezete

ExecutionContext, amely a azure-functions-java-library-ban van meghatározva, olyan segítő függvényeket tartalmaz, amelyeket a futtatókörnyezettel való kommunikációhoz használnak. További információ: ExecutionContext referenciacikk.

Tuskózó

A naplók írásához a függvénykódból használja a getLogger-t, amely a ExecutionContext-ben van definiálva.

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

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 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 eszközt kínál népszerű függőségi injektálási keretrendszerekkel történő integrációra a Functions-alkalmazásokban. Az Azure Functions Java SPI egy FunctionInstanceInjector felületet tartalmaz. Az interfész implementálásával visszaadhatja a függvényosztály egy példányát, és a függvények meghívása ezen a példányon lesz. Ez olyan keretrendszereknek ad képességet, mint a Spring, a Quarkus, a Google Guice, a Dagger stb., hogy létrehozzák a függvénypéldányt és regisztrálják azt az IOC-tárolóban. Ez azt jelenti, hogy ezeket a dependency injection keretrendszereket használhatja a függvények természetes módon történő kezeléséhez.

Feljegyzés

A Microsoft Azure Functions Java SPI-típusok (azure-function-java-spi) egy olyan csomag, amely harmadik felek számára az összes SPI-felületet tartalmazza a Microsoft Azure-függvények futtatókörnyezetével való interakcióhoz.

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:

  • Last updated on