Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Memulai dengan AWS Flow Framework for Java Bagian ini memperkenalkan AWS Flow Framework dengan memandu Anda melalui serangkaian contoh aplikasi sederhana yang memperkenalkan model pemrograman dasar dan API. Contoh aplikasi didasarkan pada aplikasi Hello World standar yang digunakan untuk memperkenalkan C dan bahasa pemrograman terkait. Berikut ini adalah implementasi khas Java Hello World: ``` public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } } ``` Berikut ini adalah deskripsi singkat dari contoh aplikasi. Mereka termasuk kode sumber lengkap sehingga Anda dapat menerapkan dan menjalankan aplikasi sendiri. Sebelum memulai, Anda harus terlebih dahulu mengkonfigurasi lingkungan pengembangan Anda dan membuat proyek AWS Flow Framework untuk Java, seperti di[Menyiapkan AWS Flow Framework untuk Java](setup.md). + [HelloWorld Aplikasi](getting-started-example-helloworld.md) memperkenalkan aplikasi alur kerja dengan menerapkan Hello World sebagai aplikasi Java standar, tetapi menyusunnya seperti aplikasi alur kerja. + [HelloWorldWorkflow Aplikasi](getting-started-example-helloworldworkflow.md)menggunakan AWS Flow Framework for Java untuk dikonversi HelloWorld menjadi alur kerja Amazon SWF. + [HelloWorldWorkflowAsync Aplikasi](getting-started-example-helloworldworkflowasync.md) memodifikasi `HelloWorldWorkflow` untuk menggunakan metode *alur kerja asinkron*. + [HelloWorldWorkflowDistributed Aplikasi](getting-started-example-helloworldworkflowdistributed.md) memodifikasi `HelloWorldWorkflowAsync` sehingga pekerja alur kerja dan aktivitas dapat berjalan pada sistem yang terpisah. + [HelloWorldWorkflowParallel Aplikasi](getting-started-example-helloworldworkflowparallel.md) memodifikasi `HelloWorldWorkflow` untuk menjalankan dua aktivitas secara paralel. # Menyiapkan AWS Flow Framework untuk Java The AWS Flow Framework for Java disertakan dengan file [AWS SDK untuk Java](https://aws.amazon.com/sdkforjava/). Jika Anda belum menyiapkan AWS SDK untuk Java, kunjungi [Memulai](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) di Panduan AWS SDK untuk Java Pengembang untuk informasi tentang menginstal dan mengonfigurasi SDK itu sendiri. ## Tambahkan kerangka alur dengan Maven Alat pembuatan Amazon SWF adalah sumber terbuka—untuk melihat atau mengunduh kode atau membuat alat sendiri, kunjungi repositori di. [https://github.com/aws/aws-swf-build-tools](https://github.com/aws/aws-swf-build-tools) Amazon menyediakan [alat build Amazon SWF](https://mvnrepository.com/artifact/com.amazonaws/aws-swf-build-tools) di Repositori Pusat Maven. Untuk menyiapkan kerangka alur untuk Maven, tambahkan ketergantungan berikut ke file `pom.xml` proyek Anda: ``` com.amazonaws aws-swf-build-tools 2.0.0 ``` # HelloWorld Aplikasi Untuk memperkenalkan cara aplikasi Amazon SWF terstruktur, kita akan membuat aplikasi Java yang berperilaku seperti alur kerja, tapi itu berjalan secara lokal dalam satu proses. Tidak ada koneksi ke Amazon Web Services yang akan diperlukan. **catatan** [HelloWorldWorkflow](getting-started-example-helloworldworkflow.md)Contoh dibangun di atas yang satu ini, menghubungkan ke Amazon SWF untuk menangani pengelolaan alur kerja. Sebuah aplikasi alur kerja terdiri dari tiga komponen dasar: + *Aktivitas pekerja* mendukung satu set *aktivitas*, yang masing-masing merupakan metode yang mengeksekusi secara independen untuk melakukan tugas tertentu. + *pekerja alur kerja* mengatur pelaksanaan aktivitas dan mengelola aliran data. Ini adalah realisasi program dari *topologi alur kerja*, yang pada dasarnya adalah bagan alur yang mendefinisikan ketika berbagai aktivitas mengeksekusi, apakah mereka mengeksekusi secara berurutan atau bersamaan, dan sebagainya. + *starter alur kerja* memulai instans alur kerja, yang disebut *eksekusi*, dan dapat berinteraksi dengannya selama eksekusi. HelloWorld diimplementasikan sebagai tiga kelas dan dua antarmuka terkait, yang dijelaskan di bagian berikut. Sebelum memulai, Anda harus mengatur lingkungan pengembangan Anda dan membuat proyek AWS Java baru seperti yang dijelaskan dalam[Menyiapkan AWS Flow Framework untuk Java](setup.md). Paket yang digunakan untuk panduan berikut semua bernama `helloWorld.XYZ`. Untuk menggunakan nama-nama tersebut, atur atribut `within` di aop.xml sebagai berikut: ``` ... ``` Untuk mengimplementasikannya HelloWorld, buat paket Java baru di proyek AWS SDK Anda bernama `helloWorld.HelloWorld` dan tambahkan file berikut: + Sebuah file antarmuka bernama `GreeterActivities.java` + Sebuah file kelas bernama `GreeterActivitiesImpl.java`, yang mengimplementasikan pekerja aktivitas. + Sebuah file antarmuka bernama `GreeterWorkflow.java`. + Sebuah file kelas bernama `GreeterWorkflowImpl.java`, yang mengimplementasikan pekerja alur kerja. + Sebuah file kelas bernama `GreeterMain.java`, yang menerapkan starter alur kerja. Detail dibahas dalam bagian berikut dan termasuk kode lengkap untuk setiap komponen, yang dapat Anda tambahkan ke file yang sesuai. ## HelloWorld Implementasi Kegiatan HelloWorld memecah keseluruhan tugas mencetak `"Hello World!"` salam ke konsol menjadi tiga tugas, yang masing-masing dilakukan dengan *metode aktivitas*. Metode aktivitas didefinisikan dalam antarmuka `GreeterActivities`, sebagai berikut. ``` public interface GreeterActivities { public String getName(); public String getGreeting(String name); public void say(String what); } ``` HelloWorld memiliki satu implementasi aktivitas`GreeterActivitiesImpl`, yang menyediakan `GreeterActivities` metode seperti yang ditunjukkan: ``` 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); } } ``` Kegiatan independen satu sama lain dan sering dapat digunakan oleh alur kerja yang berbeda. Sebagai contoh, setiap alur kerja dapat menggunakan `say` aktivitas untuk mencetak string ke konsol tersebut. Alur kerja juga dapat memiliki beberapa implementasi aktivitas, masing-masing melakukan serangkaian tugas yang berbeda. ## HelloWorld Pekerja Alur Kerja Untuk mencetak “Hello World\$1” ke konsol tersebut, tugas aktivitas harus dijalankan secara berurutan di urutan yang benar dengan data yang benar. Pekerja HelloWorld alur kerja mengatur eksekusi aktivitas berdasarkan *topologi alur kerja linier* sederhana, yang ditunjukkan pada gambar berikut. ![\[Topologi alur kerja linier\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/helloworld_topology.png) Tiga aktivitas mengeksekusi secara berurutan, dan data mengalir dari satu aktivitas ke aktivitas berikutnya. Pekerja HelloWorld alur kerja memiliki metode tunggal, titik masuk alur kerja, yang didefinisikan dalam `GreeterWorkflow` antarmuka, sebagai berikut: ``` public interface GreeterWorkflow { public void greet(); } ``` Kelas `GreeterWorkflowImpl` mengimplementasikan antarmuka ini, sebagai berikut: ``` 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); } } ``` `greet`Metode ini mengimplementasikan HelloWorld topologi dengan membuat instance dari`GreeterActivitiesImpl`, memanggil setiap metode aktivitas dalam urutan yang benar, dan meneruskan data yang sesuai ke setiap metode. ## HelloWorld Alur Kerja Starter *starter alur kerja* adalah aplikasi yang memulai eksekusi alur kerja, dan mungkin juga berkomunikasi dengan alur kerja saat mengeksekusi. `GreeterMain`Kelas mengimplementasikan HelloWorld alur kerja starter, sebagai berikut: ``` public class GreeterMain { public static void main(String[] args) { GreeterWorkflow greeter = new GreeterWorkflowImpl(); greeter.greet(); } } ``` `GreeterMain` menciptakan sebuah instans dari `GreeterWorkflowImpl` dan panggilan `greet` untuk menjalankan pekerja alur kerja. Jalankan `GreeterMain` sebagai aplikasi Java dan Anda akan melihat “Hello World\$1” dalam output konsol tersebut. # HelloWorldWorkflow Aplikasi Meskipun [HelloWorld](getting-started-example-helloworld.md)contoh dasarnya terstruktur seperti alur kerja, ini berbeda dari alur kerja Amazon SWF dalam beberapa hal utama: **Aplikasi Alur Kerja konvensional dan Amazon SWF** | HelloWorld | Alur Kerja Amazon SWF | | --- | --- | | Jalankan secara lokal sebagai proses tunggal. | Berjalan sebagai beberapa proses yang dapat didistribusikan di beberapa sistem, termasuk EC2 instans Amazon, pusat data pribadi, komputer klien, dan sebagainya. Mereka bahkan tidak perlu menjalankan sistem operasi yang sama. | | Aktivitas adalah metode sinkron, yang memblok sampai mereka selesai. | Aktivitas diwakili oleh metode asinkron, yang kembali segera dan mengizinkan alur kerja untuk melakukan tugas-tugas lain sambil menunggu untuk aktivitas selesai. | | Pekerja alur kerja berinteraksi dengan pekerja aktivitas dengan memanggil metode yang sesuai. | pekerja alur kerja berinteraksi dengan pekerja aktivitas dengan menggunakan permintaan HTTP, dengan Amazon SWF bertindak sebagai perantara. | | Alur kerja starter berinteraksi dengan pekerja alur kerja dengan memanggil metode yang sesuai. | Alur kerja starter berinteraksi dengan pekerja alur kerja dengan menggunakan permintaan HTTP, dengan Amazon SWF bertindak sebagai perantara. | Anda dapat menerapkan aplikasi alur kerja asinkron terdistribusi dari scratch, misalnya, dengan meminta pekerja alur kerja Anda berinteraksi dengan pekerja aktivitas secara langsung melalui panggilan layanan web. Namun, Anda kemudian harus menerapkan semua kode rumit yang diperlukan untuk mengelola eksekusi asinkron beberapa aktivitas, menangani aliran data, dan sebagainya. AWS Flow Framework Untuk Java dan Amazon SWF mengurus semua detail itu, yang memungkinkan Anda untuk fokus pada penerapan logika bisnis. HelloWorldWorkflow adalah versi modifikasi HelloWorld yang berjalan sebagai alur kerja Amazon SWF. Gambar berikut merangkum bagaimana dua aplikasi bekerja. ![\[Versi konvensional dan Amazon SWF dari Hello World!\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/workflow_conceptual_welcome.png) HelloWorld berjalan sebagai proses tunggal dan starter, pekerja alur kerja, dan pekerja aktivitas berinteraksi dengan menggunakan panggilan metode konvensional. Dengan `HelloWorldWorkflow`, starter, pekerja alur kerja, dan pekerja aktivitas mendistribusikan komponen yang berinteraksi melalui Amazon SWF dengan menggunakan permintaan HTTP. Amazon SWF mengelola interaksi dengan mempertahankan daftar alur kerja dan tugas aktivitas, yang dikirim ke komponen masing-masing. Bagian ini menjelaskan cara kerja kerangka kerja HelloWorldWorkflow. HelloWorldWorkflow diimplementasikan dengan menggunakan AWS Flow Framework for Java API, yang menangani detail terkadang rumit berinteraksi dengan Amazon SWF di latar belakang dan menyederhanakan proses pengembangan secara signifikan. Anda dapat menggunakan proyek yang sama dengan yang Anda lakukan HelloWorld, yang sudah dikonfigurasi AWS Flow Framework untuk aplikasi Java. Namun, untuk menjalankan aplikasi, Anda harus membuat akun Amazon SWF, sebagai berikut: + Mendaftar untuk AWS akun, jika Anda belum memilikinya, di [Amazon Web Services](https://aws.amazon.com/). + Tetapkan ID Akses dan ID rahasia akun Anda ke variabel AWS\$1ACCESS\$1KEY\$1ID dan AWS\$1SECRET\$1KEY lingkungan, masing-masing. Ini adalah praktik yang baik untuk tidak mengekspos nilai-nilai kunci literal dalam kode Anda. Menyimpannya dalam variabel lingkungan adalah cara yang mudah untuk menangani masalah ini. + Mendaftar untuk akun Amazon SWF di [Amazon Simple Workflow Service](https://aws.amazon.com/swf/). + Masuk ke Konsol Manajemen AWS dan pilih layanan Amazon SWF. + Pilih **Manage Domains** (Mengelola Domain) di pojok kanan atas dan daftarkan domain Amazon SWF baru. *domain* adalah kontainer logis untuk sumber daya aplikasi Anda, seperti alur kerja dan aktivitas jenis, dan eksekusi alur kerja. Anda dapat menggunakan nama domain yang nyaman, tetapi penelusurannya menggunakan "”. helloWorldWalkthrough Untuk mengimplementasikan HelloWorldWorkflow, buat salinan HelloWorld. HelloWorld paket di direktori proyek Anda dan beri nama HelloWorld. HelloWorldWorkflow. Bagian berikut menjelaskan cara memodifikasi HelloWorld kode asli untuk menggunakan AWS Flow Framework untuk Java dan dijalankan sebagai aplikasi alur kerja Amazon SWF. ## HelloWorldWorkflow Aktivitas Pekerja HelloWorld melaksanakan aktivitasnya pekerja sebagai satu kelas. Pekerja AWS Flow Framework untuk aktivitas Java memiliki tiga komponen dasar: + *Metode aktivitas*—yang melakukan tugas yang sebenarnya — didefinisikan dalam sebuah antarmuka dan diimplementasikan dalam kelas terkait. + [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)Kelas mengelola interaksi antara metode aktivitas dan Amazon SWF. + Aplikasi *host aktivitas* mendaftar dan memulai pekerja aktivitas, dan menangani pembersihan. Bagian ini membahas metode aktivitas; dua kelas lainnya dibahas kemudian. HelloWorldWorkflow mendefinisikan antarmuka aktivitas di`GreeterActivities`, sebagai berikut: ``` 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); } ``` Antarmuka ini tidak sepenuhnya diperlukan untuk HelloWorld, tetapi AWS Flow Framework untuk aplikasi Java. Perhatikan bahwa definisi antarmuka itu sendiri tidak berubah. Namun, Anda harus menerapkan dua AWS Flow Framework untuk anotasi Java, [@ActivityRegistrationOptions](annotations.md#annotations-activityregistration) dan[@Activities](annotations.md#annotations-activities), ke definisi antarmuka. Anotasi menyediakan informasi konfigurasi dan mengarahkan prosesor anotasi Java AWS Flow Framework untuk menggunakan definisi antarmuka untuk menghasilkan kelas *klien aktivitas*, yang akan dibahas nanti. `@ActivityRegistrationOptions`memiliki beberapa nilai bernama yang digunakan untuk mengkonfigurasi perilaku aktivitas. HelloWorldWorkflow menentukan dua batas waktu: + `defaultTaskScheduleToStartTimeoutSeconds` menentukan berapa lama tugas dapat antrean dalam daftar tugas aktivitas, dan diatur ke 300 detik (5 menit). + `defaultTaskStartToCloseTimeoutSeconds` menentukan waktu maksimum aktivitas dapat mengambil untuk melakukan tugas dan diatur ke 10 detik. Batas waktu ini memastikan bahwa aktivitas menyelesaikan tugasnya dalam jumlah waktu yang wajar. Jika batas waktu terlampaui, kerangka kerja menghasilkan kesalahan dan pekerja alur kerja harus memutuskan bagaimana menangani masalah. Untuk diskusi tentang cara menangani kesalahan tersebut, lihat [Penanganan Kesalahan](errorhandling.md). `@Activities` memiliki beberapa nilai, tetapi biasanya hanya menentukan nomor versi aktivitas, yang mengizinkan Anda untuk melacak generasi yang berbeda dari implementasi aktivitas. Jika Anda mengubah antarmuka aktivitas setelah Anda mendaftarkannya dengan Amazon SWF, termasuk mengubah nilai-nilai `@ActivityRegistrationOptions`, Anda harus menggunakan nomor versi baru. HelloWorldWorkflow mengimplementasikan metode aktivitas di`GreeterActivitiesImpl`, sebagai berikut: ``` 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); } } ``` Perhatikan bahwa kode identik dengan HelloWorld implementasi. Pada intinya, AWS Flow Framework aktivitas hanyalah metode yang mengeksekusi beberapa kode dan mungkin mengembalikan hasilnya. Perbedaan antara aplikasi standar dan aplikasi alur kerja Amazon SWF terletak pada bagaimana alur kerja mengeksekusi aktivitas, di mana aktivitas mengeksekusi, dan bagaimana hasilnya dikembalikan ke pekerja alur kerja. ## HelloWorldWorkflow Pekerja Alur Kerja Seorang pekerja alur kerja Amazon SWF memiliki tiga komponen dasar. + *implementasi alur kerja*, yang merupakan kelas yang melakukan tugas-tugas yang berhubungan dengan alur kerja. + Kelas *Aktivitas klien*, yang pada dasarnya sebuah proksi untuk kelas aktivitas dan digunakan oleh implementasi alur kerja untuk mengeksekusi metode aktivitas secara asinkron. + [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html)Kelas, yang mengelola interaksi antara alur kerja dan Amazon SWF. Bagian ini membahas implementasi alur kerja dan aktivitas klien; kelas `WorkflowWorker` dibahas nanti. HelloWorldWorkflow mendefinisikan antarmuka alur kerja di`GreeterWorkflow`, sebagai berikut: ``` 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(); } ``` Antarmuka ini juga tidak sepenuhnya diperlukan untuk HelloWorld tetapi sangat penting untuk aplikasi AWS Flow Framework untuk Java. Anda harus menerapkan dua AWS Flow Framework untuk anotasi Java, [@Workflow](annotations.md#annotations-workflow) dan[@WorkflowRegistrationOptions](annotations.md#annotations-workflowregistrationoptions), ke definisi antarmuka alur kerja. Anotasi menyediakan informasi konfigurasi dan juga mengarahkan prosesor anotasi AWS Flow Framework untuk Java untuk menghasilkan kelas klien alur kerja berdasarkan antarmuka, seperti yang dibahas nanti. `@Workflow`memiliki satu parameter opsional, *DataConverter*, yang sering digunakan dengan nilai default, NullDataConverter, yang menunjukkan bahwa harus digunakan. JsonDataConverter `@WorkflowRegistrationOptions` juga memiliki sejumlah parameter opsional yang dapat digunakan untuk mengkonfigurasi pekerja alur kerja. Di sini, kita mengatur `defaultExecutionStartToCloseTimeoutSeconds`—yang menentukan berapa lama alur kerja dapat menjalankan—hingga 3600 detik (1 jam). Definisi `GreeterWorkflow` antarmuka berbeda dari HelloWorld dalam satu cara penting, [@Execute](annotations.md#annotations-execute) anotasi. Antarmuka alur kerja menentukan metode yang dapat disebut oleh aplikasi seperti alur kerja starter dan terbatas pada beberapa metode, masing-masing dengan peran tertentu. Kerangka kerja tidak menentukan nama atau daftar parameter untuk metode antarmuka alur kerja; Anda menggunakan nama dan daftar parameter yang cocok untuk alur kerja Anda dan menerapkan AWS Flow Framework untuk penjelasan Java untuk mengidentifikasi peran metode ini. `@Execute` memiliki dua tujuan: + Ini mengidentifikasi `greet` sebagai titik masuk alur kerja—metode yang digunakan starter alur kerja untuk memulai alur kerja. Secara umum, titik masuk dapat mengambil satu atau lebih parameter, yang memungkinkan starter menginisialisasi alur kerja, tetapi contoh ini tidak memerlukan inisialisasi. + Ini menentukan nomor versi alur kerja, yang mengizinkan Anda untuk melacak generasi yang berbeda dari implementasi alur kerja. Untuk mengubah antarmuka alur kerja setelah Anda mendaftarkannya dengan Amazon SWF, termasuk mengubah nilai batas waktu, Anda harus menggunakan nomor versi baru. Untuk informasi tentang metode lainnya yang dapat disertakan dalam antarmuka alur kerja, lihat [Alur Kerja dan Kontrak Aktivitas](features.workflow.md). HelloWorldWorkflow mengimplementasikan alur kerja di`GreeterWorkflowImpl`, sebagai berikut: ``` 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); } } ``` Kode ini mirip dengan HelloWorld, tetapi dengan dua perbedaan penting. + `GreeterWorkflowImpl` menciptakan sebuah instans dari `GreeterActivitiesClientImpl`, klien aktivitas, bukan `GreeterActivitiesImpl`, dan mengeksekusi aktivitas dengan memanggil metode pada objek klien. + Nama dan ucapan aktivitas mengembalikan objek `Promise` daripada objek `String`. HelloWorld adalah aplikasi Java standar yang berjalan secara lokal sebagai satu proses, sehingga `GreeterWorkflowImpl` dapat mengimplementasikan topologi alur kerja hanya dengan membuat instance`GreeterActivitiesImpl`, memanggil metode secara berurutan, dan meneruskan nilai pengembalian dari satu aktivitas ke aktivitas berikutnya. Dengan alur kerja Amazon SWF, tugas aktivitas masih dilakukan dengan metode aktivitas dari `GreeterActivitiesImpl`. Namun, metode ini tidak selalu berjalan dalam proses yang sama seperti alur kerja—bahkan mungkin tidak berjalan pada sistem yang sama—dan alur kerja perlu menjalankan aktivitas asinkron. Persyaratan ini meningkatkan masalah berikut: + Bagaimana menjalankan metode aktivitas yang mungkin berjalan dalam proses yang berbeda, mungkin pada sistem yang berbeda. + Bagaimana menjalankan metode aktivitas secara asinkron. + Bagaimana mengelola nilai-nilai masukan dan mengembalikan aktivitas. Misalnya, jika nilai mengembalikan Aktivitas A adalah masukan untuk Aktivitas B, Anda harus memastikan bahwa Aktivitas B tidak mengeksekusi sampai Aktivitas A selesai. Anda dapat menerapkan berbagai topologi alur kerja melalui aliran kontrol aplikasi dengan menggunakan familiar kontrol aliran Java dikombinasikan dengan aktivitas klien dan `Promise`. ### Aktivitas Klien `GreeterActivitiesClientImpl` pada dasarnya adalah proksi untuk `GreeterActivitiesImpl` yang mengizinkan penerapan alur kerja untuk menjalankan metode `GreeterActivitiesImpl` asinkron. Kelas `GreeterActivitiesClient` dan `GreeterActivitiesClientImpl` dibuat secara otomatis untuk Anda menggunakan informasi yang diberikan dalam anotasi yang diterapkan ke `GreeterActivities` kelas Anda. Anda tidak perlu menerapkan ini sendiri. **catatan** Eclipse menghasilkan kelas-kelas ini ketika Anda menyimpan proyek Anda. Anda dapat melihat kode yang dihasilkan di subdirektori `.apt_generated` dari direktori proyek Anda. Untuk menghindari kesalahan kompilasi di kelas `GreeterWorkflowImpl` Anda, itu adalah praktik yang baik untuk memindahkan direktori `.apt_generated` ke atas tab **Order and Export** (Pesan dan Ekspor) dari kotak dialog **Java Build Path** (Jalur Membangun Java). Seorang pekerja alur kerja mengeksekusi aktivitas dengan memanggil metode klien yang sesuai. Metode asinkron dan segera mengembalikan objek `Promise`, tempat `T` adalah jenis kembali aktivitas. Objek `Promise` kembali pada dasarnya adalah sebuah tempat untuk nilai bahwa metode aktivitas akhirnya akan kembali. + Ketika metode klien kegiatan kembali, objek `Promise` awalnya dalam sebuah *kondisi tidak siap*, yang menunjukkan bahwa objek belum mewakili nilai kembali valid. + Ketika metode aktivitas yang sesuai menyelesaikan tugas dan kembali, kerangka kerja memberikan nilai kembali ke objek `Promise` dan menempatkan dalam *status siap*. ### Jenis Janji Tujuan utama dari objek `Promise` adalah untuk mengelola aliran data antara komponen asinkron dan mengontrol ketika mereka mengeksekusi. Ini mengurangi aplikasi Anda dari kebutuhan untuk secara eksplisit mengelola sinkronisasi atau bergantung pada mekanisme seperti timer untuk memastikan bahwa komponen asinkron tidak menjalankan prematur. Ketika Anda memanggil metode aktivitas klien, segera kembali tetapi menunda kerangka kerja mengeksekusi metode aktivitas yang sesuai sampai masukan objek `Promise` siap dan mewakili data yang valid. Dari perspektif `GreeterWorkflowImpl`, semua tiga aktivitas metode klien kembali segera. Dari perspektif `GreeterActivitiesImpl`, kerangka kerja tidak memanggil `getGreeting` sampai `name` selesai, dan tidak memanggil `say` sampai `getGreeting` selesai. Dengan menggunakan `Promise` untuk melewatkan data dari satu aktivitas ke kegiatan berikutnya, `HelloWorldWorkflow` tidak hanya memastikan bahwa metode aktivitas tidak mencoba untuk menggunakan data yang tidak valid, itu juga mengontrol ketika kegiatan mengeksekusi dan secara implisit mendefinisikan topologi alur kerja. Melewati setiap `Promise` aktivitas nilai kembali ke aktivitas berikutnya membutuhkan aktivitas untuk mengeksekusi secara berurutan, mendefinisikan topologi linear dibahas sebelumnya. Dengan AWS Flow Framework untuk Java, Anda tidak perlu menggunakan kode pemodelan khusus untuk mendefinisikan topologi yang kompleks, hanya kontrol aliran Java standar dan. `Promise` Untuk contoh bagaimana menerapkan topologi paralel sederhana, lihat [HelloWorldWorkflowParallel Aktivitas Pekerja](getting-started-example-helloworldworkflowparallel.md#getting-started-example-helloworldworkflowparallel.activities). **catatan** Ketika metode aktivitas seperti `say` tidak mengembalikan nilai, metode klien yang sesuai mengembalikan objek `Promise`. Objek tidak mewakili data, tetapi awalnya tidak siap dan menjadi siap ketika aktivitas selesai. Oleh karena itu Anda dapat melewati objek `Promise` ke aktivitas lain metode klien untuk memastikan bahwa mereka menunda eksekusi sampai aktivitas asli selesai. `Promise` mengizinkan implementasi alur kerja untuk menggunakan metode klien aktivitas dan nilai-nilai kembali mereka seperti metode sinkron. Namun, Anda harus berhati-hati dalam mengakses `Promise` nilai objek. Berbeda dengan jenis Java [Future ](http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html), kerangka kerja menangani sinkronisasi untuk `Promise`, bukan aplikasi. Jika Anda memanggil `Promise.get` dan objeknya belum siap, `get` melempar pengecualian. Perhatikan bahwa `HelloWorldWorkflow` tidak pernah mengakses objek `Promise` secara langsung; itu hanya melewati objek dari satu aktivitas ke aktivitas berikutnya. Ketika sebuah objek menjadi siap, kerangka kerja ekstrak nilai dan lolos ke metode aktivitas sebagai tipe standar. objek `Promise` harus diakses hanya dengan kode asinkron, di mana kerangka kerja menjamin bahwa objek siap dan mewakili nilai yang valid. `HelloWorldWorkflow` berkaitan dengan masalah ini dengan melewati objek `Promise` untuk metode aktivitas klien. Anda dapat mengakses `Promise` nilai objek dalam implementasi alur kerja Anda dengan melewatkan objek ke *asynchronous workflow method* (metode alur kerja asinkron), yang berperilaku seperti aktivitas. Sebagai contoh, lihat [HelloWorldWorkflowAsync Aplikasi](getting-started-example-helloworldworkflowasync.md). ## HelloWorldWorkflow Alur Kerja dan Implementasi Aktivitas Alur kerja dan implementasi aktivitas memiliki kelas pekerja terkait, [ActivityWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/ActivityWorker.html)dan. [WorkflowWorker](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowWorker.html) Mereka menangani komunikasi antara Amazon SWF dan aktivitas dan implementasi alur kerja dengan polling daftar tugas Amazon SWF yang sesuai untuk tugas, mengeksekusi metode yang tepat untuk setiap tugas, dan mengelola aliran data. Untuk detail selengkapnya, lihat [AWS Flow Framework Konsep Dasar: Struktur Aplikasi](awsflow-basics-application-structure.md) Untuk mengaitkan implementasi aktivitas dan alur kerja dengan objek pekerja yang sesuai, Anda menerapkan satu atau lebih aplikasi pekerja yang: + Mendaftar alur kerja atau aktivitas dengan Amazon SWF. + Membuat objek pekerja dan mengasosiasikan mereka dengan alur kerja atau aktivitas implementasi pekerja. + Mengarahkan objek pekerja untuk mulai berkomunikasi dengan Amazon SWF. Jika Anda ingin menjalankan alur kerja dan aktivitas sebagai proses terpisah, Anda harus menerapkan alur kerja dan aktivitas yang terpisah host pekerja. Sebagai contoh, lihat [HelloWorldWorkflowDistributed Aplikasi](getting-started-example-helloworldworkflowdistributed.md). Untuk mempermudah, HelloWorldWorkflow mengimplementasikan host pekerja tunggal yang menjalankan aktivitas dan alur kerja pekerja dalam proses yang sama, sebagai berikut: ``` 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`tidak memiliki HelloWorld mitra, jadi Anda harus menambahkan kelas Java bernama `GreeterWorker` ke proyek dan menyalin kode contoh ke file itu. Langkah pertama adalah membuat dan mengonfigurasi [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objek, yang memanggil metode layanan Amazon SWF yang mendasarinya. Untuk melakukannya, `GreeterWorker`: 1. Membuat [ClientConfiguration](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/ClientConfiguration.html)objek dan menentukan batas waktu soket 70 detik. Nilai ini menentukan lama untuk menunggu data yang akan ditransfer melalui koneksi terbuka didirikan sebelum menutup soket. 1. Membuat AWSCredentials objek [Basic](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/BasicAWSCredentials.html) untuk mengidentifikasi AWS akun dan meneruskan kunci akun ke konstruktor. Untuk kenyamanan, dan untuk menghindari mengekspos mereka sebagai teks biasa dalam kode, kunci disimpan sebagai variabel lingkungan. 1. Menciptakan [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objek untuk mewakili alur kerja, dan meneruskan `ClientConfiguration` objek `BasicAWSCredentials` dan ke konstruktor. 1. Menetapkan URL titik akhir layanan objek klien. Amazon SWF saat ini tersedia di semua AWS wilayah. Untuk kenyamanan, `GreeterWorker` mendefinisikan dua konstanta string. + `domain`adalah nama domain Amazon SWF alur kerja, yang Anda buat saat menyiapkan akun Amazon SWF Anda. `HelloWorldWorkflow`mengasumsikan bahwa Anda menjalankan alur kerja di domain helloWorldWalkthrough "”. + `taskListToPoll` adalah nama daftar tugas yang digunakan Amazon SWF untuk mengelola komunikasi antara alur kerja dan aktivitas pekerja. Anda dapat mengatur nama ke string yang nyaman. HelloWorldWorkflow menggunakan "HelloWorldList" untuk alur kerja dan daftar tugas aktivitas. Di belakang layar, nama-nama berakhir di namespace yang berbeda, sehingga dua daftar tugas yang berbeda. `GreeterWorker`menggunakan konstanta string dan [AmazonSimpleWorkflowClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/AmazonSimpleWorkflowClient.html)objek untuk membuat objek pekerja, yang mengelola interaksi antara aktivitas dan implementasi pekerja dan Amazon SWF. Khususnya, objek pekerja menangani tugas mengundi daftar tugas yang sesuai untuk tugas. objek `GreeterWorker` membuat `ActivityWorker` dan mengkonfigurasinya untuk menangani `GreeterActivitiesImpl` dengan menambahkan instans kelas baru. `GreeterWorker` kemudian memanggil objek `ActivityWorker` metode `start`, yang mengarahkan objek untuk memulai mengundi daftar tugas aktivitas tertentu. Objek `GreeterWorker` membuat `WorkflowWorker` dan mengkonfigurasinya untuk menangani `GreeterWorkflowImpl` dengan menambahkan nama file kelas, `GreeterWorkflowImpl.class`. Kemudian memanggil `WorkflowWorker` metode `start` objek, yang mengarahkan objek untuk memulai polling daftar tugas alur kerja yang ditentukan. Anda dapat menjalankan `GreeterWorker` dengan berhasil pada saat ini. Ini register alur kerja dan aktivitas dengan Amazon SWF dan mulai objek pekerja polling daftar tugas masing-masing. Untuk memverifikasi ini, jalankan `GreeterWorker` dan pergi ke konsol Amazon SWF dan pilih `helloWorldWalkthrough` dari daftar domain. Jika Anda memilih **Workflow Types** (Jenis Alur Kerja) di panel **Navigation** (Navigasi), Anda akan melihat `GreeterWorkflow.greet`: ![\[HelloWorldWorkflow jenis alur kerja\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/Workflow_Type.png) Jika Anda memilih **Activity Types** (Tipe Aktivitas), metode `GreeterActivities` ditampilkan: ![\[HelloWorldWorkflow jenis kegiatan\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/Activity_Types.png) Namun, jika Anda memilih **Workflow Executions** (Eksekusi Alur kerja), Anda tidak akan melihat eksekusi aktif. Meskipun alur kerja dan aktivitas pekerja membuat polling untuk tugas, kami belum memulai eksekusi alur kerja. ## HelloWorldWorkflow Pemula Bagian akhir dari teka-teki ini adalah untuk menerapkan starter alur kerja, merupakan aplikasi yang memulai eksekusi alur kerja. Status eksekusi disimpan oleh Amazon SWF, sehingga Anda dapat melihat riwayat dan status eksekusi. HelloWorldWorkflow mengimplementasikan alur kerja starter dengan memodifikasi `GreeterMain` kelas, sebagai berikut: ``` 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(); } } ``` Objek `GreeterMain` membuat `AmazonSimpleWorkflowClient` dengan menggunakan kode yang sama seperti `GreeterWorker`. Objek kemudian menciptakan objek `GreeterWorkflowClientExternal`, yang bertindak sebagai proksi untuk alur kerja dalam banyak cara yang sama bahwa klien kegiatan dibuat di `GreeterWorkflowClientImpl` bertindak sebagai proksi untuk metode aktivitas. Daripada membuat objek klien alur kerja dengan menggunakan `new`, Anda harus: 1. Membuat objek pabrik klien eksternal dan meneruskan objek `AmazonSimpleWorkflowClient` dan Amazon SWF nama domain untuk konstruktor. Objek pabrik klien dibuat oleh prosesor anotasi kerangka kerja, yang menciptakan nama objek hanya dengan menambahkan "ClientExternalFactoryImpl" ke nama antarmuka alur kerja. 1. Buat objek klien eksternal dengan memanggil `getClient` metode objek pabrik, yang menciptakan nama objek dengan menambahkan "ClientExternal" ke nama antarmuka alur kerja. Anda dapat secara opsional meneruskan `getClient` string yang Amazon SWF akan digunakan untuk mengidentifikasi instans ini dari alur kerja. Jika tidak, Amazon SWF merupakan instans alur kerja dengan menggunakan GUID yang dihasilkan. Klien kembali dari pabrik hanya akan membuat alur kerja yang diberi nama dengan string yang diteruskan ke metode [getClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/simpleworkflow/flow/WorkflowClientFactoryExternal.html#getClient(java.lang.String)), (klien yang dikembali dari pabrik sudah memiliki status di Amazon SWF). Untuk menjalankan alur kerja dengan id yang berbeda, Anda perlu kembali ke pabrik dan membuat klien baru dengan id yang berbeda telah ditentukan. Alur kerja klien mengekspos metode `greet` yang `GreeterMain` memanggil untuk memulai alur kerja, sebagai `greet()` adalah metode yang ditentukan dengan anotasi `@Execute`. **catatan** Prosesor anotasi juga menciptakan objek pabrik klien internal yang digunakan untuk membuat alur kerja anak. Untuk detail selengkapnya, lihat [Eksekusi Alur Kerja Anak](childworkflow.md). Matikan `GreeterWorker` untuk saat ini jika masih berjalan, dan jalankan `GreeterMain`. Anda sekarang harus melihat someID pada daftar Amazon SWF konsol eksekusi alur kerja aktif:. ![\[HelloWorldWorkflow eksekusi alur kerja\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/Active_Execution.png) Jika Anda memilih `someID` dan pilih tab **Events** (Peristiwa), peristiwa ditampilkan: ![\[HelloWorldWorkflow peristiwa alur kerja awal\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/Events1.png) **catatan** Jika Anda memulai `GreeterWorker` sebelumnya, dan masih berjalan, Anda akan melihat daftar acara yang lebih panjang untuk alasan yang akan dibahas segera. Berhenti `GreeterWorker` dan coba jalankan `GreaterMain` lagi. Tab **Events** (Peristiwa) hanya menampilkan dua acara: + `WorkflowExecutionStarted` menunjukkan bahwa alur kerja telah mulai mengeksekusi. + `DecisionTaskScheduled` menunjukkan bahwa Amazon SWF telah antri tugas keputusan pertama. Alasan bahwa alur kerja diblokir pada tugas keputusan pertama adalah bahwa alur kerja didistribusikan di dua aplikasi, `GreeterMain` dan `GreeterWorker`. `GreeterMain` memulai eksekusi alur kerja, namun `GreeterWorker` tidak berjalan, sehingga pekerja tidak melakukan polling daftar dan melaksanakan tugas. Anda dapat menjalankan aplikasi baik secara independen, tetapi Anda perlu keduanya untuk eksekusi alur kerja untuk melanjutkan di luar tugas keputusan pertama. Jika Anda sekarang menjalankan `GreeterWorker`, alur kerja dan aktivitas pekerja akan mulai melakukan polling dan berbagai tugas akan selesai dengan cepat. Jika Anda sekarang memeriksa tab `Events`, batch pertama peristiwa ditampilkan. ![\[HelloWorldWorkflow acara alur kerja lengkap\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/Events2.png) Anda dapat memilih acara individual untuk mendapatkan informasi lebih lanjut. Pada saat Anda selesai mencari, alur kerja seharusnya mencetak “Hello World\$1” ke konsol Anda. Setelah alur kerja selesai, alur kerja tidak lagi muncul di daftar eksekusi aktif. Namun, jika Anda ingin memeriksanya, pilih tombol status eksekusi **Closed** (Ditutup) dan kemudian pilih **List Executions** (Daftar Eksekusi). Ini akan menampilkan semua instans alur kerja yang telah selesai di domain yang ditentukan (`helloWorldWalkthrough`) yang belum melebihi waktu penyimpanan mereka, yang Anda tentukan saat membuat domain. ![\[HelloWorldWorkflow alur kerja selesai\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/Closed_Workflows.png) Perhatikan bahwa setiap instans alur kerja memiliki nilai **Run ID** (Jalankan ID). Anda dapat menggunakan ID Alur Kerja yang sama untuk instance alur kerja yang berbeda, tetapi hanya untuk satu eksekusi aktif pada satu waktu. # HelloWorldWorkflowAsync Aplikasi Terkadang, sebaiknya alur kerja melakukan tugas tertentu secara lokal alih-alih menggunakan aktivitas. Namun, tugas alur kerja sering melibatkan pengolahan nilai-nilai yang diwakili oleh objek `Promise`. Jika Anda meneruskan objek `Promise` ke metode alur kerja sinkron, metode mengeksekusi segera tetapi tidak dapat mengakses nilai objek `Promise` objek siap. Anda bisa melakukan polling `Promise.isReady` sampai kembali `true`, tapi itu tidak efisien dan metode mungkin memblokir untuk waktu yang lama. Pendekatan yang lebih baik adalah dengan menggunakan *asynchronous method* (metode asinkron). Metode asinkron diimplementasikan seperti metode standar—sering sebagai anggota kelas implementasi alur kerja—dan berjalan dalam konteks implementasi alur kerja. Anda menetapkan sebagai metode asinkron dengan menerapkan anotasi `@Asynchronous`, yang mengarahkan kerangka kerja untuk memperlakukannya seperti suatu aktivitas. + Ketika implementasi alur kerja memanggil metode asinkron, alur kerja kembali dengan segera. Metode asinkron biasanya mengembalikan objek `Promise`, yang telah siap ketika metode selesai. + Jika Anda melewati metode asinkron satu atau lebih objek `Promise`, metode menunda eksekusi sampai semua objek masukan siap. Sebuah metode asinkron karena itu dapat mengakses input nilai `Promise` tanpa mempertaruhkan pengecualian. **catatan** Karena cara AWS Flow Framework untuk Java mengeksekusi alur kerja, metode asinkron biasanya dijalankan beberapa kali, jadi Anda harus menggunakannya hanya untuk tugas-tugas overhead rendah cepat. Anda harus menggunakan aktivitas untuk melakukan tugas-tugas yang panjang seperti komputasi large. Untuk detail selengkapnya, lihat [AWS Flow Framework Konsep Dasar: Eksekusi Terdistribusi](awsflow-basics-distributed-execution.md). Topik ini adalah panduan dari HelloWorldWorkflowAsync, versi modifikasi HelloWorldWorkflow yang menggantikan salah satu kegiatan dengan metode asinkron. Untuk mengimplementasikan aplikasi, buat salinan HelloWorld. HelloWorldWorkflow paket di direktori proyek Anda dan beri nama HelloWorld. HelloWorldWorkflowAsync. **catatan** Topik ini didasarkan pada konsep dan file yang disajikan di topik [HelloWorld Aplikasi](getting-started-example-helloworld.md) dan [HelloWorldWorkflow Aplikasi](getting-started-example-helloworldworkflow.md). Biasakan diri Anda dengan file dan konsep yang disajikan dalam topik tersebut sebelum melanjutkan. Bagian berikut menjelaskan cara memodifikasi HelloWorldWorkflow kode asli untuk menggunakan metode asinkron. ## HelloWorldWorkflowAsync Implementasi Kegiatan HelloWorldWorkflowAsync mengimplementasikan antarmuka pekerja aktivitasnya di`GreeterActivities`, sebagai berikut: ``` 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); } ``` Antarmuka ini mirip dengan yang digunakan oleh HelloWorldWorkflow, dengan pengecualian berikut: + Ini menghilangkan aktivitas `getGreeting`; tugas yang sekarang ditangani dengan metode asinkron. + Nomor versi diatur ke 2.0. Setelah Anda mendaftarkan antarmuka aktivitas dengan Amazon SWF, Anda tidak dapat memodifikasinya kecuali Anda mengubah nomor versi. Implementasi metode aktivitas yang tersisa identik dengan HelloWorldWorkflow. Hapus saja `getGreeting` dari `GreeterActivitiesImpl`. ## HelloWorldWorkflowAsync Implementasi Alur Kerja HelloWorldWorkflowAsync mendefinisikan antarmuka alur kerja sebagai berikut: ``` 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(); } ``` Antarmuka identik dengan HelloWorldWorkflow terpisah dari nomor versi baru. Seperti aktivitas, jika Anda ingin mengubah alur kerja terdaftar, Anda harus mengubah versinya. HelloWorldWorkflowAsync mengimplementasikan alur kerja sebagai berikut: ``` 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 menggantikan `getGreeting` aktivitas dengan metode `getGreeting` asinkron tetapi metode ini bekerja dengan `greet` cara yang hampir sama: 1. Eksekusi aktivitas `getName`, yang segera mengembalikan objek `Promise`, `name`, yang mewakili nama. 1. Panggil metode asinkron `getGreeting` dan meneruskan objek `name`. `getGreeting` dengan segera mengembalikan objek `Promise`, `greeting`, yang mewakili ucapan. 1. Eksekusi aktivitas `say` dan meneruskan objek `greeting`. 1. Saat `getName` lengkap, `name` telah siap dan `getGreeting` menggunakan nilainya untuk membangun ucapan. 1. Saat `getGreeting` lengkap, `greeting` telah siap dan `say` mencetak string ke konsol tersebut. Perbedaannya adalah bahwa, daripada memanggil klien aktivitas untuk mengeksekusi aktivitas `getGreeting`, menyapa panggilan metode `getGreeting` asinkron. Hasil bersih adalah sama, tetapi metode `getGreeting` bekerja agak berbeda dari aktivitas `getGreeting`. + Pekerja alur kerja menggunakan semantik fungsi panggilan standar untuk mengeksekusi `getGreeting`. Namun, eksekusi asinkron aktivitas dimediasi oleh Amazon SWF. + `getGreeting` menjalankan di proses implementasi alur kerja. + `getGreeting` mengembalikan objek `Promise` daripada objek `String`. Untuk mendapatkan nilai String yang dipegang oleh `Promise`, Anda menyebutnya metode `get()`. Namun, karena aktivitas dijalankan secara asinkron, nilai pengembaliannya mungkin tidak segera siap; `get()` akan memunculkan pengecualian hingga nilai pengembalian metode asinkron tersedia. Untuk informasi selengkapnya tentang cara kerja `Promise`, lihat [AWS Flow Framework Konsep Dasar: Data Exchange Antara Aktivitas dan Alur Kerja](awsflow-basics-data-exchange-activities-workflows.md). `getGreeting` membuat nilai kembali dengan melewati string ucapan ke metode `Promise.asPromise`statis. Metode ini membuat objek `Promise` dari jenis yang sesuai, menetapkan nilai, dan menempatkan dalam status siap. ## HelloWorldWorkflowAsync Alur Kerja dan Aktivitas Host dan Starter HelloWorldWorkflowAsync mengimplementasikan `GreeterWorker` sebagai kelas host untuk alur kerja dan implementasi aktivitas. Ini identik dengan HelloWorldWorkflow implementasi kecuali untuk `taskListToPoll` nama, yang diatur ke "`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 mengimplementasikan alur kerja starter di`GreeterMain`; itu identik dengan implementasi. HelloWorldWorkflow Untuk menjalankan alur kerja, jalankan `GreeterWorker` dan`GreeterMain`, seperti halnya HelloWorldWorkflow. # HelloWorldWorkflowDistributed Aplikasi Dengan HelloWorldWorkflow dan HelloWorldWorkflowAsync, Amazon SWF memediasi interaksi antara alur kerja dan implementasi aktivitas, tetapi mereka berjalan secara lokal sebagai satu proses. `GreeterMain`dalam proses terpisah, tetapi masih berjalan pada sistem yang sama. Sebuah fitur kunci dari Amazon SWF adalah hal itu mendukung aplikasi didistribusikan. Misalnya, Anda dapat menjalankan workflow worker di EC2 instans Amazon, starter alur kerja di komputer pusat data, dan aktivitas di komputer desktop klien. Anda bahkan dapat menjalankan aktivitas yang berbeda pada sistem yang berbeda. HelloWorldWorkflowDistributed Aplikasi meluas HelloWorldWorkflowAsync untuk mendistribusikan aplikasi di dua sistem dan tiga proses. + Alur kerja dan starter alur kerja berjalan sebagai proses terpisah pada satu sistem. + Aktivitas berjalan pada sistem yang terpisah. Untuk mengimplementasikan aplikasi, buat salinan HelloWorld. HelloWorldWorkflowAsync paket di direktori proyek Anda dan beri nama HelloWorld. HelloWorldWorkflowDistributed. Bagian berikut menjelaskan cara memodifikasi HelloWorldWorkflowAsync kode asli untuk mendistribusikan aplikasi di dua sistem dan tiga proses. Anda tidak perlu mengubah implementasi alur kerja atau aktivitas untuk menjalankannya pada sistem yang terpisah, bahkan nomor versi tersebut. Anda juga tidak perlu memodifikasi `GreeterMain`. Yang perlu Anda ubah adalah host aktivitas dan alur kerja. Dengan HelloWorldWorkflowAsync, satu aplikasi berfungsi sebagai alur kerja dan host aktivitas. Untuk menjalankan implementasi alur kerja dan aktivitas pada sistem terpisah, Anda harus menerapkan aplikasi terpisah. Hapus GreeterWorker dari proyek dan tambahkan dua file kelas baru, GreeterWorkflowWorker dan GreeterActivitiesWorker. HelloWorldWorkflowDistributed mengimplementasikan kegiatan tuan rumah di GreeterActivitiesWorker, sebagai berikut: ``` 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 mengimplementasikan host alur kerjanya di`GreeterWorkflowWorker`, sebagai berikut: ``` 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(); } } ``` Catatan bahwa `GreeterActivitiesWorker` hanya `GreeterWorker` tanpa kode `WorkflowWorker` dan `GreeterWorkflowWorker` hanya `GreeterWorker` tanpa kode `ActivityWorker`. **Untuk menjalankan alur kerja:** 1. Buat file JAR yang dapat dijalankan dengan `GreeterActivitiesWorker` sebagai titik masuk. 1. Salin file JAR dari Langkah 1 ke sistem lain, yang dapat menjalankan sistem operasi yang mendukung Java. 1. Pastikan AWS kredensi dengan akses ke domain Amazon SWF yang sama tersedia di sistem lain. 1. Jalankan file JAR. 1. Pada sistem pengembangan Anda, gunakan Eclipse untuk menjalankan `GreeterWorkflowWorker` dan `GreeterMain`. Selain fakta bahwa aktivitas berjalan pada sistem yang berbeda dari pekerja alur kerja dan starter alur kerja, alur kerja bekerja dengan cara yang persis sama seperti. HelloWorldAsync Namun, karena `println` memanggil yang mencetak “Hello World\$1” ke konsol tersebut adalah di aktivitas `say`, output akan muncul pada sistem yang menjalankan pekerja aktivitas. # HelloWorldWorkflowParallel Aplikasi Versi sebelumnya dari Hello World\$1 semua menggunakan topologi alur kerja linear. Namun, Amazon SWF tidak terbatas pada topologi linier. HelloWorldWorkflowParallel Aplikasi ini adalah versi modifikasi HelloWorldWorkflow yang menggunakan topologi paralel, seperti yang ditunjukkan pada gambar berikut. ![\[HelloWorldWorkflowParallel topologi alur kerja\]](http://docs.aws.amazon.com/id_id/amazonswf/latest/awsflowguide/images/helloworld_parallel_topology.png) Dengan HelloWorldWorkflowParallel, `getName` dan `getGreeting` jalankan secara paralel dan masing-masing mengembalikan bagian dari salam. `say`kemudian menggabungkan dua string menjadi salam, dan mencetaknya ke konsol. Untuk mengimplementasikan aplikasi, buat salinan HelloWorld. HelloWorldWorkflow paket di direktori proyek Anda dan beri nama HelloWorld. HelloWorldWorkflowParallel. Bagian berikut menjelaskan cara memodifikasi HelloWorldWorkflow kode asli untuk dijalankan `getName` dan secara `getGreeting` paralel. ## HelloWorldWorkflowParallel Aktivitas Pekerja Antarmuka HelloWorldWorkflowParallel aktivitas diimplementasikan di`GreeterActivities`, seperti yang ditunjukkan pada contoh berikut. ``` 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); } ``` Antarmuka mirip dengan HelloWorldWorkflow, dengan pengecualian berikut: + `getGreeting` tidak mengambil masukan apapun; itu hanya mengembalikan string ucapan. + `say` mengambil dua string masukan, ucapan dan nama. + Antarmuka memiliki nomor versi baru, yang diperlukan setiap saat Anda mengubah antarmuka yang terdaftar. HelloWorldWorkflowParallel melaksanakan kegiatan di`GreeterActivitiesImpl`, sebagai berikut: ``` 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` dan `getGreeting` sekarang hanya mengembalikan setengah dari string ucapan. `say` menggabungkan dua bagian untuk menghasilkan frase lengkap, dan mencetak ke konsol tersebut. ## HelloWorldWorkflowParallel Pekerja Alur Kerja Antarmuka HelloWorldWorkflowParallel alur kerja diimplementasikan dalam`GreeterWorkflow`, sebagai berikut: ``` 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(); } ``` Kelas identik dengan HelloWorldWorkflow versi, kecuali bahwa nomor versi telah diubah agar sesuai dengan pekerja aktivitas. Alur kerja diimplementasikan dalam `GreeterWorkflowImpl`, sebagai berikut: ``` 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); } } ``` Sekilas, implementasi ini terlihat sangat mirip dengan HelloWorldWorkflow; tiga metode aktivitas klien mengeksekusi secara berurutan. Namun, aktivitas tidak. + HelloWorldWorkflow diteruskan `name` ke`getGreeting`. Karena `name` adalah objek `Promise`, `getGreeting` ditangguhkan melaksanakan aktivitas sampai `getName` selesai, sehingga dua aktivitas dilaksanakan secara berurutan. + HelloWorldWorkflowParallel tidak melewati input apa pun `getName` atau`getGreeting`. Tidak ada metode yang menunda eksekusi dan metode aktivitas terkait dieksekusi segera, secara paralel. Aktivitas `say` mengambil `greeting` dan `name` sebagai parameter input. Karena mereka adalah objek `Promise`, `say` yang menunda eksekusi sampai kedua aktivitas selesai, dan kemudian membangun dan mencetak ucapan. Perhatikan bahwa HelloWorldWorkflowParallel tidak menggunakan kode pemodelan khusus untuk menentukan topologi alur kerja. Ia melakukannya secara implisit dengan menggunakan kontrol aliran Java standar dan mengambil keuntungan dari properti objek. `Promise` AWS Flow Framework untuk aplikasi Java dapat mengimplementasikan bahkan topologi kompleks hanya dengan menggunakan `Promise` objek dalam hubungannya dengan konstruksi aliran kontrol Java konvensional. ## HelloWorldWorkflowParallel Alur Kerja dan Aktivitas Host dan Starter HelloWorldWorkflowParallel mengimplementasikan `GreeterWorker` sebagai kelas host untuk alur kerja dan implementasi aktivitas. Ini identik dengan HelloWorldWorkflow implementasi kecuali untuk `taskListToPoll` nama, yang diatur ke "HelloWorldParallelList”. `HelloWorldWorkflowParallel`mengimplementasikan alur kerja starter di`GreeterMain`, dan itu identik dengan implementasi. HelloWorldWorkflow Untuk menjalankan alur kerja, jalankan `GreeterWorker` dan `GreeterMain`, seperti dengan `HelloWorldWorkflow`.