Temporal Java SDK

// Workflow client and service interaction
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowOptions;
import io.temporal.servicestubs.WorkflowServiceStubs;

// Workflow implementation
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import io.temporal.workflow.SignalMethod;
import io.temporal.workflow.QueryMethod;

// Activity implementation
import io.temporal.activity.Activity;
import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;

// Worker management
import io.temporal.worker.Worker;
import io.temporal.worker.WorkerFactory;
import io.temporal.worker.WorkerOptions;

// Common configurations and exceptions
import io.temporal.common.RetryOptions;
import io.temporal.failure.ApplicationFailure;

// Define a workflow interface
@WorkflowInterface
public interface HelloWorkflow {
    @WorkflowMethod
    String sayHello(String name);
}

// Define an activity interface
@ActivityInterface
public interface HelloActivity {
    @ActivityMethod
    String getGreeting(String name);
}

// Implement the workflow
public class HelloWorkflowImpl implements HelloWorkflow {
    private final HelloActivity activity = Workflow.newActivityStub(
        HelloActivity.class,
        ActivityOptions.newBuilder()
            .setStartToCloseTimeout(Duration.ofSeconds(30))
            .build()
    );

    @Override
    public String sayHello(String name) {
        return activity.getGreeting(name);
    }
}

// Implement the activity
public class HelloActivityImpl implements HelloActivity {
    @Override
    public String getGreeting(String name) {
        return "Hello, " + name + "!";
    }
}

// Start a workflow
public class Main {
    public static void main(String[] args) {
        // Create workflow client
        WorkflowServiceStubs service = WorkflowServiceStubs.newLocalServiceStubs();
        WorkflowClient client = WorkflowClient.newInstance(service);

        // Create worker
        WorkerFactory factory = WorkerFactory.newInstance(client);
        Worker worker = factory.newWorker("hello-task-queue");
        worker.registerWorkflowImplementationTypes(HelloWorkflowImpl.class);
        worker.registerActivitiesImplementations(new HelloActivityImpl());

        // Start worker
        factory.start();

        // Execute workflow
        HelloWorkflow workflow = client.newWorkflowStub(
            HelloWorkflow.class,
            WorkflowOptions.newBuilder()
                .setTaskQueue("hello-task-queue")
                .setWorkflowId("hello-workflow")
                .build()
        );

        String result = workflow.sayHello("World");
        System.out.println(result); // "Hello, World!"
    }
}

// Core activity execution context
public final class Activity {
    public static ActivityExecutionContext getExecutionContext();
    public static RuntimeException wrap(Throwable e);
}

// Activity execution context with heartbeat and async completion
public interface ActivityExecutionContext {
    ActivityInfo getInfo();
    <V> void heartbeat(V details) throws ActivityCompletionException;
    <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass);
    ManualActivityCompletionClient useLocalManualCompletion();
    void doNotCompleteOnReturn();
}

// Activity configuration options
public final class ActivityOptions {
    public static ActivityOptions.Builder newBuilder();
    // Builder methods for timeouts, retry options, task queue, etc.
}

// Central workflow utility class
public final class Workflow {
    public static <T> T newActivityStub(Class<T> activityInterface, ActivityOptions options);
    public static <T> T newLocalActivityStub(Class<T> activityInterface, LocalActivityOptions options);
    public static <T> ChildWorkflowStub newChildWorkflowStub(Class<T> workflowInterface, ChildWorkflowOptions options);
    public static void sleep(Duration duration);
    public static long currentTimeMillis();
    public static Random newRandom();
    public static void continueAsNew(Object... args);
}

// Workflow interface annotations
@WorkflowInterface
@WorkflowMethod
@SignalMethod
@QueryMethod
@UpdateMethod

// Primary workflow client interface
public interface WorkflowClient {
    // Factory methods
    public static WorkflowClient newInstance(WorkflowServiceStubs service);
    public static WorkflowClient newInstance(WorkflowServiceStubs service, WorkflowClientOptions options);

    // Workflow stub creation
    public <T> T newWorkflowStub(Class<T> workflowInterface, WorkflowOptions options);
    public <T> T newWorkflowStub(Class<T> workflowInterface, String workflowId);
    public WorkflowStub newUntypedWorkflowStub(String workflowType, WorkflowOptions options);

    // Static execution methods
    public static WorkflowExecution start(Func<R> workflow);
    public static <R> CompletableFuture<R> execute(Func<R> workflow);
}

// Workflow configuration options
public final class WorkflowOptions {
    public static WorkflowOptions.Builder newBuilder();
    // Builder methods for timeouts, retry options, task queue, etc.
}

// Worker factory for creating and managing workers
public interface WorkerFactory {
    public static WorkerFactory newInstance(WorkflowClient workflowClient);
    public Worker newWorker(String taskQueue);
    public Worker newWorker(String taskQueue, WorkerOptions options);
    public void start();
    public void shutdown();
    public void awaitTermination(long timeout, TimeUnit unit);
}

// Individual worker for executing workflows and activities
public interface Worker {
    public void registerWorkflowImplementationTypes(Class<?>... workflowImplementationClasses);
    public void registerActivitiesImplementations(Object... activityImplementations);
    public <R> void addWorkflowImplementationFactory(Class<R> workflowInterface, Func<R> factory);
}

// Worker configuration options
public final class WorkerOptions {
    public static WorkerOptions.Builder newBuilder();
    // Builder methods for concurrency limits, timeouts, tuning options
}

// Base exception hierarchy
public class TemporalException extends RuntimeException { }
public class TemporalFailure extends TemporalException { }

// Specific failure types
public final class ActivityFailure extends TemporalFailure { }
public final class ApplicationFailure extends TemporalFailure {
    public static ApplicationFailure newFailure(String message, String type);
    public static ApplicationFailure newNonRetryableFailure(String message, String type);
}
public final class CanceledFailure extends TemporalFailure { }
public final class ChildWorkflowFailure extends TemporalFailure { }
public final class TimeoutFailure extends TemporalFailure { }
public final class TerminatedFailure extends TemporalFailure { }

// Core payload conversion interface
public interface PayloadConverter {
    public Optional<Payload> toData(Object value) throws DataConverterException;
    public <T> T fromData(Payload content, Class<T> valueClass, Type valueType) throws DataConverterException;
}

// Payload codec for encoding/decoding (encryption, compression)
public interface PayloadCodec {
    public List<Payload> encode(List<Payload> payloads);
    public List<Payload> decode(List<Payload> payloads);
}

// Serialization context for activities
public interface ActivitySerializationContext extends SerializationContext {
    public String getNamespace();
    public String getTaskQueue();
    public String getWorkflowId();
}