Megosztás a következőn keresztül:

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

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

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

Az azure-functions-maven-beépülő modulfunction.jsonlétrehozott:

{
  "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 a Java azon verziójával, amelyen az alkalmazást helyileg fejleszti és teszteli.

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:

Functions-verzió 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.

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 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 használati 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 Portalon az Alkalmazásbeállítások lapon adja hozzá a beállítást vagy a languageWorkers__java__argumentsJAVA_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>

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

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 kötése a következőhöz byte[]a function.json dataTypemezőjének beállításávalbinary:

   @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és hasznos adatai az argumentum Stringrészeként inputReq 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 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ó Metódusok, fejlécek vagy lekérdezések lekérdezhetők
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 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);
    }

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

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

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