Guida per sviluppatori Java per Funzioni di AzureAzure Functions Java developer guide

Questa guida contiene informazioni dettagliate che consentono di sviluppare funzioni di Azure con Java.This guide contains detailed information to help you succeed developing Azure Functions using Java.

Gli sviluppatori Java, se non si ha familiarità con funzioni di Azure, si consiglia di leggere prima di tutto uno degli articoli seguenti:As a Java developer, if you're new to Azure Functions, please consider first reading one of the following articles:

Guida introduttivaGetting started ConcettiConcepts

Nozioni fondamentali sulle funzioni JavaJava function basics

Una funzione Java è un metodo public, accompagnato dall'annotazione @FunctionName.A Java function is a public method, decorated with the annotation @FunctionName. Questo metodo definisce la voce per una funzione Java e deve essere unico in un particolare pacchetto.This method defines the entry for a Java function, and must be unique in a particular package. Il pacchetto può avere più classi con più metodi pubblici annotati con @FunctionName .The package can have multiple classes with multiple public methods annotated with @FunctionName. Un singolo pacchetto viene distribuito in un'app per le funzioni in Azure.A single package is deployed to a function app in Azure. Quando è in esecuzione in Azure, l'app per le funzioni fornisce il contesto di distribuzione, esecuzione e gestione per le singole funzioni Java.When running in Azure, the function app provides the deployment, execution, and management context for your individual Java functions.

Modello di programmazioneProgramming model

I concetti di trigger e binding sono fondamentali in Funzioni di Azure.The concepts of triggers and bindings are fundamental to Azure Functions. I trigger avviano l'esecuzione del codice,Triggers start the execution of your code. mentre i binding consentono la trasmissione dei dati e la restituzione dei dati da una funzione, senza dover scrivere codice personalizzato per l'accesso ai dati.Bindings give you a way to pass data to and return data from a function, without having to write custom data access code.

Creare funzioni JavaCreate Java functions

Per semplificare la creazione di funzioni Java, sono disponibili strumenti e archetipi basati su Maven che usano modelli Java predefiniti che consentono di creare progetti con un trigger di funzione specifico.To make it easier to create Java functions, there are Maven-based tooling and archetypes that use predefined Java templates to help you create projects with a specific function trigger.

Strumenti basati su MavenMaven-based tooling

Negli ambienti di sviluppo seguenti sono disponibili strumenti di Funzioni di Azure che consentono di creare progetti di funzioni Java:The following developer environments have Azure Functions tooling that lets you create Java function projects:

I collegamenti agli articoli precedenti illustrano come creare le prime funzioni usando l'IDE preferito.The article links above show you how to create your first functions using your IDE of choice.

Eseguire lo scaffold di un progettoProject Scaffolding

Se si preferisce eseguire lo sviluppo dalla riga di comando dal terminale, il modo più semplice per eseguire lo scaffold dei progetti di funzione basati su Java consiste nell'usare archetipi Apache Maven.If you prefer command line development from the Terminal, the simplest way to scaffold Java-based function projects is to use Apache Maven archetypes. L'archetipo Java Maven per Funzioni di Azure è pubblicato con il seguente groupId:artifactId: com.microsoft.azure:azure-functions-archetype.The Java Maven archetype for Azure Functions is published under the following groupId:artifactId: com.microsoft.azure:azure-functions-archetype.

Il comando seguente genera un nuovo progetto di funzione Java usando questo archetipo:The following command generates a new Java function project using this archetype:

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

Per iniziare a usare questo archetipo, vedere Avvio rapido Java.To get started using this archetype, see the Java quickstart.

Struttura di cartelleFolder structure

Di seguito è illustrata la struttura di cartelle di un progetto Java di Funzioni di Azure:Here is the folder structure of an Azure Functions Java project:

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

È possibile usare un file host.json per configurare l'app per le funzioni.You can use a shared host.json file to configure the function app. Ogni funzione ha il proprio file di codice (con estensione java) e il proprio file di configurazione delle associazioni (function.json).Each function has its own code file (.java) and binding configuration file (function.json).

È possibile inserire più funzioni in un progetto.You can put more than one function in a project. Evitare di inserire le funzioni in file con estensione jar separati.Avoid putting your functions into separate jars. L'elemento FunctionApp nella directory di destinazione viene distribuito all'app per le funzioni in Azure.The FunctionApp in the target directory is what gets deployed to your function app in Azure.

Trigger e annotazioniTriggers and annotations

Le funzioni vengono richiamate da un trigger, ad esempio una richiesta HTTP, un timer o un aggiornamento dati.Functions are invoked by a trigger, such as an HTTP request, a timer, or an update to data. La funzione deve elaborare tale trigger e qualsiasi altro input per generare uno o più output.Your function needs to process that trigger, and any other inputs, to produce one or more outputs.

Usare le annotazioni Java incluse nel pacchetto com.microsoft.azure.functions.annotation.* per associare input e output ai metodi dell'utente.Use the Java annotations included in the com.microsoft.azure.functions.annotation.* package to bind input and outputs to your methods. Per altre informazioni, vedere la documentazione di riferimento per Java.For more information, see the Java reference docs.

Importante

È necessario configurare un account di Archiviazione di Azure nel file local.settings.json per eseguire i trigger di Archivio BLOB di Azure, archiviazione code di Azure o archiviazione tabelle di Azure.You must configure an Azure Storage account in your local.settings.json to run Azure Blob storage, Azure Queue storage, or Azure Table storage triggers locally.

Esempio:Example:

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

ecco il file function.json corrispondente generato da azure-functions-maven-plugin:Here is the generated corresponding function.json by the azure-functions-maven-plugin:

{
  "scriptFile": "azure-functions-example.jar",
  "entryPoint": "com.example.Function.echo",
  "bindings": [
    {
      "type": "httpTrigger",
      "name": "req",
      "direction": "in",
      "authLevel": "anonymous",
      "methods": [ "post" ]
    },
    {
      "type": "http",
      "name": "$return",
      "direction": "out"
    }
  ]
}

Versioni JavaJava versions

La versione di Java usata quando si crea l'app per le funzioni in cui vengono eseguite le funzioni in Azure è specificata nel file di pom.xml.The version of Java used when creating the function app on which functions runs in Azure is specified in the pom.xml file. L'archetipo Maven genera attualmente una pom.xml per Java 8, che è possibile modificare prima di pubblicare.The Maven archetype currently generates a pom.xml for Java 8, which you can change before publishing. La versione di Java in pom.xml deve corrispondere alla versione in cui è stata sviluppata e testata localmente l'app.The Java version in pom.xml should match the version on which you have locally developed and tested your app.

Versioni supportateSupported versions

La tabella seguente mostra le versioni Java supportate correnti per ogni versione principale del runtime di funzioni, per sistema operativo:The following table shows current supported Java versions for each major version of the Functions runtime, by operating system:

Versione di FunzioniFunctions version Versioni Java (Windows)Java versions (Windows) Versioni Java (Linux)Java versions (Linux)
3.x3.x 1111
88
1111
88
2.x2.x 88 n/dn/a

A meno che non si specifichi una versione Java per la distribuzione, l'archetipo di Maven viene impostato su Java 8 durante la distribuzione in Azure.Unless you specify a Java version for your deployment, the Maven archetype defaults to Java 8 during deployment to Azure.

Specificare la versione della distribuzioneSpecify the deployment version

È possibile controllare la versione di Java a cui è destinato l'archetipo Maven usando il -DjavaVersion parametro.You can control the version of Java targeted by the Maven archetype by using the -DjavaVersion parameter. Il valore di questo parametro può essere 8 o 11 .The value of this parameter can be either 8 or 11.

L'archetipo Maven genera un pom.xml destinato alla versione Java specificata.The Maven archetype generates a pom.xml that targets the specified Java version. Gli elementi seguenti in pom.xml indicano la versione di Java da usare:The following elements in pom.xml indicate the Java version to use:

ElementoElement Valore Java 8Java 8 value Valore Java 11Java 11 value DescrizioneDescription
Java.version 1.81.8 1111 Versione di Java usata dal plug-in del compilatore Maven.Version of Java used by the maven-compiler-plugin.
JavaVersion 88 1111 Versione Java ospitata dall'app per le funzioni in Azure.Java version hosted by the function app in Azure.

Gli esempi seguenti illustrano le impostazioni per Java 8 nelle sezioni pertinenti del file pom.xml:The following examples show the settings for Java 8 in the relevant sections of the pom.xml file:

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>

Importante

È necessario impostare correttamente la variabile di ambiente JAVA_HOME sulla directory JDK utilizzata durante la compilazione del codice con Maven.You must have the JAVA_HOME environment variable set correctly to the JDK directory that is used during code compiling using Maven. Verificare che la versione del JDK sia almeno uguale alla massima dell' Java.version impostazione.Make sure that the version of the JDK is at least as high as the Java.version setting.

Specificare il sistema operativo di distribuzioneSpecify the deployment OS

Maven consente inoltre di specificare il sistema operativo in cui viene eseguita l'app per le funzioni in Azure.Maven also lets you specify the operating system on which your function app runs in Azure. Usare l' os elemento per scegliere il sistema operativo.Use the os element to choose the operating system.

ElementoElement WindowsWindows LinuxLinux DockerDocker
os windowswindows Linuxlinux dockerdocker

Nell'esempio seguente viene illustrata l'impostazione del sistema operativo nella runtime sezione del file di pom.xml:The following example shows the operating system setting in the runtime section of the pom.xml file:

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

Disponibilità del runtime JDK e supportoJDK runtime availability and support

Per lo sviluppo locale di app per le funzioni Java, scaricare e usare il JDK di Azul Zulu Enterprise per Azure Java da Azul Systems.For local development of Java function apps, download and use the appropriate Azul Zulu Enterprise for Azure Java JDKs from Azul Systems. Funzioni di Azure usa un runtime di Azul Java JDK quando si distribuisce l'app per le funzioni nel cloud.Azure Functions uses an Azul Java JDK runtime when you deploy your function app to the cloud.

Supporto tecnico di Azure per i problemi con i JDK e le app per le funzioni è disponibile con un piano di supporto completo.Azure support for issues with the JDKs and function apps is available with a qualified support plan.

Personalizzare JVMCustomize JVM

Funzioni di Azure consente di personalizzare la JVM (macchina virtuale Java) usata per eseguire le funzioni Java.Functions lets you customize the Java virtual machine (JVM) used to run your Java functions. Per impostazione predefinita, vengono usate le opzioni JVM seguenti:The following JVM options are used by default:

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

È possibile fornire argomenti aggiuntivi in un'impostazione dell'app denominata JAVA_OPTS.You can provide additional arguments in an app setting named JAVA_OPTS. È possibile aggiungere impostazioni all'app per le funzioni distribuita in Azure nel portale di Azure o nell'interfaccia della riga di comando di Azure.You can add app settings to your function app deployed to Azure in the Azure portal or the Azure CLI.

Importante

Nel piano a consumo, perché la personalizzazione funzioni è necessario aggiungere anche l'impostazione WEBSITE_USE_PLACEHOLDER con un valore pari a 0.In the Consumption plan, you must also add the WEBSITE_USE_PLACEHOLDER setting with a value of 0 for the customization to work. Questa impostazione aumenta i tempi di avvio a freddo per le funzioni Java.This setting does increase the cold start times for Java functions.

Portale di AzureAzure portal

Nel portale di Azure, usare la scheda Impostazioni applicazione per aggiungere l'impostazione JAVA_OPTS.In the Azure portal, use the Application Settings tab to add the JAVA_OPTS setting.

Interfaccia della riga di comando di AzureAzure CLI

È possibile usare il comando az functionapp config appsettings set per impostare JAVA_OPTS, come nell'esempio seguente:You can use the az functionapp config appsettings set command to set JAVA_OPTS, as in the following example:

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

Questo esempio abilita la modalità headless.This example enables headless mode. Sostituire anche <APP_NAME> con il nome dell'app per le funzioni e <RESOURCE_GROUP> con il gruppo di risorse.Replace <APP_NAME> with the name of your function app, and <RESOURCE_GROUP> with the resource group.

Librerie di terze partiThird-party libraries

Funzioni di Azure supporta l'uso di librerie di terze parti.Azure Functions supports the use of third-party libraries. Per impostazione predefinita, tutte le dipendenze specificate nel file pom.xml del progetto vengono raggruppate automaticamente durante l'obiettivo mvn package.By default, all dependencies specified in your project pom.xml file are automatically bundled during the mvn package goal. Inserire le librerie non specificate come dipendenze del file pom.xml in una directory lib nella directory radice della funzione.For libraries not specified as dependencies in the pom.xml file, place them in a lib directory in the function's root directory. Le dipendenze inserite nella directory lib vengono aggiunte al caricatore di classe di sistema in fase di runtime.Dependencies placed in the lib directory are added to the system class loader at runtime.

La dipendenza com.microsoft.azure.functions:azure-functions-java-library è specificata in classpath per impostazione predefinita e non deve essere inclusa nella directory lib.The com.microsoft.azure.functions:azure-functions-java-library dependency is provided on the classpath by default, and doesn't need to be included in the lib directory. Le dipendenze elencate qui, inoltre, vengono aggiunte al classpath da azure-functions-java-worker.Also, azure-functions-java-worker adds dependencies listed here to the classpath.

Supporto dei tipi di datiData type support

Per stabilire un'associazione con binding di input/output, è possibile usare oggetti Java precedenti normali (POJO, Plain Old Java Object), tipi definiti in azure-functions-java-library o tipi di dati primitivi, ad esempio stringa o numero intero.You can use Plain old Java objects (POJOs), types defined in azure-functions-java-library, or primitive data types such as String and Integer to bind to input or output bindings.

Oggetti POJOPOJOs

Per la conversione dei dati di input in oggetti POJO, azure-funzioni-java-worker usa la libreria gson.For converting input data to POJO, azure-functions-java-worker uses the gson library. I tipi POJO usati come input delle funzioni devono essere public.POJO types used as inputs to functions should be public.

Dati binariBinary data

Per associare dati di input/output binari a byte[], impostare il campo dataType nel file function.json su binary:Bind binary inputs or outputs to byte[], by setting the dataType field in your function.json to binary:

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

Se si prevedono valori null, usare Optional<T>.If you expect null values, use Optional<T>.

AssociazioniBindings

I binding di input e output forniscono una modalità dichiarativa per connettersi ai dati dall'interno del codice.Input and output bindings provide a declarative way to connect to data from within your code. Una funzione può avere più binding di input e output.A function can have multiple input and output bindings.

Esempio di associazione di inputInput binding example

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

Questa funzione viene richiamata con una richiesta HTTP.You invoke this function with an HTTP request.

  • Il payload della richiesta HTTP viene passato come String per l'argomento inputReq.HTTP request payload is passed as a String for the argument inputReq.
  • Viene recuperata una voce dall'archiviazione tabelle e passata come TestInputData all'argomento inputData.One entry is retrieved from Table storage, and is passed as TestInputData to the argument inputData.

Per ricevere un batch di input, è possibile stabilire un'associazione a String[], POJO[], List<String> o List<POJO>.To receive a batch of inputs, you can bind to String[], POJO[], List<String>, or 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;
}

Questa funzione viene attivata ogni volta che sono disponibili nuovi dati nell'hub eventi configurato.This function gets triggered whenever there is new data in the configured event hub. Poiché l'oggetto cardinality è impostato su MANY, la funzione riceve un batch di messaggi dall'hub eventi.Because the cardinality is set to MANY, the function receives a batch of messages from the event hub. L'oggetto TestEventData dell'hub eventi viene convertito in EventData per l'esecuzione della funzione.EventData from event hub gets converted to TestEventData for the function execution.

Esempio di associazione di outputOutput binding example

È possibile associare un binding di output al valore restituito usando $return.You can bind an output binding to the return value by using $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;
    }
}

Se sono presenti più associazioni di output, usare il valore restituito per una sola di tali associazioni.If there are multiple output bindings, use the return value for only one of them.

Per inviare più valori di output, usare il tipo OutputBinding<T> definito nel pacchetto azure-functions-java-library.To send multiple output values, use OutputBinding<T> defined in the azure-functions-java-library package.

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

Questa funzione viene richiamata con un comando HttpRequest.You invoke this function on an HttpRequest. La funzione scrive più valori nell'archiviazione code.It writes multiple values to Queue storage.

HttpRequestMessage e HttpResponseMessageHttpRequestMessage and HttpResponseMessage

Questi sono definiti in azure-functions-java-library.These are defined in azure-functions-java-library. Si tratta di tipi di helper che funzionano con le funzioni HttpTrigger.They are helper types to work with HttpTrigger functions.

Tipo specializzatoSpecialized type DestinazioneTarget Uso tipicoTypical usage
HttpRequestMessage<T> Trigger HTTPHTTP Trigger Metodo Get, intestazioni o queryGets method, headers, or queries
HttpResponseMessage Associazione di output HTTPHTTP Output Binding Restituisce uno stato diverso da 200Returns status other than 200

MetadatiMetadata

Alcuni trigger inviano metadati dei trigger insieme ai dati di input.Few triggers send trigger metadata along with input data. È possibile usare l'annotazione @BindingName per stabilire un'associazione con i metadati dei trigger.You can use annotation @BindingName to bind to trigger metadata.

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

Nell'esempio precedente, queryValue è associato al parametro della stringa di query name nell'URL della richiesta HTTP http://{example.host}/api/metadata?name=test.In the preceding example, the queryValue is bound to the query string parameter name in the HTTP request URL, http://{example.host}/api/metadata?name=test. Di seguito è riportato un altro esempio di binding a Id dai metadati del trigger della coda.Here's another example, showing how to bind to Id from queue trigger metadata.

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

Nota

Il nome specificato nell'annotazione deve corrispondere alla proprietà dei metadati.The name provided in the annotation needs to match the metadata property.

Contesto di esecuzioneExecution context

L'oggetto ExecutionContext definito in azure-functions-java-library contiene metodi helper per comunicare con il runtime di Funzioni.ExecutionContext, defined in the azure-functions-java-library, contains helper methods to communicate with the functions runtime. Per ulteriori informazioni, vedere l' articolo di riferimento ExecutionContext.For more information, see the ExecutionContext reference article.

LoggerLogger

Usare l'oggetto getLogger definito in ExecutionContext per scrivere i log dal codice della funzione.Use getLogger, defined in ExecutionContext, to write logs from function code.

Esempio:Example:


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

Visualizzazione dei log e della tracciaView logs and trace

È possibile usare l'interfaccia della riga di comando di Azure per trasmettere in streaming la registrazione dei canali stdout e stderr di Java, oltre alla registrazione di altre applicazioni.You can use the Azure CLI to stream Java stdout and stderr logging, as well as other application logging.

Ecco come configurare l'app per le funzioni per scrivere la registrazione delle applicazioni tramite l'interfaccia della riga di comando di Azure:Here's how to configure your function app to write application logging by using the Azure CLI:

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

Per eseguire lo streaming dell'output dell'app per le funzioni usando l'interfaccia della riga di comando di Azure, aprire un nuovo prompt dei comandi o una sessione terminal o Bash e immettere il comando seguente:To stream logging output for your function app by using the Azure CLI, open a new command prompt, Bash, or Terminal session, and enter the following command:

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

Il comando az webapp log tail offre opzioni per filtrare l'output usando l'opzione --provider.The az webapp log tail command has options to filter output by using the --provider option.

Per scaricare i file di log come un singolo file ZIP usando l'interfaccia della riga di comando di Azure, aprire un nuovo prompt dei comandi o una sessione terminal o Bash e immettere il comando seguente:To download the log files as a single ZIP file by using the Azure CLI, open a new command prompt, Bash, or Terminal session, and enter the following command:

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

Prima di eseguire questo comando, è necessario aver abilitato la registrazione del file system nel portale di Azure o nell'interfaccia della riga di comando di Azure.You must have enabled file system logging in the Azure portal or the Azure CLI before running this command.

Variabili di ambienteEnvironment variables

In Funzioni, le impostazioni dell'app, come le stringhe di connessione al servizio, vengono esposte come variabili di ambiente durante l'esecuzione.In Functions, app settings, such as service connection strings, are exposed as environment variables during execution. È possibile accedere a queste impostazioni usando System.getenv("AzureWebJobsStorage").You can access these settings by using, System.getenv("AzureWebJobsStorage").

Nell'esempio seguente viene ottenuta l'impostazione applicazione con la chiave denominata myAppSetting:The following example gets the application setting, with the key named 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);
    }
}

Nota

Il valore di AppSetting FUNCTIONS_EXTENSION_VERSION deve essere ~2 o ~3 per un'esperienza di avvio a freddo ottimizzata.The value of AppSetting FUNCTIONS_EXTENSION_VERSION should be ~2 or ~3 for an optimized cold start experience.

Passaggi successiviNext steps

Per altre informazioni sullo sviluppo di Funzioni di Azure in Java, vedere le risorse seguenti:For more information about Azure Functions Java development, see the following resources: