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. # 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.