इवेंट जनरेशन, CQRS और लारवेल

पेशेवर पाठ्यक्रम "फ्रेमवर्क लारवेल" के छात्रों के लिए लेख का अनुवाद तैयार किया गया था।

---

परिचय

यह लेख PHP भाषा और लार्वेल ढांचे में घटना CQRS- सिस्टम बनाने की मूल बातें के लिए समर्पित है। यह माना जाता है कि आप कमांड बस का उपयोग करके विकास योजना से परिचित हैं और इसमें घटनाओं का एक विचार है (विशेष रूप से, श्रोताओं की एक सरणी के लिए घटनाओं का प्रकाशन)। इस ज्ञान को ताज़ा करने के लिए, आप लैराकैट्स सेवा का उपयोग कर सकते हैं। इसके अलावा, यह माना जाता है कि आपको CQRS सिद्धांत की एक निश्चित समझ है। यदि नहीं, तो मैं अत्यधिक दो व्याख्यान सुनने की सलाह देता हूं: इवेंट जनरेशन और ग्रेग यंग के CQRS और इवेंट जनरेशन पर मैथियास वेरेज वर्कशॉप ।

अपनी परियोजनाओं में यहां दिए गए कोड का उपयोग न करें! यह CQRS के पीछे के विचारों को समझने का एक सीखने का मंच है। इस कोड को विश्वसनीय नहीं कहा जा सकता है, इसका खराब परीक्षण किया गया है, और इसके अलावा, मैं शायद ही कभी प्रोग्राम इंटरफेस करता हूं, इसलिए कोड के अलग-अलग हिस्सों को बदलना बहुत मुश्किल होगा। CQRS पैकेज का एक बेहतर उदाहरण आप उपयोग कर सकते हैं, ब्रॉडवे है, जो Qandidate Lab द्वारा विकसित किया गया है । यह साफ, शिथिल युग्मित कोड है, हालांकि, कुछ सार यह पूरी तरह से स्पष्ट नहीं करते हैं यदि आपने कभी इवेंट सिस्टम का सामना नहीं किया है।

और आखिरी - मेरा कोड घटनाओं और लारवेल कमांड बस से जुड़ा हुआ है। मैं यह देखना चाहता था कि लारवेल में कोड कैसे दिखेगा (मैं आमतौर पर छोटी एजेंसियों की परियोजनाओं के लिए इस ढांचे का उपयोग करता हूं), हालांकि, पीछे मुड़कर देखता हूं, तो मुझे लगता है कि मुझे अपना कार्यान्वयन बनाना चाहिए। मुझे उम्मीद है कि मेरा कोड उन लोगों के लिए भी स्पष्ट होगा जो फ्रेमवर्क का उपयोग नहीं करते हैं।

Github पर, कोड https://github.com/scazz/cqrs-tutorial.git पर स्थित है, और हमारे गाइड में हम तर्क बढ़ाने के लिए इसके घटकों पर विचार करेंगे।

हम एक सर्फ स्कूल के लिए एक प्रारंभिक पंजीकरण प्रणाली बनाएंगे। इसकी मदद से, स्कूल ग्राहक कक्षाओं के लिए पंजीकरण कर सकते हैं। रिकॉर्डिंग प्रक्रिया के लिए, हम निम्नलिखित नियम बनाते हैं:

• प्रत्येक पाठ में कम से कम एक ग्राहक होना चाहिए ...
• ... लेकिन तीन से ज्यादा नहीं।

इवेंट-आधारित CQRS सिस्टम की सबसे प्रभावशाली विशेषताओं में से एक है सिस्टम से आवश्यक प्रत्येक मीट्रिक के लिए विशिष्ट रीडिंग मॉडल का निर्माण। आपको ElasticSearch में रीडिंग मॉडल के प्रक्षेपण के उदाहरण मिलेंगे, और ग्रेग यंग ने जटिल घटनाओं से निपटने के लिए अपने इवेंट स्टोर में एक विषय-उन्मुख भाषा को लागू किया है। हालाँकि, सादगी के लिए, हमारा पढ़ा हुआ प्रक्षेपण एलोकेंट के साथ उपयोग के लिए एक मानक SQL डेटाबेस होगा। नतीजतन, हमारे पास कक्षाओं के लिए एक टेबल और ग्राहकों के लिए एक होगा।

इवेंट जनरेशन की अवधारणा आपको घटनाओं को ऑफ़लाइन संसाधित करने की अनुमति देती है। लेकिन इस लेख में मैं "पारंपरिक" विकास मॉडल को अधिकतम (फिर से, सरल बनाने के लिए) का पालन करूंगा, और हमारे पढ़ने के अनुमानों को वास्तविक समय में अपडेट किया जाएगा, घटनाओं के भंडार में संग्रहीत किए जाने के तुरंत बाद।

प्रोजेक्ट सेटअप और पहला परीक्षण

git clone https://github.com/scazz/cqrs-tutorial 

एक नया Laravel 5 प्रोजेक्ट बनाएं

 $> laravel new cqrs-tutorial 

और शुरुआत के लिए, हमें एक परीक्षण की आवश्यकता है। हम एकीकरण परीक्षण का उपयोग करेंगे, जो यह सुनिश्चित करेगा कि कक्षाओं के लिए ग्राहक का पंजीकरण इस तथ्य की ओर जाता है कि सबक हमारे एलोकेंट मॉडल में बनाया गया है।

लिस्टिंग परीक्षण / CQRSTest.php:

 use Illuminate\Foundation\Bus\DispatchesCommands; class CQRSTest extends TestCase { use DispatchesCommands; 

 /** *  ,   BookLesson       * @return void */ public function testFiringEventUpdatesReadModel() { $testLessonId = '123e4567-e89b-12d3-a456-426655440000'; $clientName = "George"; $lessonId = new LessonId($testLessonId); $command = new BookLesson($lessonId, $clientName); $this->dispatch($command); $this->assertNotNull(Lesson::find($testLessonId)); $this->assertEquals( Lesson::find($testLessonId)->clientName, $clientName ); } } 

हम एक आईडी के लिए नई गतिविधि का प्रचार करते हैं, एक नई गतिविधि के लिए साइन अप करने के लिए एक टीम बनाते हैं, और लारवेल को इसे भेजने के लिए कहते हैं। पाठ तालिका में, हमें एक नया रिकॉर्ड बनाने की आवश्यकता है जिसे हम एलोकेंट मॉडल का उपयोग करके पढ़ सकते हैं। हमें एक डेटाबेस की आवश्यकता है, इसलिए अपनी .env फ़ाइल को ठीक से भरें।

हमारे ईवेंट स्टोर में दर्ज प्रत्येक घटना एग्रीगेट की जड़ से जुड़ी होती है, जिसे हम बस इकाई (इकाई) कहेंगे - शैक्षिक उद्देश्यों के लिए एक अमूर्तता केवल भ्रम पैदा करती है। आईडी एक सार्वभौमिक विशिष्ट पहचानकर्ता (UUID) है। यदि ईवेंट पाठ या क्लाइंट पर लागू होता है तो ईवेंट स्टोर ध्यान नहीं रखता है। वह केवल यह जानता है कि यह एक आईडी से जुड़ा है।

परीक्षण के दौरान पहचानी गई त्रुटियों के आधार पर, हम लापता कक्षाएं बना सकते हैं। सबसे पहले, हम लेसनॉइड क्लास बनाएंगे, फिर बुकलैसन कमांड (हैंडलर विधि के बारे में अभी तक चिंता न करें, बस परीक्षण चलाना जारी रखें)। लेसन क्लास, लेससन नेमस्पेस के बाहर एक रीडिंग मॉडल है। एक विशेष रीडिंग मॉडल - विषय क्षेत्र का तर्क यहां कभी संग्रहीत नहीं किया जाएगा। निष्कर्ष में, हमें पाठ तालिका के लिए एक माइग्रेशन बनाने की आवश्यकता होगी।

कोड की स्पष्टता बनाए रखने के लिए, मैं सत्यापन सत्यापन पुस्तकालय का उपयोग करूंगा। इसे निम्न कमांड के साथ जोड़ा जा सकता है:

 $> composer require beberlei/assert 

इस कमांड द्वारा शुरू की जाने वाली प्रक्रिया पर विचार करें:

1. मान्यता: आवश्यक आदेश विफल हो सकते हैं, और घटनाएँ पहले ही घटित हो चुकी हैं और इसलिए विफल नहीं होनी चाहिए।
2. एक नया पाठ बनाएँ घटना (एक पाठ के लिए साइन अप)।
3. गतिविधि की स्थिति अपडेट करें। (रिकॉर्ड मॉडल को मॉडल की स्थिति के बारे में पता होना चाहिए ताकि वह सत्यापन कर सके।)
4. इस घटना को गतिविधि रिकॉर्ड मॉडल में संग्रहीत अनअमाइंड इवेंट की धारा में जोड़ें।
5. स्टोर करने के लिए अप्रकाशित घटनाओं की धारा को बचाएं।
6. पाठ तालिका को अद्यतन करने के लिए सभी पठन प्रोजेक्टरों को सूचित करने के लिए विश्व स्तर पर लेसनॉस्कबुक की गई घटना उठाएँ।

पहले आपको पाठ के लिए एक रिकॉर्डिंग मॉडल बनाने की आवश्यकता है। हम स्थैतिक कारखाना विधि का उपयोग करेंगे Lesson::bookClientOntoNewLesson() । यह एक नया LessonWasOpened ईवेंट उत्पन्न करता है (पाठ खुला है), इस ईवेंट को स्वयं पर लागू करता है (बस अपनी आईडी सेट करता है), नए ईवेंट को DomainEventMessage (ईवेंट प्लस कुछ मेटाडेटा के रूप में उपयोग करता है जो हम इवेंट स्टोर में सहेजते समय उपयोग करते हैं)।

इवेंट में क्लाइंट जोड़ने के लिए प्रक्रिया को दोहराया जाता है। ClientWasBookedOntoLesson ईवेंट लागू करते ClientWasBookedOntoLesson (क्लाइंट को पाठ में नामांकित किया गया था), रिकॉर्डिंग मॉडल क्लाइंट नामों को ट्रैक नहीं करता है, लेकिन केवल पंजीकृत ग्राहकों की संख्या। रिकॉर्ड मॉडल को स्थिरता सुनिश्चित करने के लिए ग्राहक के नाम जानने की आवश्यकता नहीं है।

applyLessonWasOpened और applyClientWasBookedOntoLesson विधियां अभी थोड़ी अजीब लग सकती हैं। हम बाद में उनका उपयोग करेंगे जब हमें रिकॉर्डिंग मॉडल की स्थिति बनाने के लिए पुरानी घटनाओं को पुन: पेश करने की आवश्यकता होगी। यह समझाना आसान नहीं है, इसलिए मैं एक कोड दूंगा जो आपको इस प्रक्रिया को समझने में मदद करेगा। बाद में हम उस कोड को निकालेंगे जो uncommittedEvents को संसाधित करता है और डोमेन ईवेंट संदेश उत्पन्न करता है।

 app/School/Lesson/Lesson.php public function openLesson( LessonId $lessonId ) { /*      ,      ,       */ $this->apply( new LessonWasOpened( $lessonId) ); } protected function applyLessonWasOpened( LessonWasOpened $event ) { $this->lessonId = $event->getLessonId(); $this->numberOfClients = 0; } public function bookClient( $clientName ) { if ($this->numberOfClients >= 3) { throw new TooManyClientsAddedToLesson(); } $this->apply( new ClientBookedOntoLesson( $this->lessonId, $clientName) ); } /** *       — *  ,       *      ,       , *      . */ protected function applyClientBookedOntoLesson( ClientBookedOntoLesson $event ) { $this->numberOfClients++; } 

हम अपने रिकॉर्डिंग मॉडल से CQRS घटकों को निकाल सकते हैं - असम्बद्ध घटनाओं के प्रसंस्करण में शामिल वर्ग के टुकड़े। हम ईवेंट-जनरेट किए गए निकाय के लिए API को एक सुरक्षित applyEventName() फ़ंक्शन के लिए भी स्पष्ट कर सकते हैं जो ईवेंट को स्वीकार करता है, जो संबंधित applyEventName() विधि को कॉल करता है, और एक नए DomainEventMessage ईवेंट को DomainEventMessage ईवेंट की सूची में जोड़ता है। निकाला गया वर्ग CQRS कार्यान्वयन का एक विवरण है और इसमें डोमेन तर्क शामिल नहीं है, इसलिए हम एक नया नामस्थान बना सकते हैं: App \ CQRS:

कोड app/CQRS/EventSourcedEntity.php पर ध्यान app/CQRS/EventSourcedEntity.php
कोड को काम करने के लिए, हमें DomainEventMessage क्लास को जोड़ना होगा, जो कि एक साधारण DTO है - इसे app/CQRS/DomainEventMessage.php में पाया जा सकता है।

इस प्रकार, हमें एक प्रणाली मिली जो प्रत्येक लिखने के प्रयास के लिए घटनाओं को उत्पन्न करती है और आक्रमणकारियों को रोकने के लिए आवश्यक परिवर्तनों को रिकॉर्ड करने के लिए घटनाओं का उपयोग करती है। अगला कदम स्टोर में इन घटनाओं को बचाने के लिए है (EventStore)। सबसे पहले, इस घटना के भंडार को बनाने की आवश्यकता है। सरल बनाने के लिए, हम एलोकेंट मॉडल, निम्नलिखित क्षेत्रों के साथ एक साधारण एसक्यूएल टेबल का उपयोग करेंगे: * UUID (यह जानने के लिए कि किस इकाई को घटना को लागू करना है) * event_payload (घटना को फिर से बनाने के लिए आवश्यक सब कुछ युक्त धारावाहिक संदेश) - event_payload टाइमस्टैम्प जब घटना को जानने के लिए। यह क्या हुआ। यदि आप कोड की सावधानीपूर्वक समीक्षा करते हैं, तो आप देखेंगे कि मैंने दो आदेश बनाए - हमारे स्टोरेज टेबल को बनाने और नष्ट करने के लिए:

• php कारीगर eloquenteventstore: बनाएँ (App \ CQRS \ EloquentEventStore \ CreateEloquentEventStore)
• php कारीगर eloquenteventstore: drop (App \ CQRS \ EloquentEventStore \ DropEloquentEventStore) (उन्हें ऐप \ _ कंसोल / कर्नेल में जोड़ना न भूलें। ताकि वे लोड हों)।

SQL को इवेंट स्टोर के रूप में उपयोग नहीं करने के दो बहुत ही अच्छे कारण हैं: यह एपेंड-ओनली मॉडल (केवल डेटा जोड़ना, ईवेंट अपरिवर्तनीय होना चाहिए) को लागू नहीं करता है, और यह भी कि SQL टेम्पोरल डेटाबेस के लिए एक आदर्श क्वेरी लैंग्वेज नहीं है। हम बाद के प्रकाशनों में इवेंट स्टोर के प्रतिस्थापन की सुविधा के लिए इंटरफ़ेस को प्रोग्राम करते हैं।

घटनाओं को बचाने के लिए, भंडार का उपयोग करें। जब भी रिकॉर्डिंग मॉडल के लिए save() कहा जाता है, तो हम ईवेंट स्टोर में अनकम्यूटिव लिस्ट को सहेजते हैं। घटनाओं को संग्रहीत करने के लिए, हमें उनके क्रमांकन और डीराइज़ेशन के लिए एक तंत्र की आवश्यकता है। इसके लिए एक Serializer बनाएं। हमें मेटाडेटा की आवश्यकता है, जैसे कि एक घटना वर्ग (उदाहरण के लिए, App\School\Lesson\Events\LessonWasOpened ) और एक इवेंट पेलोड (किसी घटना को फिर से संगठित करने के लिए आवश्यक डेटा)।

यह सब JSON प्रारूप में एन्कोड किया जाएगा, और फिर इकाई UUID और टाइमस्टैम्प के साथ हमारे डेटाबेस को लिखा जाएगा। हम घटनाओं को कैप्चर करने के बाद अपने रीडिंग मॉडल को अपडेट करना चाहते हैं, इसलिए बचत के बाद रिपॉजिटरी हर घटना को ट्रिगर करेगी। सीरियल क्लास के लिए जिम्मेदार होगा, जबकि इवेंट उसके पेलोड को सीरियल करने के लिए जिम्मेदार होगा। एक पूरी तरह से क्रमबद्ध घटना कुछ इस तरह दिखाई देगी:

  { class: "App\\School\\Lesson\\Events\\", event: $event->serialize() } 

चूँकि सभी घटनाओं को क्रमबद्धता और डीरिएलाइज़ेशन विधि की आवश्यकता होती है, इसलिए हम एक SerializableEvent इंटरफ़ेस बना सकते हैं और अपेक्षित मूल्य के प्रकार का एक संकेत जोड़ सकते हैं। हमारे LessonWasOpened अपडेट करें:

 app/School/Lesson/Events/LessonWasOpened.php class LessonWasOpened implements SerializableEvent { public function serialize() { return array( 'lessonId'=> (string) $this->getLessonId() ); } } 

एक LessonRepository रिपोजिटरी रिपोजिटरी बनाएं। हम बाद में कोर CQRS घटकों को रिफ्लेक्टर और निकाल सकते हैं।

app/School/Lesson/LessonRepository.php

 eventStoreRepository = new EloquentEventStoreRepository( new EventSerializer() ); } public function save(Lesson $lesson) { /** @var DomainEventMessage $domainEventMessage */ foreach( $lesson->getUncommittedDomainEvents() as $domainEventMessage ) { $this->eventStoreRepository->append( $domainEventMessage->getId(), $domainEventMessage->getEvent(), $domainEventMessage->getRecordedAt() ); Event::fire($domainEventMessage->getEvent()); } } } 

यदि आप फिर से एकीकरण परीक्षण चलाते हैं और फिर domain_events SQL तालिका की जाँच करते हैं, तो आपको डेटाबेस में दो घटनाओं को देखना चाहिए।

परीक्षण को सफलतापूर्वक पास करने में हमारा अंतिम चरण प्रसारण घटनाओं को सुन रहा है और पाठ पढ़ने के मॉडल के प्रक्षेपण को अद्यतन करना है। पाठ प्रसारण की घटनाओं को LessonProjector द्वारा इंटरसेप्ट किया जाएगा, जो LessonProjection (पाठ तालिका के LessonProjection मॉडल) में आवश्यक परिवर्तन लागू करेगा:

  app/School/Lesson/Projections/LessonProjector.php class LessonProjector { public function applyLessonWasOpened( LessonWasOpened $event ) { $lessonProjection = new LessonProjection(); $lessonProjection->id = $event->getLessonId(); $lessonProjection->save(); } public function subscribe(Dispatcher $events) { $fullClassName = self::class; $events->listen( LessonWasOpened::class, $fullClassName.'@applyLessonWasOpened'); } }  app/School/Lesson/Projections/LessonProjection.php class LessonProjection extends Model { public $timestamps = false; protected $table = "lessons"; } 

यदि आप परीक्षण चलाते हैं, तो आप देखेंगे कि एक SQL त्रुटि हुई है:

 Unknown column 'clientName' in 'field list' 

जैसे ही हम clientName को पाठ तालिका में जोड़ने के लिए माइग्रेशन बनाते हैं, हम सफलतापूर्वक परीक्षण पास कर लेंगे। हमने CQRS की बुनियादी कार्यक्षमता को लागू किया है: टीमें ऐसी घटनाओं का निर्माण करती हैं जिनका उपयोग रीडिंग मॉडल बनाने के लिए किया जाता है।

लिंक के साथ रीडिंग मॉडल में सुधार

हम एक महत्वपूर्ण मुकाम पर पहुंच गए हैं, लेकिन यह सब नहीं है! अब तक, रीडिंग मॉडल केवल एक क्लाइंट का समर्थन करता है (हमने अपने डोमेन नियमों में तीन निर्दिष्ट किए हैं)। रीडिंग मॉडल में हम जो बदलाव करते हैं, वे काफी सरल हैं: हम सिर्फ एक क्लाइंट प्रोजेक्शन मॉडल और एक ClientBookedOntoLesson जो ClientBookedOntoLesson इवेंट को पकड़ता है। सबसे पहले, हम अपने परीक्षण को उन परिवर्तनों को प्रतिबिंबित करने के लिए अद्यतन करते हैं जिन्हें हम अपने पढ़ने के मॉडल में देखना चाहते हैं:

 tests/CQRSTest.php public function testFiringEventUpdatesReadModel() { $lessonId = new LessonId( (string) \Rhumsaa\Uuid\Uuid::uuid1() ); $clientName = "George"; $command = new BookLesson($lessonId, $clientName); $this->dispatch($command); $lesson = Lesson::find( (string) $lessonId); $this->assertEquals( $lesson->id, (string) $lessonId ); $client = $lesson->clients()->first(); $this->assertEquals($client->name, $clientName); } 

यह एक स्पष्ट प्रदर्शन है कि रीडिंग मॉडल को बदलना कितना आसान है। सब कुछ, घटना के भंडार के नीचे, अपरिवर्तित रहता है। एक बोनस के रूप में, ईवेंट सिस्टम का उपयोग करते समय, हमें बुनियादी परीक्षणों के लिए डेटा मिलता है - रीडिंग मॉडल के प्रोजेक्टर को बदलते समय, हम हर उस घटना को सुनते हैं जो कभी हमारे सिस्टम में हुई है।

हम नए प्रोजेक्टर का उपयोग करके इन घटनाओं को पुन: पेश करते हैं, अपवादों की जांच करते हैं, और पिछले अनुमानों के साथ परिणामों की तुलना करते हैं। सिस्टम कुछ समय के लिए काम करने के बाद, हमारे पास हमारे प्रोजेक्टरों के परीक्षण के लिए घटनाओं का एक काफी प्रतिनिधि चयन होगा।

हमारे रिकॉर्डिंग मॉडल में वर्तमान स्थिति को लोड करने की क्षमता नहीं है। यदि हम पाठ में दूसरा ग्राहक जोड़ना चाहते हैं, तो हम बस एक दूसरा ClientWasAddedToLesson ईवेंट बना सकते हैं, लेकिन हम इनवियर्स के खिलाफ सुरक्षा प्रदान नहीं कर सकते। अधिक स्पष्टता के लिए, मैं प्रति पाठ दो ग्राहकों की रिकॉर्डिंग का अनुकरण करते हुए एक दूसरा परीक्षण लिखने का प्रस्ताव करता हूं।

 tests/CQRSTest.php public function testLoadingWriteModel() { $lessonId = new LessonId( (string) \Rhumsaa\Uuid\Uuid::uuid1() ); $clientName_1 = "George"; $clientName_2 = "Fred"; $command = new BookLesson($lessonId, $clientName_1); $this->dispatch($command); $command = new BookClientOntoLesson($lessonId, $clientName_2); $this->dispatch($command); $lesson = Lesson::find( (string) $lessonId ); $this->assertClientCollectionContains($lesson->clients, $clientName_1); $this->assertClientCollectionContains($lesson->clients, $clientName_2); } 

हमारे रिकॉर्डिंग मॉडल के लिए, हमें एक इकाई को "लोड" करने की एक विधि को लागू करने की आवश्यकता है जिसके लिए इवेंट स्टोर में पहले से ही इसके लिए आवेदन कर सकते हैं। हम इकाई के यूयूआईडी को संदर्भित करने वाली प्रत्येक घटना को वापस खेलकर इसे प्राप्त कर सकते हैं। सामान्य शब्दों में, प्रक्रिया इस प्रकार है:

1. हमें ईवेंट स्टोर से सभी प्रासंगिक ईवेंट संदेश प्राप्त होते हैं।
2. प्रत्येक संदेश के लिए, हम इसी घटना को फिर से बनाते हैं।
3. हम एक नया इकाई रिकॉर्ड मॉडल बनाते हैं और प्रत्येक घटना को वापस खेलते हैं।

फिलहाल, हमारे परीक्षण अपवादों को फेंकते हैं, इसलिए हम BookLesson कमांड को टेम्पलेट के रूप में उपयोग करते हुए, आवश्यक BookClientOntoLesson (पाठ के लिए एक क्लाइंट रजिस्टर करें) BookLesson करेंगे। हैंडलर विधि इस तरह दिखाई देगी:

  app/School/Lesson/Commands/BookClientOntoLesson.php public function handle(LessonRepository $repository) { /** @var Lesson $lesson */ $lesson = $repository->load($this->lessonId); $lesson->bookClient($this->clientName); $repository->save($lesson); }      : app/School/Lesson/LessonRepository.php public function load(LessonId $id) { $events = $this->eventStoreRepository->load($id); $lesson = new Lesson(); $lesson->initializeState($events); return $lesson; } 

रिपॉजिटरी लोड फ़ंक्शन रीक्रिएटेड इवेंट की एक सरणी देता है। ऐसा करने के लिए, वह पहले रिपॉजिटरी में घटनाओं के बारे में संदेश पाता है, और फिर प्रत्येक संदेश को एक घटना में बदलने के लिए उन्हें Serializer में Serializer है। Serializer घटनाओं से संदेश बनाता है, इसलिए हमें व्युत्क्रम परिवर्तन करने के लिए deserialize() विधि को जोड़ने की आवश्यकता है। याद रखें कि घटना के डेटा (उदाहरण के लिए, क्लाइंट का नाम) को क्रमबद्ध करने के लिए प्रत्येक घटना के लिए Serializer पारित किया गया है। हम व्युत्क्रम परिवर्तन करने के लिए ऐसा ही करेंगे, जबकि हमारे SerializableEvent इंटरफ़ेस को deserialize() विधि का उपयोग करके अपडेट किया जाना चाहिए। कोड को देखते हैं ताकि सब कुछ जगह में गिर जाए। सबसे पहले EventStoreRepository लोड EventStoreRepository :

 app/CQRS/EloquentEventStore/EloquentEventStoreRepository.php public function load($uuid) { $eventMessages = EloquentEventStoreModel::where('uuid', $uuid)->get(); $events = []; foreach($eventMessages as $eventMessage) { /*       event_payload,        . */ $events[] = $this->eventSerializer->deserialize( json_decode($eventMessage->event_payload)); } return $events; } 

eventSerializer में उचित deserialization फ़ंक्शन का उपयोग करना:

 app/CQRS/Serializer/EventSerializer.php public function serialize( SerializableEvent $event ) { return array( 'class' => get_class($event), 'payload' => $event->serialize() ); } public function deserialize( $serializedEvent ) { $eventClass = $serializedEvent->class; $eventPayload = $serializedEvent->payload; return $eventClass::deserialize($eventPayload); } 

अंत में, हम LessonWasOpened में स्टैटिक फैक्ट्री विधि deserialize() का उपयोग LessonWasOpened (हमें प्रत्येक ईवेंट में इस विधि को जोड़ने की आवश्यकता है)

 app/School/Lesson/Events/LessonWasOpened.php public static function deserialize($data) { $lessonId = new LessonId($data->lessonId); return new self($lessonId); } 

अब हमारे पास उन सभी घटनाओं की एक सरणी है, जिन्हें हमने app/CQRS/EventSouredEntity.php में initializeState विधि में राज्य को शुरू करने के लिए हमारे एंटिटी रिकॉर्ड मॉडल के सापेक्ष पुन: प्रस्तुत किया है।

अब हमारी परीक्षा चलाओ। बिंगो!
वास्तव में, इस समय हमारे पास हमारे डोमेन नियमों के अनुपालन को सत्यापित करने के लिए एक परीक्षण नहीं है, इसलिए इसे लिखें:

 tests/CQRSTest.php public function testMoreThan3ClientsCannotBeAddedToALesson() { $lessonId = new LessonId( (string) \Rhumsaa\Uuid\Uuid::uuid1() ); $this->dispatch( new BookLesson($lessonId, "bob") ); $this->dispatch( new BookClientOntoLesson($lessonId, "george") ); $this->dispatch( new BookClientOntoLesson($lessonId, "fred") ); $this->setExpectedException( TooManyClientsAddedToLesson::class ); $this->dispatch( new BookClientOntoLesson($lessonId, "emma") ); } 

कृपया ध्यान दें कि हमें केवल lessonId आवश्यकता है - यह परीक्षण प्रत्येक कमांड के दौरान पाठ की स्थिति को lessonId ।

फिलहाल, हम केवल मैन्युअल रूप से बनाए गए UUID स्थानांतरित करते हैं, जबकि वास्तव में हम उन्हें स्वचालित रूप से उत्पन्न करना चाहते हैं। मैं Ramsy\UUID पैकेज का उपयोग करने जा रहा हूं, इसलिए composer साथ इसे स्थापित करें:

 $> composer require ramsey/uuid 

अब नए पैकेज का उपयोग करने के लिए हमारे परीक्षण अपडेट करें:

 tests/CQRSTest.php public function testEntityCreationWithUUIDGenerator() { $lessonId = new LessonId( (string) \Rhumsaa\Uuid\Uuid::uuid1() ); $this->dispatch( new BookLesson($lessonId, "bob") ); $this->assertInstanceOf( Lesson::class, Lesson::find( (string) $lessonId) ); } 

अब नए प्रोजेक्ट डेवलपर कोड को देख सकते हैं, App\School\ReadModels , जिसमें App\School\ReadModels मॉडल का एक सेट है, और पाठ तालिका में परिवर्तन लिखने के लिए इन मॉडलों का उपयोग करें। हम एक ऐसा app/CQRS/ReadModelImmutableModel.php क्लास बनाकर इसे रोक सकते हैं, जो एलोक्वेंट मॉडल क्लास का विस्तार करता है और app/CQRS/ReadModelImmutableModel.php में सेव मेथड को ओवरराइड करता है।