Desain berbasis acara - Masa Depan, Janji vs Ketekunan Akka

Saya memiliki beberapa kasus penggunaan yang memerlukan peristiwa yang telah ditentukan sebelumnya untuk diaktifkan berdasarkan tindakan pengguna tertentu.

misalnya katakanlah ketika NewUser dibuat di aplikasi, ia harus memanggil CreateUserInWorkflowSystem dan FireEmailToTheUser secara asinkron. Ada banyak kasus bisnis lain yang serupa dengan peristiwa yang ditentukan sebelumnya berdasarkan kasus penggunaan. Saya dapat menggunakan Promises/Futures untuk memodelkan peristiwa ini seperti di bawah ini

if 'NewUser' then 
    call `CreateUserInWorkflowSystem` (which will be Future based API)
    call `FireEmailToTheUser` (which will be Future based API)
if 'FileImport' then
   call `API3` (which will be Future based call)
   call `API4` (which will be Future based call)

Semua panggilan Future itu harus mencatat kegagalan di suatu tempat sehingga panggilan yang gagal dapat dicoba lagi, dll. Catatan Panggilan NewUser tidak akan menunggu Futures (peristiwa per kata) selesai.

Itu menggunakan Futures/Promises API biasa. Namun menurut saya Akka Persistence akan cocok di sini dan memblokir panggilan masih bisa mencapai Futures. Dengan kegigihan Akka, penanganan kegagalan akan mudah karena menyediakannya di luar kotak, dll. Saya memahami kegigihan Akka masih dalam tahap percobaan tetapi itu tampaknya tidak menjadi masalah besar karena typesafe umumnya menyimpan kerangka kerja baru ini dalam keadaan eksperimental sebelum dipromosikan ke rilis mendatang, dll. (hal yang sama juga berlaku pada Makro). Dengan adanya persyaratan ini, menurut Anda apakah Futures/Promises atau kegigihan Akka lebih cocok di sini?


scala akka akka-persistence
person Vikas Pandya    schedule 24.06.2014    source sumber

Jawaban (1)


arrow_upward
1
arrow_downward

Ini adalah pertanyaan berdasarkan opini - bukan jenis pertanyaan terbaik untuk ditanyakan pada SO. Pokoknya mencoba menjawab.

Hal ini sangat bergantung pada apa yang Anda nyamankan dan apa persyaratan Anda. Apakah nanti Anda perlu menskalakan sistem melampaui JVM tunggal - gunakan Akka. Apakah Anda ingin membuatnya lebih sederhana - gunakan Futures.

Jika Anda menggunakan Futures, Anda dapat menyimpan semua status dan tindakan yang akan dieksekusi dalam antrian pekerjaan/db. Itu cukup masuk akal.

Jika kalian menggunakan Akka Persistence maka jelas itu akan membantu kalian dalam persistence. Akka akan membantu melakukan pengawasan, pemulihan, dan percobaan ulang dengan lebih mudah. Jika tindakan CreateUserInWorkflowSystem Anda gagal, hasilnya disebarkan ke aktor pengawas yang mungkin memulai ulang aktor yang gagal dan membuatnya mencoba lagi sebanyak N kali. Jika aktor pengawas Anda gagal maka supervisornya akan melakukan hal yang benar, atau pada akhirnya seluruh aplikasi akan crash dan itu bagus. Dengan Futures Anda harus mengimplementasikan mekanisme ini sendiri dan memastikan aplikasi tersebut bisa crash saat dibutuhkan.

Jika Anda memiliki tindakan independen sepenuhnya, maka Kontrak Berjangka dan Aktor terdengar hampir sama. Jika Anda harus merangkai tindakan dan menyusunnya, maka menggunakan Futures akan menjadi hal yang lebih alami untuk dilakukan: untuk pemahaman, dll. Di Akka Anda harus menunggu sampai pesan dan berdasarkan jenis pesan, lakukan tindakan selanjutnya.

Cobalah untuk meniru implementasi sederhana menggunakan keduanya dan bandingkan apa yang Anda suka/tidak suka dengan persyaratan aplikasi khusus Anda. Secara keseluruhan, kedua pilihan itu bagus, namun dalam hal ini saya sedikit condong ke arah aktor.

person yǝsʞǝla    schedule 24.06.2014