Azure Functions Java developer guide

The Azure Functions runtime supports Java SE 8 LTS (zulu8.31.0.2-jre8.0.181-win_x64). This guide contains information about the intricacies of writing Azure Functions with Java.

As it happens to other languages, a Function App may have one or more functions. A Java function is a public method, decorated with the annotation @FunctionName. This method defines the entry for a Java function, and must be unique in a particular package. One Function App written in Java may have multiple classes with multiple public methods annotated with @FunctionName.

This article assumes that you have already read the Azure Functions developer reference. You should also complete the Functions quickstart to create your first function, by using Visual Studio Code or Maven.

Programming model

The concepts of triggers and bindings are fundamental to Azure Functions. Triggers start the execution of your code. Bindings give you a way to pass data to and return data from a function, without having to write custom data access code.

Project Scaffolding

The simplest way to scaffold a Java-based Azure Function project is to use Apache Maven archetypes. You can also find project generation wizards on Visual Studio Code, and the Azure Toolkits for Eclipse and IntelliJ.

There are currently two Azure Functions archetypes for Maven:

Java Archetype

This archetype is published under the following groupId and artifactId

mvn archetype:generate \ \

Kotlin Archetype (Preview)

This archetype is published under the following groupId and artifactId

mvn archetype:generate \ \

The source code of these archetypes can be found on the Azure Maven Archetypes GitHub repository.

Folder structure

Here is the folder structure of an Azure Functions Java project:

 | - src
 | | - main
 | | | - java
 | | | | - FunctionApp
 | | | | | -
 | | | | | -
 | - target
 | | - azure-functions
 | | | - FunctionApp
 | | | | - FunctionApp.jar
 | | | | - host.json
 | | | | - MyFirstFunction
 | | | | | - function.json
 | | | | - MySecondFunction
 | | | | | - function.json
 | | | | - bin
 | | | | - lib
 | - pom.xml

* The Kotlin project looks very similar since it is still Maven

You can use a shared host.json file to configure the function app. Each function has its own code file (.java) and binding configuration file (function.json).

You can put more than one function in a project. Avoid putting your functions into separate jars. The FunctionApp in the target directory is what gets deployed to your function app in Azure.

Triggers and annotations

Functions are invoked by a trigger, such as an HTTP request, a timer, or an update to data. Your function needs to process that trigger, and any other inputs, to produce one or more outputs.

Use the Java annotations included in the* package to bind input and outputs to your methods. For more information, see the Java reference docs.


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.


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

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"

JDK runtime availability and support

For local development of Java function apps, download and use the Azul Zulu Enterprise for Azure Java 8 JDKs from Azul Systems. Azure Functions uses the Azul Java 8 JDK runtime when you deploy your function apps to the cloud.

Azure support for issues with the JDKs and function apps is available with a qualified support plan.

Customize JVM

Functions lets you customize the Java virtual machine (JVM) used to run your Java functions. The following JVM options are used by default:

  • -XX:+TieredCompilation
  • -XX:TieredStopAtLevel=1
  • -noverify
  • -jar

You can provide additional arguments in an app setting named JAVA_OPTS. You can add app settings to your function app deployed to Azure in the Azure portal or the Azure CLI.

Azure portal

In the Azure portal, use the Application Settings tab to add the JAVA_OPTS setting.

Azure CLI

You can use the az functionapp config appsettings set command to set JAVA_OPTS, as in the following example:

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

This example enables headless mode. Replace <APP_NAME> with the name of your function app, and <RESOURCE_GROUP> with the resource group.


In the Consumption plan, you must add the WEBSITE_USE_PLACEHOLDER setting with a value of 0.
This setting does increase the cold start times for Java functions.

Third-party libraries

Azure Functions supports the use of third-party libraries. By default, all dependencies specified in your project pom.xml file are automatically bundled during the mvn package goal. For libraries not specified as dependencies in the pom.xml file, place them in a lib directory in the function's root directory. Dependencies placed in the lib directory are added to the system class loader at runtime.

The dependency is provided on the classpath by default, and doesn't need to be included in the lib directory. Also, azure-functions-java-worker adds dependencies listed here to the classpath.

Data type support

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.


For converting input data to POJO, azure-functions-java-worker uses the gson library. POJO types used as inputs to functions should be public.

Binary data

Bind binary inputs or outputs to byte[], by setting the dataType field in your function.json to binary:

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

If you expect null values, use Optional<T>.


Input and output bindings provide a declarative way to connect to data from within your code. A function can have multiple input and output bindings.

Input binding example

package com.example;


public class Function {
    public static String echo(
        @HttpTrigger(name = "req", methods = { "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;

You invoke this function with an HTTP request.

  • HTTP request payload is passed as a String for the argument inputReq.
  • One entry is retrieved from Table storage, and is passed as TestInputData to the argument inputData.

To receive a batch of inputs, you can bind to String[], POJO[], List<String>, or List<POJO>.

    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;

This function gets triggered whenever there is new data in the configured event hub. Because the cardinality is set to MANY, the function receives a batch of messages from the event hub. EventData from event hub gets converted to TestEventData for the function execution.

Output binding example

You can bind an output binding to the return value by using $return.

package com.example;


public class Function {
    @BlobOutput(name = "$return", path = "samples-output-java/{name}")
    public static String copy(@BlobTrigger(name = "blob", path = "samples-input-java/{name}") String content) {
        return content;

If there are multiple output bindings, use the return value for only one of them.

To send multiple output values, use OutputBinding<T> defined in the azure-functions-java-library package.

    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();
   = "msg1"+queueMessageId;
            TestData testData2 = new TestData();
   = "msg2"+queueMessageId;


            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;

You invoke this function on an HttpRequest. It writes multiple values to Queue storage.

HttpRequestMessage and HttpResponseMessage

These are defined in azure-functions-java-library. They are helper types to work with HttpTrigger functions.

Specialized type Target Typical usage
HttpRequestMessage<T> HTTP Trigger Gets method, headers, or queries
HttpResponseMessage HTTP Output Binding Returns status other than 200


Few triggers send trigger metadata along with input data. You can use annotation @BindingName to bind to trigger metadata.

package com.example;

import java.util.Optional;

public class Function {
    public static String metadata(
        @HttpTrigger(name = "req", methods = { "get", "post" }, authLevel = AuthorizationLevel.ANONYMOUS) Optional<String> body,
        @BindingName("name") String queryValue
    ) {
        return body.orElse(queryValue);

In the preceding example, the queryValue is bound to the query string parameter name in the http request URL, http://{}/api/metadata?name=test. Here's another example, showing how to bind to Id from queue trigger metadata.

    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(); = metadataId;


The name provided in the annotation needs to match the metadata property.

Execution context

ExecutionContext, defined in the azure-functions-java-library, contains helper methods to communicate with the functions runtime.


Use getLogger, defined in ExecutionContext, to write logs from function code.



public class Function {
    public String echo(@HttpTrigger(name = "req", methods = {"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);

View logs and trace

You can use the Azure CLI to stream Java stdout and stderr logging, as well as other application logging.

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

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

The az webapp log tail command has options to filter output by using the --provider option.

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

You must have enabled file system logging in the Azure portal or the Azure CLI before running this command.

Environment variables

In Functions, app settings, such as service connection strings, are exposed as environment variables during execution. You can access these settings by using, System.getenv("AzureWebJobsStorage").

The following example gets the application setting, with the key named myAppSetting:

public class Function {
    public String echo(@HttpTrigger(name = "req", methods = {"post"}, authLevel = AuthorizationLevel.ANONYMOUS) String req, ExecutionContext context) {
        context.getLogger().info("My app setting value: "+ System.getenv("myAppSetting"));
        return String.format(req);

Next steps

For more information about Azure Functions Java development, see the following resources: