AWS Flow Framework for Java：深度解析

需积分: 9 56 浏览量更新于2024-07-21 收藏 1.18MB PDF 举报

"AWSFlowFrameworkforJava是亚马逊网络服务（Amazon Web Services, AWS）提供的一款用于构建基于Java的工作流应用程序的框架。此框架帮助开发者轻松处理复杂的分布式系统中的工作流程管理，包括任务调度、状态管理、故障恢复和并发控制。AWSFlowFrameworkforJava适用于构建在AWS基础设施上运行的应用程序，它利用了AWS的服务如Simple Workflow Service (SWF)来协调多个分布式任务。" AWSFlowFrameworkforJava是AWS为Java开发者设计的一个强大的工具，它允许开发者在AWS环境中构建高度可扩展和容错性强的业务流程。该框架的核心是Amazon Simple Workflow Service (SWF)，这是一个完全托管的服务，能够协调分布式应用中的长期运行工作流程和任务。SWF负责跟踪任务状态、处理并发执行、以及在出现故障时自动重试或恢复。使用AWSFlowFrameworkforJava，开发者可以专注于实现业务逻辑，而无需关注底层的流程协调细节。框架提供了抽象层，使得开发者可以使用熟悉的编程模型，例如定义工作流、活动和决策任务，而无需直接与SWF API交互。此外，它还支持声明式地定义工作流，这有助于降低复杂性并提高代码的可读性。该框架还包含了错误处理机制，如自动重试、超时管理和回退策略。当工作流中的任务失败时，AWSFlowFrameworkforJava会尝试自动恢复，或者根据预定义的策略执行回退操作。这极大地增强了应用程序的健壮性和可靠性。在安全性方面，AWSFlowFrameworkforJava利用AWS的安全实践，如IAM角色和权限，确保只有授权的实体可以执行和管理工作流程。通过使用AWS的身份和访问管理（IAM），开发者可以精细控制对SWF和其他相关AWS服务的访问。除此之外，AWSFlowFrameworkforJava还与AWS的其他服务集成良好，例如Amazon S3（用于存储数据）、DynamoDB（用于持久化工作流状态）和Lambda（用于无服务器计算）。这种集成使得开发者可以构建更复杂、更高效的应用程序，充分利用AWS云服务的灵活性和可扩展性。 AWSFlowFrameworkforJava是AWS提供的一款强大工具，它简化了在Java中构建分布式工作流应用程序的过程，并且充分利用了AWS服务的特性。通过使用这个框架，开发者可以构建出高可用、可扩展并且具有故障恢复能力的业务流程，同时降低了管理复杂性和开发成本。

This section discusses the workflow implementation and activities client; the WorkflowWorker class is

discussed later.

HelloWorldWorkflow defines the workflow interface in GreeterWorkflow, as follows:

import com.amazonaws.services.simpleworkflow.flow.annotations.Execute;

import com.amazonaws.services.simpleworkflow.flow.annotations.Workflow;

import com.amazonaws.services.simpleworkflow.flow.annotations.WorkflowRegistra

tionOptions;

@Workflow

@WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 3600)

public interface GreeterWorkflow {

@Execute(version = "1.0")

public void greet();

}

This interface also isn't strictly necessary for HelloWorld but is essential for an AWS Flow Framework for

Java application.You must apply two AWS Flow Framework for Java annotations,

@WorkflowRegistrationOptions (p. 114) and @WorkflowRegistrationOptions (p. 114), to the workflow

interface definition. The annotations provide configuration information and also direct the AWS Flow

Framework for Java annotation processor to generate a workflow client class based on the interface, as

discussed later.

@Workflow has one named value, but it is typically used without values to designate GreeterWorkflow

as a workflow interface.@WorkflowRegistrationOptions has several named values that can be used

to configure the workflow worker. HelloWorldWorkflow specifies one timeout:

• defaultExecutionStartToCloseTimeoutSeconds specifies how long the workflow can run and

is set to 300 seconds (5 minutes).

The GreeterWorkflow interface definition differs from HelloWorld in one important way, the

@Execute (p.114) annotation.Workflow interfaces specify the methods that can be called by applications

such as the workflow starter and are limited to a handful of methods, each with a particular role. The

framework doesn't specify a name or parameter list for workflow interface methods; you use a name and

parameter list that is suitable for your workflow and apply an AWS Flow Framework for Java annotation

to identify the method's role.

@Execute has two purposes: identifies greet as the workflow's entry point—the method that the workflow

starter calls to start the workflow. In general, an entry point can take one or more parameters, which

allows the starter to initialize the workflow, but this example doesn't require initialization.

• It identifies greet as the workflow's entry point—the method that the workflow starter calls to start the

workflow. In general, an entry point can take one or more parameters, which allows the starter to

initialize the workflow, but this example doesn't require initialization.

• It specifies the workflow's version number, which allows you to keep track of different generations of

workflow implementations.To change a workflow interface after you have registered it with Amazon

SWF, including changing the timeout values, you must use a new version number.

For information on the other methods that can be included in a workflow interface, see Workflow and

Activity Contracts (p. 42).

HelloWorldWorkflow implements the workflow in GreeterWorkflowImpl, as follows:

API Version 2012-01-25

AWS Flow Framework for Java Developer Guide

HelloWorldWorkflow Workflow Worker

import com.amazonaws.services.simpleworkflow.flow.core.Promise;

public class GreeterWorkflowImpl implements GreeterWorkflow {

private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl();

public void greet() {

Promise<String> name = operations.getName();

Promise<String> greeting = operations.getGreeting(name);

operations.say(greeting);

}

The code is similar to HelloWorld, but with two important differences.

• GreeterWorkflowImpl creates an instance of GreeterActivitiesClientImpl, the activities

client, instead of GreeterActivitiesImpl, and executes activities by calling methods on the client

object.

• The name and greeting activities return Promise<String> objects instead of String objects.

HelloWorld is a standard Java application that runs locally as a single process, so GreeterWorkflowImpl

can implement the workflow topology by simply creating an instance of GreeterActivitiesImpl,

calling the methods in order, and passing the return values from one activity to the next.With an Amazon

SWF workflow, an activity's task is still performed by an activity method from GreeterActivitiesImpl.

However, the method doesn't necessarily run in the same process as the workflow—it might not even

run on the same system—and the workflow needs to execute the activity asynchronously. These

requirements raise the following issues:

• How to execute an activity method that might be running in a different process, perhaps on a different

system.

• How to execute an activity method asynchronously.

• How to manage activities' input and return values. For example, if the Activity A return value is an input

to Activity B, you must ensure that Activity B doesn't execute until Activity A is complete.

You can implement a variety of workflow topologies through the application's control flow by using familiar

Java flow control combined with the activities client and the Promise<T>.

Activities Client

GreeterActivitiesClientImpl is basically a proxy for GreeterActivitiesImpl that allows a

workflow implementation to execute the GreeterActivitiesImpl methods asynchronously.

You don't implement the activities client directly.The AWS Flow Framework for Java annotation processor

uses the annotations and code from the GreeterActivities interface to generate the

GreeterActivitiesClient interface and the GreeterActivitiesClientImpl class. It creates the

class names by simply appending "Client" and "ClientImpl" to the interface name. If you would like to

examine the activities client code, Eclipse generates it each time you save the source files and puts the

resulting class implementations in the project's .apt_generated folder.

A workflow worker executes an activity by calling the corresponding client method. The method is

asynchronous and immediately returns a Promise<T> object, where T is the activity's return type. The

returned Promise<T> object is basically a placeholder for the value that the activity method will eventually

return.

API Version 2012-01-25

AWS Flow Framework for Java Developer Guide

HelloWorldWorkflow Workflow Worker

• When the activities client method returns, the Promise<T> object is initially in an unready state, which

indicates that the object does not yet represent a valid return value.

• When the corresponding activity method completes its task and returns, the framework assigns the

return value to the Promise<T> object and puts it in the ready state.

Promise<T> Type

The primary purpose of Promise<T> objects is to manage data flow between asynchronous components

and control when they execute. It relieves your application of the need to explicitly manage synchronization

or depend on mechanisms such as timers to ensure that asynchronous components do not execute

prematurely. When you call an activities client method, it immediately returns but the framework defers

executing the corresponding activity method until any input Promise<T> objects are ready and represent

valid data.

From GreeterWorkflowImpl perspective, all three activities client methods return immediately. From

the GreeterActivitiesImpl perspective, the framework doesn't call getGreeting until name

completes, and doesn't call say until getGreeting completes.

By using Promise<T> to pass data from one activity to the next, HelloWorldWorkflow not only ensures

that activity methods don't attempt to use invalid data, it also controls when the activities execute and

implicitly defines the workflow topology. Passing each activity's Promise<T> return value to the next

activity requires the activities to execute in sequence, defining the linear topology discussed earlier. With

AWS Flow Framework for Java, you don't need to use any special modeling code to define even complex

topologies, just standard Java flow control and Promise<T>. For an example of how to implement a

simple parallel topology, see HelloWorldWorkflowParallel Activities Worker (p. 25).

Note

When an activity method such as say doesn't return a value, the corresponding client method

returns a Promise<Void> object. The object doesn't represent data, but it is initially unready

and becomes ready when the activity completes.You can therefore pass a Promise<Void>

object to other activities client methods to ensure that they defer execution until the original

activity completes.

Promise<T> allows a workflow implementation to use activities client methods and their return values

much like synchronous methods. However, you must be careful about accessing a Promise<T> object's

value. Unlike the Java Future<T> type, the framework handles synchronization for Promise<T>, not the

application. If you call Promise<T>.get and the object is not ready, get throws an exception. Notice

that HelloWorldWorkflow never accesses a Promise<T> object directly; it simply passes the objects

from one activity to the next. When an object becomes ready, the framework extracts the value and

passes it to the activity method as a standard type.

Promise<T> objects should be accessed only by asynchronous code, where the framework guarantees

that the object is ready and represents a valid value. HelloWorldWorkflow deals with this issue by

passing Promise<T> objects only to activities client methods.You can access a Promise<T> object's

value in your workflow implementation by passing the object to an asynchronous workflow method, which

behaves much like an activity. For an example, see HelloWorldWorkflowAsync Application (p. 20).

HelloWorldWorkflow Workflow and Activities Host

The workflow and activities implementations have associated worker classes, ActivityWorker and

WorkflowWorker. They handle communication between Amazon SWF and the activities and workflow

implementations by polling the appropriate Amazon SWF task list for tasks, executing the appropriate

method for each task, and managing the data flow. For details, see Application Structure (p. 28)

To associate the activity and workflow implementations with the corresponding worker objects, you

implement one or more worker applications which:

API Version 2012-01-25

AWS Flow Framework for Java Developer Guide

HelloWorldWorkflow Workflow and Activities Host

• Register workflows or activities with Amazon SWF.

• Create worker objects and associate them with the workflow or activity worker implementations.

• Direct the worker objects to start communicating with Amazon SWF.

If you want to run the workflow and activities as separate processes, you must implement separate

workflow and activities worker hosts. For an example, see HelloWorldWorkflowDistributed

Application (p. 23). For simplicity, HelloWorldWorkflow implements a single worker host that runs activities

and workflow workers in the same process, as follows:

import com.amazonaws.ClientConfiguration;

import com.amazonaws.auth.AWSCredentials;

import com.amazonaws.auth.BasicAWSCredentials;

import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;

import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClient;

import com.amazonaws.services.simpleworkflow.flow.ActivityWorker;

import com.amazonaws.services.simpleworkflow.flow.WorkflowWorker;

public class GreeterWorker {

public static void main(String[] args) throws Exception {

ClientConfiguration config = new ClientConfiguration().withSocket

Timeout(70*1000);

String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID");

String swfSecretKey = System.getenv("AWS_SECRET_KEY");

AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swf

SecretKey);

AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials,

config);

service.setEndpoint("https://swf.us-east-1.amazonaws.com");

String domain = " helloWorldExamples";

String taskListToPoll = "HelloWorldList";

ActivityWorker aw = new ActivityWorker(service, domain, taskListToPoll);

aw.addActivitiesImplementation(new GreeterActivitiesImpl());

aw.start();

WorkflowWorker wfw = new WorkflowWorker(service, domain, taskListToPoll);

wfw.addWorkflowImplementationType(GreeterWorkflowImpl.class);

wfw.start();

}

GreeterWorker has no HelloWorld counterpart, so you must add a Java class named GreeterWorker

to the project and copy the example code to that file.

The first step is to create and configure an AmazonSimpleWorkflowClient object, which invokes the

underlying Amazon SWF service methods.To do so, GreeterWorker:

1. Creates a ClientConfiguration object and specifies a socket timeout of 70 seconds.This value specifies

long to wait for data to be transferred over an established open connection before closing the socket.

2. Creates a BasicAWSCredentials object to identify the Amazon AWS account and passes the account

keys to the constructor. For convenience, and to avoid exposing them as plain text in the code, the

keys are stored as environment variables.

API Version 2012-01-25

AWS Flow Framework for Java Developer Guide

HelloWorldWorkflow Workflow and Activities Host

3. Creates an AmazonSimpleWorkflowClient object to represent the workflow, and passes the

AmazonSimpleWorkflowConfig object and access keys to the constructor.

4. Sets the client object's service endpoint URL. Currently, only US East (Northern Virginia) Region

supports Amazon SWF.

For convenience, GreeterWorker defines two string constants.

• domain is the workflow's Amazon SWF domain name, which you created when you set up your Amazon

SWF account. HelloWorldWorkflow assumes that you are running the workflow in the

"helloWorldExamples" domain.

• taskListToPoll is the name of the task lists that Amazon SWF uses to manage communication

between the workflow and activities workers.You can set the name to any convenient string.

HelloWorldWorkflow uses "HelloWorldList" for both workflow and activity task lists. Behind the scenes,

the names end up in different namespaces, so the two task lists are distinct.

GreeterWorker uses the string constants and the AmazonSimpleWorkflowClient object to create worker

objects, which manage the interaction between the activities and worker implementations and Amazon

SWF. In particular, the worker objects handle the task of polling the appropriate task list for tasks.

GreeterWorker creates an ActivityWorker object and configures it to handle

GreeterActivitiesImpl by adding a new class instance. GreeterWorker then calls the

ActivityWorker object's start method, which directs the object to start polling the specified activities

task list.

GreeterWorker creates a WorkflowWorker object and configures it to handle GreeterWorkflowImpl

by adding the class file name, GreeterWorkflowImpl.class. It then calls the WorkflowWorker

object's start method, which directs the object to start polling the specified workflow task list.

You can run GreeterWorker successfully at this point. It registers the workflow and activities with Amazon

SWF and starts the worker objects polling their respective task lists. To verify this, run GreeterWorker

and go to the Amazon SWF console and selecting helloWorldWalkthrough from the list of domains.

If you click Workflow Types in the Navigation pane, you should see GreeterWorkflow.greet, as

shown in the following screen shot.

If you click Activity Types, you should see the GreeterActivities methods, as shown in the following

screen shot.

API Version 2012-01-25

AWS Flow Framework for Java Developer Guide

HelloWorldWorkflow Workflow and Activities Host

剩余124页未读，继续阅读

situji

粉丝: 0
资源: 1

AWS Flow Framework for Java：深度解析

aws-sdk-java, 面向Java的官方 AWS SDK.zip

亚马逊JDK Amazon Corretto 8

aws-java-sdk-1.1.7.1.jar.zip

Aws for java V2 怎么做分片下载并实现进度条给前端

也没有onStateChanged、onProgressChanged、onError方法，我用的Aws for java V2版本

AWS SDK for Java.rar

AWS SDK for Java 开发人员指南1

AWS SDK for Java开发人员指南.pdf

aws-java-sdk-examples:最新的AWS Java SDK的工作示例

AWS S3 Java 开发文档

最新资源