Rövid útmutató: Java Durable Functions-alkalmazás létrehozása

A Azure Functions egyik funkciója, a Durable Functions használatával állapotalapú kiszolgáló nélküli munkafolyamatokat írhat Java. Ebben a rövid útmutatóban klónozhat és futtathat egy mintaalkalmazást, amely két gyakori vezénylési mintát mutat be:

Függvényláncolás: Egymás után hívja meg a tevékenységeket (Tokió → Seattle → London).
Fan-out/fan-in: A tevékenységek párhuzamos meghívása öt városra vonatkozóan, majd az eredmények összesítése.

A folyamat végére mindkét orchestráció helyben fog futni a Durable Task Scheduler emulátorral, és az állapotukat a kezelőpulton is láthatja.

Klónozza és készítse elő a Hello Cities mintaprojektet.
Állítsa be a Durable Task Scheduler emulatort és az Azurite-t a helyi fejlesztéshez.
Hozza létre és futtassa a függvényalkalmazást, majd indítsa el mindkét orchesztrációt.
Tekintse meg a vezénylési folyamat állapotát és kimenetét a Durable Task Scheduler irányítópultján.

Prerequisites

Java 11+ (JDK) telepítve.
Apache Maven 3.0 vagy újabb verzió.
Azure Functions Core Tools v4 vagy újabb.
Docker az emulátor és az Azurite futtatásához.
Klónozza a Durable Task Scheduler GitHub-adattárat a gyorsútmutató-minta használatához.

A Durable Task Scheduler emulátor beállítása

A Durable Task Scheduler emulator helyi fejlesztési környezetet biztosít, így Azure előfizetés nélkül tesztelheti a vezényléseket. A Java Functions-gazdagéphez Azurite is szükséges a helyi tároláshoz.

Indítsa el mindkét tárolót:

docker run -d --name dtsemulator -p 8080:8080 -p 8082:8082 \
  mcr.microsoft.com/dts/dts-emulator:latest

docker run -d --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 \
  mcr.microsoft.com/azure-storage/azurite

Tip

Miután az emulátor elindult, a http://localhost:8082 címen elérheti a Durable Task Scheduler irányítópultját az orchesztrációk figyeléséhez.

A gyorsútmutató-minta futtatása

Keresse meg a Hello Cities mintakönyvtárat:

cd samples/durable-functions/java/HelloCities

Ellenőrizze, hogy a local.settings.json fájl a következő konfigurációt tartalmazza-e:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
  }
}

A projekt létrehozása:
```
mvn clean package
```
Indítsa el a függvényalkalmazást:
```
mvn azure-functions:run
```
Egy másik terminálban indítsa el a függvényláncolási koordinálást:
```
$response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartChaining
$response
```
A válasz az orchestrationpéldányhoz tartozó állapotra vonatkozó URL-címeket tartalmaz. Másolja ki az értéket, statusQueryGetUri és futtassa az eredmény ellenőrzéséhez:
```
Invoke-RestMethod -Uri $response.statusQueryGetUri
```

Indítsa el a fan-out/fan-in hangszerelést:

$response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartFanOutFanIn
Invoke-RestMethod -Uri $response.statusQueryGetUri

Várt kimenet

A POST-kérelem állapot URL-címekkel rendelkező JSON-választ ad vissza. Például:

{
  "id": "<instanceId>",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/<instanceId>?code=...",
  "sendEventPostUri": "...",
  "terminatePostUri": "...",
  "purgeHistoryDeleteUri": "..."
}

Amikor lekérdezi a(z) statusQueryGetUri elemet, és az orchestráció runtimeStatus értéke Completed, az üdvözlési eredményeket a(z) output mezőben találja. A láncolás vezénylése a következőt adja vissza:

{
  "name": "ChainingOrchestration",
  "runtimeStatus": "Completed",
  "output": "Hello Tokyo! Hello Seattle! Hello London!"
}

A fan-out/fan-in vezénylés az alábbit adja vissza:

{
  "name": "FanOutFanInOrchestration",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!", "Hello Paris!", "Hello Berlin!"]
}

Tip

Ha a(z) runtimeStatus helyén Running vagy Pending jelenik meg, várjon egy pillanatot, majd kérdezze le újra a(z) statusQueryGetUri-t.

Nyissa meg a Durable Task Scheduler irányítópultját a következő címen: http://localhost:8082, hogy megtekinthesse az orchesztráció állapotát és a végrehajtási előzményeket.

A kód értelmezése

A src/main/java/com/example/Functions.java mintaprojektje egy Durable Functions alkalmazáshoz szükséges mindhárom függvénytípust tartalmazza.

Tevékenységfüggvény

A SayHello tevékenység egy városnevet vesz fel, és egy üdvözlést ad vissza:

@FunctionName("SayHello")
public String sayHello(
        @DurableActivityTrigger(name = "city") String city) {
    return "Hello " + city + "!";
}

Orchestrator-függvények

A láncba rendező vezénylő sorrendben hívja meg a SayHello elemet a következő három város esetében:

@FunctionName("ChainingOrchestration")
public String chainingOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String result = "";
    result += ctx.callActivity("SayHello", "Tokyo", String.class).await();
    result += " " + ctx.callActivity("SayHello", "Seattle", String.class).await();
    result += " " + ctx.callActivity("SayHello", "London", String.class).await();
    return result;
}

A fan-out/fan-in koordinátor párhuzamosan ütemezi a tevékenységeket:

@FunctionName("FanOutFanInOrchestration")
public List<String> fanOutFanInOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String[] cities = {"Tokyo", "Seattle", "London", "Paris", "Berlin"};
    List<Task<String>> parallelTasks = new ArrayList<>();

    for (String city : cities) {
        parallelTasks.add(ctx.callActivity("SayHello", city, String.class));
    }

    List<String> results = new ArrayList<>();
    for (Task<String> task : parallelTasks) {
        results.add(task.await());
    }

    return results;
}

Klienstől függő funkciók

A HTTP által aktivált ügyfélfüggvények elindítják az egyes vezényléseket:

@FunctionName("StartChaining")
public HttpResponseMessage startChaining(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Void> request,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance("ChainingOrchestration");
    return durableContext.createCheckStatusResponse(request, instanceId);
}

Konfiguráció

A minta a Durable Task Scheduler emulatort használja a tároló háttérrendszereként. Ez itt van konfigurálva: host.json

{
  "extensions": {
    "durableTask": {
      "hubName": "default",
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  }
}

Az emulátor kapcsolati sztringje itt van beállítva: local.settings.json:

{
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
  }
}

Erőforrások tisztítása

Ha végzett, állítsa le az emulátortárolókat:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Következő lépések

További információ a common Durable Functions alkalmazásmintákról.
Durable Functions-alkalmazás telepítése az Azure-ba.
További információ a Durable Functions társzolgáltatókról.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-06-05