1# Durable Task Scheduler — Java
2 
3## Learn More
4 
5- [Durable Task Scheduler documentation](https://learn.microsoft.com/azure/durable-task-scheduler/)
6- [Durable Functions Java guide](https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview?tabs=java)
7 
8## Durable Functions Setup
9 
10### Required Maven Dependencies
11 
12```xml
13<dependencies>
14  <dependency>
15    <groupId>com.microsoft.azure.functions</groupId>
16    <artifactId>azure-functions-java-library</artifactId>
17    <version>3.2.3</version>
18  </dependency>
19  <dependency>
20    <groupId>com.microsoft</groupId>
21    <artifactId>durabletask-azure-functions</artifactId>
22    <version>1.7.0</version>
23  </dependency>
24</dependencies>
25```
26 
27> **💡 Finding latest versions**: Search [Maven Central](https://central.sonatype.com/) for `durabletask-azure-functions` (group: `com.microsoft`) to find the current stable version.
28 
29### host.json
30 
31```json
32{
33  "version": "2.0",
34  "extensions": {
35    "durableTask": {
36      "hubName": "default",
37      "storageProvider": {
38        "type": "durabletask-scheduler",
39        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
40      }
41    }
42  },
43  "extensionBundle": {
44    "id": "Microsoft.Azure.Functions.ExtensionBundle",
45    "version": "[4.*, 5.0.0)"
46  }
47}
48```
49 
50### local.settings.json
51 
52```json
53{
54  "IsEncrypted": false,
55  "Values": {
56    "FUNCTIONS_WORKER_RUNTIME": "java",
57    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
58    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
59  }
60}
61```
62 
63## Minimal Example
64 
65```java
66import com.microsoft.azure.functions.*;
67import com.microsoft.azure.functions.annotation.*;
68import com.microsoft.durabletask.*;
69import com.microsoft.durabletask.azurefunctions.*;
70 
71public class DurableFunctionsApp {
72 
73    @FunctionName("HttpStart")
74    public HttpResponseMessage httpStart(
75            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION)
76            HttpRequestMessage<Void> request,
77            @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
78        DurableTaskClient client = durableContext.getClient();
79        String instanceId = client.scheduleNewOrchestrationInstance("MyOrchestration");
80        return durableContext.createCheckStatusResponse(request, instanceId);
81    }
82 
83    @FunctionName("MyOrchestration")
84    public String myOrchestration(
85            @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
86        String result1 = ctx.callActivity("SayHello", "Tokyo", String.class).await();
87        String result2 = ctx.callActivity("SayHello", "Seattle", String.class).await();
88        return result1 + ", " + result2;
89    }
90 
91    @FunctionName("SayHello")
92    public String sayHello(@DurableActivityTrigger(name = "name") String name) {
93        return "Hello " + name + "!";
94    }
95}
96```
97 
98## Workflow Patterns
99 
100### Fan-Out/Fan-In
101 
102```java
103@FunctionName("FanOutFanIn")
104public List<String> fanOutFanIn(
105        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
106    String[] cities = {"Tokyo", "Seattle", "London", "Paris", "Berlin"};
107    List<Task<String>> parallelTasks = new ArrayList<>();
108 
109    // Fan-out: schedule all activities in parallel
110    for (String city : cities) {
111        parallelTasks.add(ctx.callActivity("SayHello", city, String.class));
112    }
113 
114    // Fan-in: wait for all to complete
115    List<String> results = new ArrayList<>();
116    for (Task<String> task : parallelTasks) {
117        results.add(task.await());
118    }
119 
120    return results;
121}
122```
123 
124### Human Interaction
125 
126```java
127@FunctionName("ApprovalWorkflow")
128public String approvalWorkflow(
129        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
130    ctx.callActivity("SendApprovalRequest", ctx.getInput(String.class)).await();
131 
132    // Wait for approval event with timeout
133    Task<Boolean> approvalTask = ctx.waitForExternalEvent("ApprovalEvent", Boolean.class);
134    Task<Void> timeoutTask = ctx.createTimer(Duration.ofDays(3));
135 
136    Task<?> winner = ctx.anyOf(approvalTask, timeoutTask).await();
137 
138    if (winner == approvalTask) {
139        return approvalTask.await() ? "Approved" : "Rejected";
140    }
141    return "Timed out";
142}
143```
144 
145## Orchestration Determinism
146 
147| ❌ NEVER | ✅ ALWAYS USE |
148|----------|--------------|
149| `System.currentTimeMillis()` | `ctx.getCurrentInstant()` |
150| `UUID.randomUUID()` | Pass random values from activities |
151| `Thread.sleep()` | `ctx.createTimer()` |
152| Direct I/O, HTTP, database | `ctx.callActivity()` |
153 
154### Replay-Safe Logging
155 
156```java
157private static final java.util.logging.Logger logger =
158    java.util.logging.Logger.getLogger("MyOrchestration");
159 
160@FunctionName("MyOrchestration")
161public String myOrchestration(
162        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
163    // Use isReplaying to avoid duplicate logs
164    if (!ctx.getIsReplaying()) {
165        logger.info("Started");  // Only logs once, not on replay
166    }
167    return ctx.callActivity("MyActivity", "input", String.class).await();
168}
169```
170 
171## Error Handling & Retry
172 
173```java
174@FunctionName("WorkflowWithRetry")
175public String workflowWithRetry(
176        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
177    TaskOptions retryOptions = new TaskOptions(new RetryPolicy(
178        3,  // maxNumberOfAttempts
179        Duration.ofSeconds(5)  // firstRetryInterval
180    ));
181 
182    try {
183        return ctx.callActivity("UnreliableService", ctx.getInput(String.class),
184                retryOptions, String.class).await();
185    } catch (TaskFailedException ex) {
186        ctx.setCustomStatus(Map.of("Error", ex.getMessage()));
187        ctx.callActivity("CompensationActivity", ctx.getInput(String.class)).await();
188        return "Compensated";
189    }
190}
191```
192 
193## Durable Task SDK (Non-Functions)
194 
195For applications running outside Azure Functions (containers, VMs, Azure Container Apps, Azure Kubernetes Service):
196 
197```java
198import com.microsoft.durabletask.*;
199import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerWorkerExtensions;
200import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerClientExtensions;
201 
202import java.time.Duration;
203 
204public class App {
205    public static void main(String[] args) throws Exception {
206        String connectionString = "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";
207 
208        // Worker
209        DurableTaskGrpcWorker worker = DurableTaskSchedulerWorkerExtensions
210            .createWorkerBuilder(connectionString)
211            .addOrchestration(new TaskOrchestrationFactory() {
212                @Override public String getName() { return "MyOrchestration"; }
213                @Override public TaskOrchestration create() {
214                    return ctx -> {
215                        String result = ctx.callActivity("SayHello",
216                                ctx.getInput(String.class), String.class).await();
217                        ctx.complete(result);
218                    };
219                }
220            })
221            .addActivity(new TaskActivityFactory() {
222                @Override public String getName() { return "SayHello"; }
223                @Override public TaskActivity create() {
224                    return ctx -> "Hello " + ctx.getInput(String.class) + "!";
225                }
226            })
227            .build();
228 
229        worker.start();
230 
231        // Client
232        DurableTaskClient client = DurableTaskSchedulerClientExtensions
233            .createClientBuilder(connectionString).build();
234        String instanceId = client.scheduleNewOrchestrationInstance("MyOrchestration", "World");
235        OrchestrationMetadata result = client.waitForInstanceCompletion(
236                instanceId, Duration.ofSeconds(30), true);
237        System.out.println("Output: " + result.readOutputAs(String.class));
238 
239        worker.stop();
240    }
241}
242```
243 
244