Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Primeros pasos con el AWS Flow Framework para Java En esta sección, AWS Flow Framework se presenta una serie de ejemplos de aplicaciones sencillas que presentan el modelo de programación básico y la API. Las aplicaciones de ejemplo están basadas en la aplicación Hello World estándar que se utiliza para realizar introducciones a C y los lenguajes de programación relacionados. Aquí tiene una implementación típica en Java de Hello World: ``` public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } } ``` A continuación, se ofrece una breve descripción de las aplicaciones de ejemplo. Se incluye el código fuente completo para que pueda implementar y ejecutar las aplicaciones usted mismo. Antes de empezar, primero debe configurar su entorno de desarrollo y crear un proyecto AWS Flow Framework para Java, como en[Configuración del AWS Flow Framework para Java](setup.md). + En [HelloWorld Solicitud](getting-started-example-helloworld.md), se ofrece una introducción a las aplicaciones de flujo de trabajo. Para ello, se implementa Hello World como aplicación de Java estándar, pero estructurándola como una aplicación de flujo de trabajo. + [HelloWorldWorkflow Solicitud](getting-started-example-helloworldworkflow.md)usa AWS Flow Framework for Java para HelloWorld convertirlo en un flujo de trabajo de Amazon SWF. + [HelloWorldWorkflowAsync Solicitud](getting-started-example-helloworldworkflowasync.md) modifica `HelloWorldWorkflow` para utilizar un método de *flujo de trabajo asíncrono*. + [HelloWorldWorkflowDistributed Solicitud](getting-started-example-helloworldworkflowdistributed.md) modifica `HelloWorldWorkflowAsync` para que los procesos de trabajo de flujo de trabajo y actividad puedan ejecutarse en distintos sistemas. + [HelloWorldWorkflowParallel Solicitud](getting-started-example-helloworldworkflowparallel.md) modifica `HelloWorldWorkflow` para ejecutar dos actividades en paralelo. # Configuración del AWS Flow Framework para Java El AWS Flow Framework para Java se incluye con. [AWS SDK para Java](https://aws.amazon.com/sdkforjava/) Si aún no lo ha configurado AWS SDK para Java, consulte [Introducción](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) en la Guía para AWS SDK para Java desarrolladores para obtener información sobre la instalación y la configuración del propio SDK. ## Agregue el marco de flujo con Maven Las herramientas de compilación de Amazon SWF son de código abierto; para ver o descargar el código o para crear las herramientas usted mismo, visite el repositorio en. [https://github.com/aws/aws-swf-build-tools](https://github.com/aws/aws-swf-build-tools) Amazon proporciona [herramientas de compilación de Amazon SWF en el repositorio](https://mvnrepository.com/artifact/com.amazonaws/aws-swf-build-tools) central de Maven. Para configurar el marco de trabajo del flujo para Maven, añada la siguiente dependencia al archivo `pom.xml` de sus proyectos: ``` com.amazonaws aws-swf-build-tools 2.0.0 ``` # HelloWorld Solicitud Para presentar de qué manera se estructuran las aplicaciones de Amazon SW, crearemos una aplicación de Java que se comporta como flujo de trabajo, pero que se ejecuta localmente en un proceso individual. No será necesario conectarse a Amazon Web Services. **nota** El [HelloWorldWorkflow](getting-started-example-helloworldworkflow.md)ejemplo se basa en este ejemplo y se conecta a Amazon SWF para gestionar el flujo de trabajo. Una aplicación de flujo de trabajo consta de tres componentes básicos: + Un *proceso de trabajo de actividades* admite un conjunto de *actividades*, cada uno de ellos es un método que se ejecuta de manera independiente para realizar una tarea en particular. + Un *proceso de trabajo de flujo de trabajo* organiza la ejecución de las actividades y administra el flujo de datos. Se trata de una realización programática de una *topología de flujo de trabajo*, que es básicamente un diagrama que define cuándo se ejecutan las diferentes actividades, si se ejecutan secuencial o simultáneamente, etc. + Un *iniciador de flujo de trabajo* comienza una instancia de flujo de trabajo, que se denomina *ejecución*, y puede interactuar con ella durante la ejecución. HelloWorld se implementa como tres clases y dos interfaces relacionadas, que se describen en las siguientes secciones. Antes de empezar, debe configurar su entorno de desarrollo y crear un nuevo proyecto AWS Java, tal y como se describe en[Configuración del AWS Flow Framework para Java](setup.md). Los paquetes utilizados para los siguientes tutoriales se denominan todos `helloWorld.XYZ`. Para utilizar esos nombre, configure el atributo `within` en aop.xml tal y como se indica a continuación: ``` ... ``` Para implementarlo HelloWorld, cree un nuevo paquete Java en su proyecto de AWS SDK con el nombre `helloWorld.HelloWorld` y añada los siguientes archivos: + Un archivo de interfaz denominado `GreeterActivities.java` + Un archivo de clase denominado `GreeterActivitiesImpl.java`, que implementa el proceso de trabajo de actividades. + Un archivo de interfaz denominado `GreeterWorkflow.java`. + Un archivo de clase denominado `GreeterWorkflowImpl.java`, que implementa el proceso de trabajo de flujo de trabajo. + Un archivo de clase denominado `GreeterMain.java`, que implementa el iniciador de flujo de trabajo. Los detalles se discuten en las siguientes secciones e incluyen el código completo para cada componente, que puede añadir al archivo apropiado. ## HelloWorld Actividades: Implementación HelloWorld divide la tarea general de imprimir un `"Hello World!"` saludo en la consola en tres tareas, cada una de las cuales se realiza mediante un *método de actividad*. Los métodos de la actividad se definen en la interfaz `GreeterActivities` de la siguiente manera. ``` public interface GreeterActivities { public String getName(); public String getGreeting(String name); public void say(String what); } ``` HelloWorld tiene una implementación de actividad`GreeterActivitiesImpl`, que proporciona los `GreeterActivities` métodos que se muestran a continuación: ``` public class GreeterActivitiesImpl implements GreeterActivities { @Override public String getName() { return "World"; } @Override public String getGreeting(String name) { return "Hello " + name + "!"; } @Override public void say(String what) { System.out.println(what); } } ``` Las actividades son independientes entre sí y con frecuencia pueden ser utilizadas por diferentes flujos de trabajo. Por ejemplo, cualquier flujo de trabajo puede usar la actividad `say` para imprimir una cadena en la consola. Los flujos de trabajo también pueden tener implementaciones de múltiples actividades, cada una de las cuales realiza un conjunto diferentes de tareas. ## HelloWorld Trabajador de Workflow Cómo imprimir “Hello World\$1” en la consola, las tareas de actividades se deben ejecutar en secuencia en el orden correcto y con los datos correctos. El trabajador del HelloWorld flujo de trabajo organiza la ejecución de las actividades basándose en una *topología de flujo de trabajo lineal* simple, como se muestra en la siguiente figura. ![\[Topología de flujo de trabajo lineal\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/helloworld_topology.png) Las tres actividades se ejecutan en secuencia y los datos fluyen de una actividad a la siguiente. El trabajador del HelloWorld flujo de trabajo tiene un único método, el punto de entrada del flujo de trabajo, que se define en la `GreeterWorkflow` interfaz de la siguiente manera: ``` public interface GreeterWorkflow { public void greet(); } ``` La clase `GreeterWorkflowImpl` implementa esta interfaz de la siguiente manera: ``` public class GreeterWorkflowImpl implements GreeterWorkflow{ private GreeterActivities operations = new GreeterActivitiesImpl(); public void greet() { String name = operations.getName(); String greeting = operations.getGreeting(name); operations.say(greeting); } } ``` El `greet` método implementa la HelloWorld topología creando una instancia de`GreeterActivitiesImpl`, llamando a cada método de actividad en el orden correcto y pasando los datos correspondientes a cada método. ## HelloWorld Inicio del flujo de trabajo Un *iniciador del flujo de trabajo* es una aplicación que inicia la ejecución de un flujo de trabajo y que también podría comunicarse con el flujo de trabajo mientras se está ejecutando. La `GreeterMain` clase implementa el iniciador del HelloWorld flujo de trabajo de la siguiente manera: ``` public class GreeterMain { public static void main(String[] args) { GreeterWorkflow greeter = new GreeterWorkflowImpl(); greeter.greet(); } } ``` `GreeterMain` crea una instancia de `GreeterWorkflowImpl` y llama a `greet` para ejecutar el proceso de trabajo del flujo de trabajo. Ejecute `GreeterMain` como una aplicación de Java; al hacerlo, debería poder ver "Hello World\$1" en la consola. # HelloWorldWorkflow Solicitud Aunque el [HelloWorld](getting-started-example-helloworld.md)ejemplo básico está estructurado como un flujo de trabajo, se diferencia de un flujo de trabajo de Amazon SWF en varios aspectos clave: **Aplicaciones de flujo de trabajo convencionales y de Amazon SWF** | HelloWorld | Flujo de trabajo de Amazon SWF | | --- | --- | | Se ejecuta de manera local como un solo proceso. | Se ejecuta como varios procesos que se pueden distribuir en varios sistemas, incluidas EC2 las instancias de Amazon, los centros de datos privados, los ordenadores cliente, etc. Ni siquiera tienen que ejecutar el mismo sistema operativo. | | Las actividades son métodos síncronos, que bloquean hasta que terminan. | Las actividades están representadas mediante métodos asíncronos, que se devuelven inmediatamente y permiten que el flujo de trabajo realice otras tareas mientras esperan a que finalice la actividad. | | El proceso de trabajo del flujo de trabajo interactúa con el proceso de trabajo de las actividades llamando al método adecuado. | Los procesos de trabajo del flujo de trabajo interactúan con los procesos de trabajo de las actividades mediante solicitudes HTTP, donde Amazon SWF actúa de intermediario. | | El iniciador del flujo de trabajo interactúa con el proceso de trabajo del flujo de trabajo llamando al método adecuado. | Los iniciadores de flujos de trabajo interactúan con los procesos de trabajo de los flujos de trabajo mediante solicitudes HTTP, donde Amazon SWF actúa de intermediario. | Podría implementar una aplicación de flujo de trabajo asíncrono distribuida a partir de cero haciendo, por ejemplo, que el proceso de trabajo del flujo de trabajo interactúe con el proceso de trabajo de actividad directamente a través de llamadas a servicios web. Sin embargo, luego tendrá que implementar todo el código tan complicado que es necesario para administrar la ejecución asíncrona de varias actividades, controlar el flujo de datos, etc. Los SWF AWS Flow Framework para Java y Amazon se ocupan de todos esos detalles, lo que le permite centrarse en la implementación de la lógica empresarial. HelloWorldWorkflow es una versión modificada HelloWorld que se ejecuta como un flujo de trabajo de Amazon SWF. La siguiente figura resume cómo funcionan las dos aplicaciones. ![\[Versiones convencionales y de Amazon SWF de “Hello World!”\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/workflow_conceptual_welcome.png) HelloWorld se ejecuta como un proceso único y el iniciador, el trabajador del flujo de trabajo y el trabajador de actividades interactúan mediante llamadas a métodos convencionales. Con `HelloWorldWorkflow`, el iniciador, el proceso de trabajo del flujo de trabajo y el proceso de trabajo de las actividades son componentes distribuidos que interactúan a través de Amazon SWF mediante solicitudes HTTP. Para gestionar la interacción, Amazon SWF mantiene listas de tareas de actividad y de flujos de trabajo, que envía a los componentes correspondientes. En esta sección se describe cómo funciona el marco para HelloWorldWorkflow. HelloWorldWorkflow se implementa mediante la API AWS Flow Framework para Java, que gestiona los detalles, a veces complicados, de la interacción con Amazon SWF en segundo plano y simplifica considerablemente el proceso de desarrollo. Puede utilizar el mismo proyecto para el que utilizó HelloWorld, que ya está configurado AWS Flow Framework para las aplicaciones Java. Sin embargo, para ejecutar la aplicación, debe configurar una cuenta de Amazon SWF de la siguiente forma: + Crea una AWS cuenta, si aún no la tienes, en [Amazon Web Services](https://aws.amazon.com/). + Asigna el ID de acceso y el ID secreto de tu cuenta a las variables de AWS\$1SECRET\$1KEY entorno AWS\$1ACCESS\$1KEY\$1ID y a las variables de entorno, respectivamente. Es recomendable no exponer los valores de las claves literales en el código. Para solucionar este problema, lo más práctico es guardarlas en variables de entorno. + Cree una cuenta de Amazon SWF en [Amazon Simple Workflow Service](https://aws.amazon.com/swf/). + Inicie sesión Consola de administración de AWS y seleccione el servicio Amazon SWF. + Elija **Administrar dominios** en la esquina superior derecha y registre un dominio nuevo de Amazon SWF. Un *dominio* es un contenedor lógico para los recursos de la aplicación, como tipos de flujo de trabajo y actividad, además de para ejecuciones de flujo de trabajo. Puede usar cualquier nombre de dominio conveniente, pero los tutoriales usan "». helloWorldWalkthrough Para implementar el HelloWorldWorkflow, cree una copia de HelloWorld. HelloWorld empaquete en el directorio de su proyecto y asígnele el nombre HelloWorld. HelloWorldWorkflow. En las siguientes secciones se describe cómo modificar el HelloWorld código original para usarlo AWS Flow Framework para Java y ejecutarlo como una aplicación de flujo de trabajo de Amazon SWF. ## HelloWorldWorkflow Trabajador de actividades HelloWorld implementó sus actividades como trabajador como una sola clase. Un trabajador de actividades AWS Flow Framework para Java tiene tres componentes básicos: + Los *métodos de actividad*, que realizan las tareas propiamente dichas, se definen en una interfaz y se implementan en una clase relacionada. + Una [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)clase gestiona la interacción entre los métodos de actividad y Amazon SWF. + Una aplicación *host de actividades* registra e inicia el proceso de trabajo de actividades y se encarga de la limpieza. En esta sección, se explican los métodos de actividades; las otras dos clases se explicarán más adelante. HelloWorldWorkflow define la interfaz de actividades de `GreeterActivities` la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Activities; import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions; @ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300, defaultTaskStartToCloseTimeoutSeconds = 10) @Activities(version="1.0") public interface GreeterActivities { public String getName(); public String getGreeting(String name); public void say(String what); } ``` Esta interfaz no era estrictamente necesaria para una aplicación Java HelloWorld, pero sí lo es AWS Flow Framework para una aplicación Java. Fíjese en que la definición de la interfaz en sí no ha cambiado. Sin embargo, debe aplicar dos AWS Flow Framework para las anotaciones de Java [@ActivityRegistrationOptions](annotations.md#annotations-activityregistration) y[@Tareas](annotations.md#annotations-activities), a la definición de la interfaz. Las anotaciones proporcionan información de configuración e indican al AWS Flow Framework procesador de anotaciones de Java que utilice la definición de la interfaz para generar una clase de *cliente de actividades*, como se explica más adelante. `@ActivityRegistrationOptions`tiene varios valores con nombre que se utilizan para configurar el comportamiento de las actividades. HelloWorldWorkflow especifica dos tiempos de espera: + `defaultTaskScheduleToStartTimeoutSeconds` especifica durante cuánto tiempo pueden estar en cola las tareas en la lista de tareas de actividad y se establece en 300 segundos (5 minutos). + `defaultTaskStartToCloseTimeoutSeconds` especifica el tiempo máximo que puede tardar la actividad en realizar la tarea y se establece en 10 segundos. Estos tiempos de espera garantizan que la actividad complete su tarea en un tiempo razonable. Si se supera cualquiera de estos tiempos de espera, el marco de trabajo genera un error y el proceso de trabajo de flujo de trabajo debe decidir cómo tratar el problema. Para leer un debate sobre cómo tratar estos errores, consulte [Gestión de errores](errorhandling.md). `@Activities` tiene varios valores, pero normalmente tan solo especifica el número de versión de las actividades, lo que le permite realizar un seguimiento de diferentes generaciones de implementaciones de las actividades. Si cambia una interfaz de actividad después de registrarla con Amazon SWF, lo que incluye cambiar los valores de `@ActivityRegistrationOptions`, debe utilizar un número de versión nuevo. HelloWorldWorkflow implementa los métodos de actividad de `GreeterActivitiesImpl` la siguiente manera: ``` public class GreeterActivitiesImpl implements GreeterActivities { @Override public String getName() { return "World"; } @Override public String getGreeting(String name) { return "Hello " + name; } @Override public void say(String what) { System.out.println(what); } } ``` Observe que el código es idéntico a la HelloWorld implementación. En esencia, una AWS Flow Framework actividad es solo un método que ejecuta algún código y, tal vez, devuelve un resultado. La diferencia entre una aplicación estándar y una aplicación de flujo de trabajo de Amazon SWF radica en la forma en que el flujo de trabajo ejecuta las actividades, dónde se ejecutan estas y cómo se devuelven los resultados al proceso de trabajo de flujo de trabajo. ## HelloWorldWorkflow Trabajador de Workflow Un proceso de trabajo de flujo de trabajo de Amazon SWF posee tres componentes básicos: + Una *implementación de flujo de trabajo*, que es una clase que realiza las tareas relacionadas con el flujo de trabajo. + Una clase de *cliente de actividades*, que básicamente es un proxy para la clase de actividades y se utiliza en una implementación de flujo de trabajo para ejecutar métodos de actividades de manera asíncrona. + Una [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html)clase que gestiona la interacción entre el flujo de trabajo y Amazon SWF. En esta sección, se explica la implementación del flujo de trabajo y el cliente de actividades; la clase `WorkflowWorker` se explicará más adelante. HelloWorldWorkflow define la interfaz del flujo de trabajo de `GreeterWorkflow` la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Execute; import com.amazonaws.services.simpleworkflow.flow.annotations.Workflow; import com.amazonaws.services.simpleworkflow.flow.annotations.WorkflowRegistrationOptions; @Workflow @WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 3600) public interface GreeterWorkflow { @Execute(version = "1.0") public void greet(); } ``` Esta interfaz tampoco es estrictamente necesaria HelloWorld , pero es esencial para una aplicación AWS Flow Framework para Java. Debe aplicar dos AWS Flow Framework para las anotaciones de Java [@Flujo de trabajo](annotations.md#annotations-workflow) y[@WorkflowRegistrationOptions](annotations.md#annotations-workflowregistrationoptions), a la definición de la interfaz de flujo de trabajo. Las anotaciones proporcionan información de configuración y también indican al procesador de anotaciones AWS Flow Framework para Java que genere una clase de cliente de flujo de trabajo basada en la interfaz, como se explica más adelante. `@Workflow`tiene un parámetro opcional, *DataConverter*, que suele utilizarse con su valor predeterminado, NullDataConverter, que indica que JsonDataConverter debe utilizarse. `@WorkflowRegistrationOptions` también posee una serie de parámetros opcionales que se pueden utilizar para configurar el proceso de trabajo de flujo de trabajo. Aquí, hay que establecer `defaultExecutionStartToCloseTimeoutSeconds`, que especifica el tiempo durante el que puede ejecutarse el flujo de trabajo: hasta 3600 segundos (1 hora). La definición de la `GreeterWorkflow` interfaz difiere de HelloWorld la [@Execute](annotations.md#annotations-execute) anotación en un aspecto importante. Las interfaces de flujo de trabajo especifican los métodos a los que pueden llamar las aplicaciones como el iniciador de flujo de trabajo y se limitan a un puñado de métodos, cada uno con un rol particular. El marco de trabajo no especifica una lista de parámetros o de nombres para los métodos de la interfaz del flujo de trabajo; se utiliza una lista de parámetros y nombres que sea adecuada para el flujo de trabajo y se aplica una anotación de AWS Flow Framework para Java con el fin de identificar el rol del método. `@Execute` tiene dos fines: + Identifica `greet` como el punto de entrada del flujo de trabajo; es decir, el método al que llama el iniciador del flujo de trabajo para iniciar el flujo de trabajo. En general, un punto de entrada puede tomar uno o más parámetros, lo que permite al iniciador inicializar el flujo de trabajo, pero en este ejemplo no es necesario realizar la inicialización. + Especifica el número de versión del flujo de trabajo, lo que le permite realizar un seguimiento de diferentes generaciones de implementaciones del flujo de trabajo. Para cambiar una interfaz de flujo de trabajo después de registrarla con Amazon SWF, lo que incluye cambiar los valores de tiempo de espera, debe utilizar un número de versión nuevo. Para obtener información acerca de otros métodos que se pueden incluir en una interfaz de flujo de trabajo, consulte [Contratos de flujo de trabajo y de actividad](features.workflow.md). HelloWorldWorkflow implementa el flujo de trabajo de `GreeterWorkflowImpl` la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.core.Promise; public class GreeterWorkflowImpl implements GreeterWorkflow { private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl(); public void greet() { Promise name = operations.getName(); Promise greeting = operations.getGreeting(name); operations.say(greeting); } } ``` El código es similar a HelloWorld, pero con dos diferencias importantes. + `GreeterWorkflowImpl` crea una instancia de `GreeterActivitiesClientImpl`, el cliente de actividades, en lugar de `GreeterActivitiesImpl`, y ejecuta las actividades llamando a los métodos en el objeto de cliente. + Las actividades name y greeting devuelven objetos `Promise` en lugar de objetos `String`. HelloWorld es una aplicación Java estándar que se ejecuta localmente como un proceso único, por lo que `GreeterWorkflowImpl` puede implementar la topología del flujo de trabajo simplemente creando una instancia de`GreeterActivitiesImpl`, llamando a los métodos en orden y pasando los valores devueltos de una actividad a la siguiente. Con un flujo de trabajo de Amazon SWF, un método de actividad sigue realizando una tarea de actividad desde `GreeterActivitiesImpl`. Sin embargo, el método no se ejecuta necesariamente en el mismo proceso que el flujo de trabajo (es posible que ni siquiera se ejecute en el mismo sistema) y el flujo de trabajo tiene que ejecutar la actividad de manera asíncrona. Estos requisitos plantean los siguientes problemas: + Cómo ejecutar un método de actividad que podría estar ejecutándose en un proceso diferente, quizá en otro sistema. + Cómo ejecutar un método de actividad de manera asíncrona. + Cómo administrar los valores de entrada y retorno de las actividades. Por ejemplo, si el valor de retorno de la Actividad A es una entrada en la Actividad B, debe asegurarse de que la Actividad B no se ejecute hasta que la Actividad A haya terminado. Puede implementar una gran variedad de topologías de flujos de trabajo a través del flujo de control de la aplicación utilizando un control de flujo de Java conocido combinado con el cliente de actividades y `Promise`. ### Cliente de actividades `GreeterActivitiesClientImpl` básicamente es un proxy para `GreeterActivitiesImpl` que permite que una implementación de flujo de trabajo ejecute los métodos `GreeterActivitiesImpl` de manera asíncrona. Las clases `GreeterActivitiesClient` y `GreeterActivitiesClientImpl` se generan automáticamente utilizando la información que se proporciona en las anotaciones que se aplican a la clase `GreeterActivities`. No es necesario que las implemente personalmente. **nota** Eclipse genera estas clases al guardar el proyecto. Puede ver el código generado en el subdirectorio `.apt_generated` del directorio del proyecto. Para evitar errores de compilación en la clase `GreeterWorkflowImpl`, es recomendable mover el directorio `.apt_generated` a la parte superior de la pestaña **Order and Export** (Pedido y exportación) del cuadro de diálogo **Java Build Path** (Ruta de compilación Java). El proceso de trabajo del flujo de trabajo ejecuta una actividad llamando al método de cliente correspondiente. El método es asíncrono y devuelve inmediatamente un objeto `Promise`, donde `T` es el tipo de retorno de la actividad. El objeto `Promise` devuelto es básicamente un marcador de posición del valor que devolverá al final el método de la actividad. + Cuando se devuelve el método del cliente de las actividades, el objeto `Promise` se encuentra inicialmente en *estado no preparado*, lo que indica que el objeto no representa aún un valor de retorno válido. + Cuando el método de actividad correspondiente termina su tarea y se devuelve, el marco de trabajo asigna el valor de retorno al objeto `Promise` y lo establece en *estado preparado*. ### Promise Type La principal finalidad de los objetos `Promise` es administrar el flujo de datos entre los componentes asíncronos y el control cuando se ejecutan. De esta forma, la aplicación ya no tiene que administrar la sincronización de forma explícita ni depender de mecanismos, como temporizadores, para asegurarse de que los componentes asíncronos no se ejecutan de forma prematura. Cuando se llama a un método del cliente de actividades, este se devuelve inmediatamente, pero el marco de trabajo aplaza la ejecución del método de actividad correspondiente hasta que haya preparado algún objeto `Promise` de entrada que represente datos válidos. Desde la perspectiva de `GreeterWorkflowImpl`, los tres métodos de cliente de las actividades se devuelven inmediatamente. Desde la perspectiva de `GreeterActivitiesImpl`, el marco de trabajo no llama a `getGreeting` hasta que `name` termina y no llama a `say` hasta que `getGreeting` termina. Si utilizamos `Promise` para pasar datos de una actividad a la siguiente, `HelloWorldWorkflow` no solo se asegura de que los métodos de actividad no intentan utilizar datos no válidos, sino que también controla cuándo se ejecutan las actividades y define de manera implícita la topología del flujo de trabajo. Para pasar el valor de retorno de `Promise` de cada actividad a la siguiente, es necesario que las actividades se ejecuten en secuencia, definiendo la topología lineal que se ha explicado anteriormente. En el caso AWS Flow Framework de Java, no es necesario utilizar ningún código de modelado especial para definir incluso topologías complejas, solo el control de flujo estándar de Java y. `Promise` Para ver un ejemplo detallado de cómo implementar una topología en paralelo sencilla, consulte [HelloWorldWorkflowParallel Actividades: Trabajador](getting-started-example-helloworldworkflowparallel.md#getting-started-example-helloworldworkflowparallel.activities). **nota** Cuando un método de actividad como `say` no devuelve un valor, el método de cliente correspondiente devuelve un objeto `Promise`. El objeto no representa datos, pero al principio no está preparado y lo está cuando termina la actividad. Por lo tanto, se puede pasar un objeto `Promise` a otros métodos de cliente de actividades para asegurarse de que aplazan su ejecución hasta que termina la actividad original. `Promise` permite que en una implementación de flujo de trabajo se utilicen métodos de cliente de actividades y sus valores de retorno de una forma muy parecida a los métodos síncronos. Sin embargo, debe tener cuidado al obtener acceso al valor de un objeto `Promise`. A diferencia del tipo [Future](http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html) de Java, el marco de trabajo se encarga de la sincronización para `Promise`, no la aplicación. Si llama a `Promise.get` y el objeto no está preparado, `get` genera una excepción. Fíjese en que `HelloWorldWorkflow` nunca obtiene acceso directamente al objeto `Promise`; simplemente pasa los objetos de una actividad a la siguiente. Cuando un objeto está preparado, el marco de trabajo extrae el valor y lo pasa al método de actividad como un tipo estándar. Solo se debería obtener acceso a los objetos `Promise` por medio de código asíncrono, donde el marco de trabajo garantiza que el objeto está preparado y representa un valor válido. Para solucionar este problema, `HelloWorldWorkflow` pasa objetos `Promise` solo a métodos de cliente de actividades. Para obtener acceso al valor de un objeto `Promise` en la implementación del flujo de trabajo, pase el objeto a un *método de flujo de trabajo asíncrono*, que se comporta de una forma muy parecida a una actividad. Para ver un ejemplo, consulta [HelloWorldWorkflowAsync Solicitud](getting-started-example-helloworldworkflowasync.md). ## HelloWorldWorkflow Implementación de flujos de trabajo y actividades Las implementaciones del flujo de trabajo y las actividades tienen clases de trabajadores asociadas, [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)y [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html). Estas clases se encargan de la comunicación entre Amazon SWF y las implementaciones de actividades y flujos de trabajo al sondear la lista de tareas de Amazon SWF apropiada para buscar tareas, a la vez que ejecutan el método adecuado para cada tarea y administran el flujo de datos. Para obtener más información, consulte [AWS Flow Framework Conceptos básicos: estructura de la aplicación](awsflow-basics-application-structure.md) Para asociar las implementaciones de actividades y flujos de trabajo con los objetos de proceso de trabajo correspondientes, tiene que implementar una o varias aplicaciones de proceso de trabajo que: + Registren flujos de trabajo o actividades en Amazon SWF. + Creen objetos de procesos de trabajo y los asocien con las implementaciones del proceso de trabajo del flujo de trabajo o la actividad. + Indiquen a los objetos del proceso de trabajo que comiencen a comunicarse con Amazon SWF. Si desea ejecutar el flujo de trabajo y las actividades como procesos independientes, debe implementar distintos hosts de procesos de trabajo de flujos de trabajo y actividades. Para ver un ejemplo, consulta [HelloWorldWorkflowDistributed Solicitud](getting-started-example-helloworldworkflowdistributed.md). Para simplificar, HelloWorldWorkflow implementa un único servidor de trabajo que ejecuta las actividades y los trabajadores del flujo de trabajo en el mismo proceso, de la siguiente manera: ``` 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().withSocketTimeout(70*1000); String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID"); String swfSecretKey = System.getenv("AWS_SECRET_KEY"); AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swfSecretKey); AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials, config); service.setEndpoint("https://swf.us-east-1.amazonaws.com"); String domain = "helloWorldWalkthrough"; 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`no tiene HelloWorld contrapartida, por lo que debe añadir una clase Java denominada `GreeterWorker` al proyecto y copiar el código de ejemplo en ese archivo. El primer paso consiste en crear y configurar un [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objeto que invoque los métodos de servicio de Amazon SWF subyacentes. Para ello, `GreeterWorker`: 1. Crea un [ClientConfiguration](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/ClientConfiguration.html)objeto y especifica un tiempo de espera del socket de 70 segundos. Este valor especifica cuánto hay que esperar a que se transfieran los datos en una conexión abierta establecida antes de cerrar el conector. 1. Crea un AWSCredentials objeto [básico](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/BasicAWSCredentials.html) para identificar la AWS cuenta y pasa las claves de la cuenta al constructor. Por comodidad, y para evitar que queden expuestas en texto sin formato en el código, las claves se almacenan en variables de entorno. 1. Crea un [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objeto para representar el flujo de trabajo y pasa los `ClientConfiguration` objetos `BasicAWSCredentials` y al constructor. 1. Establece la dirección URL del punto de conexión del servicio del objeto del cliente. Amazon SWF está disponible actualmente en todas las AWS regiones. Por comodidad, `GreeterWorker` define dos constantes de cadena. + `domain`es el nombre de dominio Amazon SWF del flujo de trabajo, que creó al configurar su cuenta de Amazon SWF. `HelloWorldWorkflow`asume que está ejecutando el flujo de trabajo en el dominio helloWorldWalkthrough "». + `taskListToPoll` es el nombre de las listas de tareas que utiliza Amazon SWF para administrar la comunicación entre los procesos de trabajo de flujos de trabajo y de actividades. Puede establecer el nombre en cualquier cadena que le resulte conveniente. HelloWorldWorkflow usa "HelloWorldList" tanto para las listas de tareas del flujo de trabajo como para las de actividades. Internamente, los nombres terminan en diferentes espacios de nombres, por lo que las dos listas de tareas están diferenciadas. `GreeterWorker`utiliza las constantes de cadena y el [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objeto para crear objetos de trabajo, que gestionan la interacción entre las actividades y las implementaciones de los trabajadores y Amazon SWF. En particular, los objetos del proceso de trabajo se encargan de la tarea de sondeo de la lista de tareas correspondiente para buscar tareas. `GreeterWorker` crea un objeto `ActivityWorker` y lo configura para que se encargue de `GreeterActivitiesImpl` añadiendo una nueva instancia de clase. Luego, `GreeterWorker` llama al método `start` del objeto `ActivityWorker`, que le indica al objeto que comience a sondear la lista de tareas de actividad especificada. `GreeterWorker` crea un objeto `WorkflowWorker` y lo configura para que se encargue de `GreeterWorkflowImpl` añadiendo el nombre de archivo de clase, `GreeterWorkflowImpl.class`. Luego, llama al método `start` del objeto `WorkflowWorker`, que le indica al objeto que comience a sondear la lista de tareas del flujo de trabajo especificada. En este momento, puede ejecutar `GreeterWorker` correctamente. Registra el flujo de trabajo y las actividades con Amazon SWF y hace que los objetos del proceso de trabajo comiencen a sondear sus correspondientes listas de tareas. Para verificar esto, ejecute `GreeterWorker`, vaya a la consola de Amazon SWF y seleccione `helloWorldWalkthrough` en la lista de dominios. Si elige **Workflow Types** (Tipos de flujo de trabajo) en el panel **Navigation** (Navegación), debería ver `GreeterWorkflow.greet`: ![\[HelloWorldWorkflow tipo de flujo de trabajo\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/Workflow_Type.png) Si elige **Activity Types** (Tipos de actividad), se muestran los métodos `GreeterActivities`: ![\[HelloWorldWorkflow tipos de actividad\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/Activity_Types.png) Sin embargo, si elige **Workflow Executions** (Ejecuciones de flujo de trabajo), verá las ejecuciones activas. Aunque los procesos de trabajo de flujos de trabajo y actividades sondean tareas, aún no hemos iniciado una ejecución de flujo de trabajo. ## HelloWorldWorkflow Motor de arranque La última pieza del puzle es la implementación de un iniciador de flujo de trabajo, que es una aplicación que inicia la ejecución del flujo de trabajo. Amazon SWF almacena el estado de ejecución para que pueda ver su historial y su estado de ejecución. HelloWorldWorkflow implementa un iniciador de flujo de trabajo modificando la `GreeterMain` clase de la siguiente manera: ``` 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; public class GreeterMain { public static void main(String[] args) throws Exception { ClientConfiguration config = new ClientConfiguration().withSocketTimeout(70*1000); String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID"); String swfSecretKey = System.getenv("AWS_SECRET_KEY"); AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swfSecretKey); AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials, config); service.setEndpoint("https://swf.us-east-1.amazonaws.com"); String domain = "helloWorldWalkthrough"; GreeterWorkflowClientExternalFactory factory = new GreeterWorkflowClientExternalFactoryImpl(service, domain); GreeterWorkflowClientExternal greeter = factory.getClient("someID"); greeter.greet(); } } ``` `GreeterMain` crea un objeto `AmazonSimpleWorkflowClient` utilizando el mismo código que `GreeterWorker`. Luego, crea un objeto `GreeterWorkflowClientExternal`, que sirve de proxy para el flujo de trabajo, de una forma muy parecida al cliente de actividades creado en `GreeterWorkflowClientImpl`, que sirve de proxy para los métodos de actividades. En lugar de crear un objeto de cliente de flujo de trabajo mediante `new`, debe: 1. Crear un objeto de fábrica de clientes externo y pasar el objeto `AmazonSimpleWorkflowClient` y el nombre de dominio de Amazon SWF al constructor. El objeto de fábrica del cliente lo crea el procesador de anotaciones del marco, que crea el nombre del objeto simplemente añadiendo «ClientExternalFactoryImpl» al nombre de la interfaz de flujo de trabajo. 1. Cree un objeto cliente externo llamando al `getClient` método del objeto de fábrica, que crea el nombre del objeto añadiendo "ClientExternal" al nombre de la interfaz de flujo de trabajo. Opcionalmente, puede pasar a `getClient` una cadena que utilizará Amazon SWF para identificar esta instancia del flujo de trabajo. De lo contrario, Amazon SWF utiliza un GUID generado para representar una instancia de flujo de trabajo. El cliente que se devuelve de la fábrica solo crea flujos de trabajo con el nombre de la cadena que se haya pasado al método [getClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowClientFactoryExternal.html#getClient(java.lang.String)) (el cliente que se ha devuelto de la fábrica ya tiene un estado en Amazon SWF). Para ejecutar un flujo de trabajo con un identificador diferente, hay que volver a la fábrica y crear un cliente nuevo especificando el identificador diferente. El cliente de flujo de trabajo expone un método `greet` al que llama `GreeterMain` para comenzar el flujo de trabajo, ya que `greet()` es el método que se ha especificado con la anotación `@Execute`. **nota** El procesador de anotaciones también crea un objeto de fábrica de clientes interno que se utiliza para crear flujos de trabajo secundarios. Para obtener más información, consulte [Ejecuciones de flujo de trabajo secundario](childworkflow.md). Cierre `GreeterWorker` por ahora, si aún se está ejecutando, y ejecute `GreeterMain`. Ahora debería ver someID en la lista de ejecuciones de flujos de trabajo activas de la consola de Amazon SWF: ![\[HelloWorldWorkflow ejecuciones de flujos de trabajo\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/Active_Execution.png) Si elige `someID` y luego la pestaña **Events** (Eventos), se muestran los eventos: ![\[HelloWorldWorkflow eventos iniciales del flujo de trabajo\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/Events1.png) **nota** Si ha iniciado `GreeterWorker` anteriormente y sigue ejecutándose, verá una lista de eventos más larga por los motivos que vamos a explicar en breve. Detenga `GreeterWorker` e intente ejecutar de nuevo `GreaterMain`. En la pestaña **Events** (Eventos) solo aparecen dos eventos: + `WorkflowExecutionStarted` indica que el flujo de trabajo ha comenzado a ejecutarse. + `DecisionTaskScheduled` indica que Amazon SWF ha puesto en cola la primera tarea de decisión. El motivo de que el flujo de trabajo se bloquee en la primera tarea de decisión es porque está distribuido en dos aplicaciones: `GreeterMain` y `GreeterWorker`. `GreeterMain` ha comenzado la ejecución del flujo de trabajo, pero `GreeterWorker` no se está ejecutando, por lo que los procesos de trabajo no sondean las listas ni ejecutan tareas. Puede ejecutar cualquiera de las aplicaciones de forma independiente, pero necesita ambas para que la ejecución del flujo de trabajo continúe después de la primera tarea de decisión. Si ahora ejecuta `GreeterWorker`, los procesos de trabajo de flujo de trabajo y actividad comenzarán a realizar el sondeo y las diversas tareas se realizarán rápidamente. Si comprueba ahora la pestaña `Events` (Eventos), verá el primer lote de eventos. ![\[HelloWorldWorkflow eventos de flujo de trabajo completos\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/Events2.png) Puede elegir eventos individuales para obtener más información. Cuando haya terminado de consultarlos, el flujo de trabajo debería haber imprimido las palabras “Hello World\$1” en la consola. Una vez completado el flujo de trabajo, desaparece de la lista de ejecuciones activas. Sin embargo, si desea revisarlo, elija el botón de estado de ejecución **Closed** (Cerrado) y luego elija **List Executions** (Lista de ejecuciones). Aquí se muestran todas las instancias de flujo de trabajo completadas en el dominio especificado (`helloWorldWalkthrough`) que no han superado su tiempo de retención, que especificó en el momento de crear el dominio. ![\[HelloWorldWorkflow flujos de trabajo completados\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/Closed_Workflows.png) Fíjese en que cada instancia de flujo de trabajo tiene un valor de **Run ID** (Identificador de ejecución) único. Puede usar el mismo ID de flujo de trabajo para distintas instancias de flujo de trabajo, pero solo para una ejecución activa a la vez. # HelloWorldWorkflowAsync Solicitud En ocasiones es preferible que un flujo de trabajo realice determinadas tareas localmente en lugar de usar una actividad. No obstante, las tareas de flujo de trabajo con frecuencia conllevan procesar valores representados por objetos `Promise`. Si pasa un objeto `Promise` a un método de flujo de trabajo asíncrono, el método se ejecuta inmediatamente pero no puede obtener acceso al valor del objeto `Promise` hasta que el objeto esté listo. Podría sondear `Promise.isReady` hasta que devuelva `true`, pero eso, además de no ser eficaz, haría que el método pudiera quedar bloqueado durante un largo periodo. Es mejor utilizar un *método asíncrono*. Un método asíncrono se implementa de forma muy parecida a un método estándar, con frecuencia como miembro de la clase de implementación de flujo de trabajo, y se ejecuta en el contexto de la implementación de flujo de trabajo. Usted lo designa como método asíncrono aplicando una anotación `@Asynchronous`, la cual indica al marco de trabajo que debe tratarlo de forma muy parecida a una actividad. + Cuando una implementación de flujo de trabajo llama a un método asíncrono, se devuelve de inmediato. Los métodos asíncronos habitualmente devuelven un objeto `Promise`, el cual queda listo una vez que el método termina. + Si pasa uno o más objetos `Promise` a un método asíncrono, difiere la ejecución hasta que todos los objetos de entrada estén listos. Un método asíncrono puede por tanto obtener acceso a su valores `Promise` de entrada sin arriesgar a que se produzca una excepción. **nota** Debido a la forma en que Java ejecuta el flujo AWS Flow Framework de trabajo, los métodos asíncronos suelen ejecutarse varias veces, por lo que solo debe usarlos para tareas rápidas y de bajo coste. Debería utilizar actividades para realizar tareas prolongadas, como grandes cálculos. Para obtener más información, consulte [AWS Flow Framework Conceptos básicos: ejecución distribuida](awsflow-basics-distributed-execution.md). Este tema es un recorrido por una versión modificada HelloWorldWorkflow que reemplaza una de las actividades por un método asíncrono. HelloWorldWorkflowAsync Para implementar la aplicación, cree una copia de HelloWorld. HelloWorldWorkflow empaquete en el directorio de su proyecto y asígnele el nombre HelloWorld. HelloWorldWorkflowAsync. **nota** En este tema se basa en los conceptos y los archivos que se presentan en los temas [HelloWorld Solicitud](getting-started-example-helloworld.md) y [HelloWorldWorkflow Solicitud](getting-started-example-helloworldworkflow.md). Familiarizarse con los archivos y conceptos que se presentan en estos temas antes de continuar. En las siguientes secciones se describe cómo modificar el HelloWorldWorkflow código original para utilizar un método asíncrono. ## HelloWorldWorkflowAsync Implementación de actividades HelloWorldWorkflowAsync implementa su interfaz de trabajo de actividades de `GreeterActivities` la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Activities; import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions; @Activities(version="2.0") @ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300, defaultTaskStartToCloseTimeoutSeconds = 10) public interface GreeterActivities { public String getName(); public void say(String what); } ``` Esta interfaz es similar a la utilizada por HelloWorldWorkflow, con las siguientes excepciones: + Omite la actividad `getGreeting`; esa tarea la realiza ahora un método asíncrono. + El número de versión se establece en 2.0. Una vez que haya registrado una interfaz de actividades con Amazon SWF, no podrá modificarla a menos que cambie el número de versión. El resto de las implementaciones del método de actividad son idénticas a HelloWorldWorkflow. Simplemente elimine `getGreeting` de `GreeterActivitiesImpl`. ## HelloWorldWorkflowAsync Aplicación del flujo de trabajo HelloWorldWorkflowAsync define la interfaz de flujo de trabajo de la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Execute; import com.amazonaws.services.simpleworkflow.flow.annotations.Workflow; import com.amazonaws.services.simpleworkflow.flow.annotations.WorkflowRegistrationOptions; @Workflow @WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 3600) public interface GreeterWorkflow { @Execute(version = "2.0") public void greet(); } ``` La interfaz es idéntica a, HelloWorldWorkflow excepto por un nuevo número de versión. Al igual que ocurre con las actividades, si desea cambiar un flujo de trabajo registrado, tiene que cambiar su versión. HelloWorldWorkflowAsync implementa el flujo de trabajo de la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Asynchronous; import com.amazonaws.services.simpleworkflow.flow.core.Promise; public class GreeterWorkflowImpl implements GreeterWorkflow { private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl(); @Override public void greet() { Promise name = operations.getName(); Promise greeting = getGreeting(name); operations.say(greeting); } @Asynchronous private Promise getGreeting(Promise name) { String returnString = "Hello " + name.get() + "!"; return Promise.asPromise(returnString); } } ``` HelloWorldWorkflowAsync reemplaza la `getGreeting` actividad por un método `getGreeting` asíncrono, pero el `greet` método funciona prácticamente de la misma manera: 1. Ejecute la actividad `getName`, lo cual devuelve inmediatamente un objeto `Promise`, `name`, que representa el nombre. 1. Llame al método asíncrono `getGreeting` y pásele el objeto `name`. `getGreeting` devuelve inmediatamente un objeto `Promise`, `greeting`, que representa el saludo. 1. Ejecute la actividad `say` y pásele el objeto `greeting`. 1. Una vez que se completa `getName`, `name` pasa a estar listo y `getGreeting` utiliza su valor para construir el saludo. 1. Una vez que `getGreeting` finaliza, `greeting` está listo y `say` imprime la cadena en la consola. La diferencia está en que, en lugar de llamar al cliente de actividades para ejecutar una actividad `getGreeting`, el saludo llama al método asíncrono `getGreeting`. El resultado final es el mismo, pero el método `getGreeting` funciona de manera algo diferente a la actividad `getGreeting`. + El proceso de trabajo de flujo de trabajo utiliza la semántica de llamada de función estándar para ejecutar `getGreeting`. No obstante, Amazon SWF actúa como intermediario en la ejecución asíncrona de la actividad. + `getGreeting` ejecuta el proceso de implementación del flujo de trabajo. + `getGreeting` devuelve un objeto `Promise` en lugar de un objeto `String`. Para obtener el valor de la cadena contenido en `Promise`, usted tendrá que llamar a su método `get()`. Sin embargo, dado que la actividad se ejecuta de forma asíncrona, es posible que su valor devuelto no esté listo inmediatamente; se `get()` generará una excepción hasta que el valor devuelto por el método asincrónico esté disponible. Para obtener más información sobre cómo funciona `Promise`, consulte [AWS Flow Framework Conceptos básicos: Data Exchange entre actividades y flujos de trabajo](awsflow-basics-data-exchange-activities-workflows.md). `getGreeting` crea un valor de retorno pasando la cadena del saludo al método estático `Promise.asPromise`. Este método crea un objeto `Promise` del tipo apropiado, establece el valor y lo pone en el estado listo. ## HelloWorldWorkflowAsync Organizador e iniciador del flujo de trabajo y las actividades HelloWorldWorkflowAsync implementa `GreeterWorker` como clase anfitriona para las implementaciones de flujos de trabajo y actividades. Es idéntica a la HelloWorldWorkflow implementación excepto por el `taskListToPoll` nombre, que se establece en "`HelloWorldAsyncList`». ``` 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().withSocketTimeout(70*1000); String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID"); String swfSecretKey = System.getenv("AWS_SECRET_KEY"); AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swfSecretKey); AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials, config); service.setEndpoint("https://swf.us-east-1.amazonaws.com"); String domain = "helloWorldWalkthrough"; String taskListToPoll = "HelloWorldAsyncList"; 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(); } } ``` HelloWorldWorkflowAsync implementa el flujo de trabajo inicial en`GreeterMain`; es idéntico a la HelloWorldWorkflow implementación. Para ejecutar el flujo de trabajo, ejecute `GreeterWorker` y`GreeterMain`, igual que con HelloWorldWorkflow. # HelloWorldWorkflowDistributed Solicitud Con HelloWorldWorkflow y HelloWorldWorkflowAsync, Amazon SWF media la interacción entre el flujo de trabajo y las implementaciones de las actividades, pero se ejecutan localmente como un solo proceso. `GreeterMain`se encuentra en un proceso independiente, pero sigue ejecutándose en el mismo sistema. Una característica clave de Amazon SWF es que admite aplicaciones distribuidas. Por ejemplo, puedes ejecutar el Workflow Worker en una EC2 instancia de Amazon, el iniciador del flujo de trabajo en un ordenador de un centro de datos y las actividades en un ordenador de escritorio cliente. Es posible incluso ejecutar diferentes actividades en diferentes sistemas. La HelloWorldWorkflowDistributed aplicación se extiende HelloWorldWorkflowAsync para distribuirla en dos sistemas y tres procesos. + El flujo de trabajo y el iniciador del flujo de trabajo se ejecutan como procesos independientes en un sistema. + Las actividades se ejecutan en un sistema independiente. Para implementar la aplicación, cree una copia de HelloWorld. HelloWorldWorkflowAsync empaquete en el directorio de su proyecto y asígnele el nombre HelloWorld. HelloWorldWorkflowDistributed. En las siguientes secciones se describe cómo modificar el HelloWorldWorkflowAsync código original para distribuir la aplicación en dos sistemas y tres procesos. No es necesario que cambie el flujo de trabajo o las implementaciones de actividades para ejecutarlos en sistemas independientes, ni tan siquiera los números de versión. Tampoco es necesario que modifique `GreeterMain`. Solo tiene que cambiar las actividades y el host del flujo de trabajo. Con HelloWorldWorkflowAsync, una sola aplicación sirve como anfitrión del flujo de trabajo y de la actividad. Para ejecutar las implementaciones de flujo de trabajo y actividad en sistemas independientes, tiene que implementar aplicaciones independientes. Elimine GreeterWorker del proyecto y añada dos nuevos archivos de clases, GreeterWorkflowWorker y GreeterActivitiesWorker. HelloWorldWorkflowDistributed implementa sus actividades alojadas en GreeterActivitiesWorker, de la siguiente manera: ``` 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; public class GreeterActivitiesWorker { public static void main(String[] args) throws Exception { ClientConfiguration config = new ClientConfiguration().withSocketTimeout(70*1000); String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID"); String swfSecretKey = System.getenv("AWS_SECRET_KEY"); AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swfSecretKey); AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials, config); service.setEndpoint("https://swf.us-east-1.amazonaws.com"); String domain = "helloWorldExamples"; String taskListToPoll = "HelloWorldAsyncList"; ActivityWorker aw = new ActivityWorker(service, domain, taskListToPoll); aw.addActivitiesImplementation(new GreeterActivitiesImpl()); aw.start(); } } ``` HelloWorldWorkflowDistributed implementa su host de flujo de trabajo `GreeterWorkflowWorker` de la siguiente manera: ``` 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.WorkflowWorker; public class GreeterWorkflowWorker { public static void main(String[] args) throws Exception { ClientConfiguration config = new ClientConfiguration().withSocketTimeout(70*1000); String swfAccessId = System.getenv("AWS_ACCESS_KEY_ID"); String swfSecretKey = System.getenv("AWS_SECRET_KEY"); AWSCredentials awsCredentials = new BasicAWSCredentials(swfAccessId, swfSecretKey); AmazonSimpleWorkflow service = new AmazonSimpleWorkflowClient(awsCredentials, config); service.setEndpoint("https://swf.us-east-1.amazonaws.com"); String domain = "helloWorldExamples"; String taskListToPoll = "HelloWorldAsyncList"; WorkflowWorker wfw = new WorkflowWorker(service, domain, taskListToPoll); wfw.addWorkflowImplementationType(GreeterWorkflowImpl.class); wfw.start(); } } ``` Tenga en cuenta que `GreeterActivitiesWorker` es simplemente `GreeterWorker` sin el código `WorkflowWorker` y `GreeterWorkflowWorker` es simplemente `GreeterWorker` sin el código `ActivityWorker`. **Para ejecutar el flujo de trabajo:** 1. Cree un archivo JAR ejecutable con `GreeterActivitiesWorker` como punto de entrada. 1. Copie el archivo JAR del Paso 1 en otro sistema, que puede estar ejecutando cualquier sistema operativo que admita Java. 1. Asegúrese de que AWS las credenciales con acceso al mismo dominio de Amazon SWF estén disponibles en el otro sistema. 1. Ejecute el archivo JAR. 1. Utilice Eclipse para ejecutar `GreeterWorkflowWorker` y `GreeterMain` en su sistema de desarrollo. Además del hecho de que las actividades se ejecutan en un sistema diferente al de Workflow Worker y al que inician el flujo de trabajo, el flujo de trabajo funciona exactamente de la misma manera que HelloWorldAsync. Sin embargo, como la llamada `println` que imprime “Hello World\$1” en la consola se encuentra en la actividad `say`, el resultado aparecerá en el sistema que ejecuta el proceso de trabajo de las actividades. # HelloWorldWorkflowParallel Solicitud Las versiones anteriores de Hello World\$1 todas utilizar una topología de flujo de trabajo lineal. No obstante, Amazon SWF no se limita a las topologías lineales. La HelloWorldWorkflowParallel aplicación es una versión modificada HelloWorldWorkflow que utiliza una topología paralela, como se muestra en la siguiente figura. ![\[HelloWorldWorkflowParallel topología del flujo de trabajo\]](http://docs.aws.amazon.com/es_es/amazonswf/latest/awsflowguide/images/helloworld_parallel_topology.png) Con HelloWorldWorkflowParallel, `getName` y `getGreeting` corre en paralelo y cada uno devuelve parte del saludo. `say`luego fusiona las dos cadenas en un saludo y lo imprime en la consola. Para implementar la aplicación, cree una copia de HelloWorld. HelloWorldWorkflow empaquete en el directorio de su proyecto y asígnele el nombre HelloWorld. HelloWorldWorkflowParallel. En las siguientes secciones se describe cómo modificar el HelloWorldWorkflow código original para que se ejecute `getName` y `getGreeting` en paralelo. ## HelloWorldWorkflowParallel Actividades: Trabajador La interfaz de HelloWorldWorkflowParallel actividades está implementada en`GreeterActivities`, como se muestra en el siguiente ejemplo. ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Activities; import com.amazonaws.services.simpleworkflow.flow.annotations.ActivityRegistrationOptions; @Activities(version="5.0") @ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300, defaultTaskStartToCloseTimeoutSeconds = 10) public interface GreeterActivities { public String getName(); public String getGreeting(); public void say(String greeting, String name); } ``` La interfaz es similar a HelloWorldWorkflow, con las siguientes excepciones: + `getGreeting` no toma ninguna entrada; simplemente devuelve una cadena de saludos. + `say` toma dos cadenas de entrada, el saludo y el nombre. + La interfaz tiene un número de versión nuevo, que se necesita siempre que cambia una interfaz registrada. HelloWorldWorkflowParallel implementa las actividades de `GreeterActivitiesImpl` la siguiente manera: ``` public class GreeterActivitiesImpl implements GreeterActivities { @Override public String getName() { return "World!"; } @Override public String getGreeting() { return "Hello "; } @Override public void say(String greeting, String name) { System.out.println(greeting + name); } } ``` `getName` y `getGreeting` ahora simplemente devuelven la mitad de la cadena del saludo. `say` concatena las dos piezas para producir la frase completa y la imprime en la consola. ## HelloWorldWorkflowParallel Workflow Worker La interfaz HelloWorldWorkflowParallel de flujo de trabajo se implementa `GreeterWorkflow` de la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.annotations.Execute; import com.amazonaws.services.simpleworkflow.flow.annotations.Workflow; import com.amazonaws.services.simpleworkflow.flow.annotations.WorkflowRegistrationOptions; @Workflow @WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 3600) public interface GreeterWorkflow { @Execute(version = "5.0") public void greet(); } ``` La clase es idéntica a la HelloWorldWorkflow versión, excepto que el número de versión se ha cambiado para que coincida con la actividad del trabajador. El flujo de trabajo se implementa en `GreeterWorkflowImpl` de la siguiente manera: ``` import com.amazonaws.services.simpleworkflow.flow.core.Promise; public class GreeterWorkflowImpl implements GreeterWorkflow { private GreeterActivitiesClient operations = new GreeterActivitiesClientImpl(); public void greet() { Promise name = operations.getName(); Promise greeting = operations.getGreeting(); operations.say(greeting, name); } } ``` A simple vista, esta implementación es muy similar a HelloWorldWorkflow las tres actividades que los métodos del cliente ejecutan en secuencia. No obstante, no es así para las actividades. + HelloWorldWorkflow pasado `name` a`getGreeting`. Dado que `name` era un objeto `Promise`, `getGreeting` aplazó la ejecución de la actividad hasta que se completó `getName`, por lo que las dos actividades se ejecutaron en secuencia. + HelloWorldWorkflowParallel no pasa ninguna entrada `getName` o`getGreeting`. Ninguno de los métodos difiere la ejecución y los métodos de actividad asociados se ejecutan inmediatamente y en paralelo. La actividad `say` toma `greeting` y `name` como parámetros de entrada. Dado que se trata de objetos `Promise`, `say` difiere la ejecución hasta que se completan ambas actividades y, a continuación, construye e imprime el saludo. Observe que HelloWorldWorkflowParallel no utiliza ningún código de modelado especial para definir la topología del flujo de trabajo. Lo hace de forma implícita mediante el uso del control de flujo estándar de Java y aprovechando las propiedades de `Promise` los objetos. AWS Flow Framework ya que las aplicaciones de Java pueden implementar incluso topologías complejas simplemente utilizando `Promise` objetos junto con las construcciones de flujo de control de Java convencionales. ## HelloWorldWorkflowParallel Flujo de trabajo y actividades: anfitrión e iniciador HelloWorldWorkflowParallel implementa `GreeterWorker` como clase anfitriona para las implementaciones de flujos de trabajo y actividades. Es idéntica a la HelloWorldWorkflow implementación excepto por el `taskListToPoll` nombre, que se establece en "HelloWorldParallelList». `HelloWorldWorkflowParallel`implementa el flujo de trabajo inicial en `GreeterMain` y es idéntico a la HelloWorldWorkflow implementación. Para ejecutar el flujo de trabajo, ejecute `GreeterWorker` y `GreeterMain`, de la misma manera que con `HelloWorldWorkflow`.