Muutke küpsiste eelistusi

E-raamat: Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka

  • Formaat: 480 pages
  • Ilmumisaeg: 04-Jul-2015
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780133846867
  • Formaat - PDF+DRM
  • Hind: 27,78 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
  • Formaat: 480 pages
  • Ilmumisaeg: 04-Jul-2015
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780133846867

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

USE THE ACTOR MODEL TO BUILD SIMPLER SYSTEMS WITH BETTER PERFORMANCE AND SCALABILITY

 

Enterprise software development has been much more difficult and failure-prone than it needs to be. Now, veteran software engineer and author Vaughn Vernon offers an easier and more rewarding method to succeeding with Actor model. Reactive Messaging Patterns with the Actor Model shows how the reactive enterprise approach, Actor model, Scala, and Akka can help you overcome previous limits of performance and scalability, and skillfully address even the most challenging non-functional requirements.

 

Reflecting his own cutting-edge work, Vernon shows architects and developers how to translate the longtime promises of Actor model into practical reality. First, he introduces the tenets of reactive software, and shows how the message-driven Actor model addresses all of themmaking it possible to build systems that are more responsive, resilient, and elastic. Next, he presents a practical Scala bootstrap tutorial, a thorough introduction to Akka and Akka Cluster, and a full chapter on maximizing performance and scalability with Scala and Akka.

 

Building on this foundation, youll learn to apply enterprise application and integration patterns to establish message channels and endpoints; efficiently construct, route, and transform messages; and build robust systems that are simpler and far more successful.

 

Coverage Includes





How reactive architecture replaces complexity with simplicity throughout the core, middle, and edges The characteristics of actors and actor systems, and how Akka makes them more powerful Building systems that perform at scale on one or many computing nodes Establishing channel mechanisms, and choosing appropriate channels for each application and integration challenge Constructing messages to clearly convey a senders intent in communicating with a receiver Implementing a Process Manager for your Domain-Driven Designs Decoupling a messages source and destination, and integrating appropriate business logic into its router Understanding the transformations a message may experience in applications and integrations Implementing persistent actors using Event Sourcing and reactive views using CQRS

 

Find unique online training on Domain-Driven Design, Scala, Akka, and other software craftsmanship topics using the for{comprehension} website at forcomprehension.com.

 
Foreword xiii
Preface xv
Acknowledgments xxiii
About the Author xxv
Chapter 1 Discovering the Actor Model and the Enterprise, All Over Again 1(24)
Why Enterprise Software Development Is Hard
1(4)
Introducing Reactive Applications
5(4)
Responsive
6(1)
Resilient
6(1)
Elastic
7(1)
Message Driven
8(1)
Enterprise Applications
9(1)
Actor Model
10(12)
Origin of Actors
11(2)
Understanding Actors
13(9)
The Actor Way Is Explicit
22(2)
What Next?
24(1)
Chapter 2 The Actor Model with Scala and Akka 25(82)
How to Get Scala and Akka
26(3)
Using Typesafe Activator
26(1)
Using sbt
26(1)
Using Maven
27(1)
Using Gradle
28(1)
Programming with Scala
29(14)
A Condensed Scala Tutorial
30(13)
Programming with Akka
43(61)
Actor System
44(11)
Supervision
55(4)
Remoting
59(12)
Clustering
71(28)
Testing Actors
99(3)
The CompletableApp
102(2)
Summary
104(3)
Chapter 3 Performance Bent 107(20)
Transistors Matter
107(2)
Clock Speed Matters
109(2)
Cores and Cache Matter
111(1)
Scale Matters
112(4)
Multithreading Is Hard
116(6)
How the Actor Model Helps
122(4)
Dealing with False Sharing
124(2)
The Patterns
126(1)
Chapter 4 Messaging with Actors 127(22)
Message Channel
128(2)
Message
130(5)
Pipes and Filters
135(5)
Message Router
140(3)
Message Translator
143(2)
Message Endpoint
145(2)
Summary
147(2)
Chapter 5 Messaging Channels 149(52)
Point-to-Point Channel
151(3)
Publish-Subscribe Channel
154(13)
Local Event Stream
155(5)
Distributed Publish-Subscribe
160(7)
Datatype Channel
167(3)
Invalid Message Channel
170(2)
Dead Letter Channel
172(3)
Guaranteed Delivery
175(8)
Channel Adapter
183(2)
Message Bridge
185(7)
Message Bus
192(8)
Summary
200(1)
Chapter 6 Message Construction 201(26)
Command Message
202(2)
Document Message
204(3)
Managing Flow and Process
206(1)
Event Message
207(2)
Request-Reply
209(2)
Return Address
211(4)
Correlation Identifier
215(2)
Message Sequence
217(1)
Message Expiration
218(4)
Format Indicator
222(4)
Summary
226(1)
Chapter 7 Message Routing 227(86)
Content-Based Router
228(4)
Message Filter
232(5)
Dynamic Router
237(8)
Recipient List
245(9)
Splitter
254(3)
Aggregator
257(7)
Resequencer
264(6)
Composed Message Processor
270(2)
Scatter-Gather
272(13)
Routing Slip
285(7)
Process Manager
292(16)
Message Broker
308(2)
Summary
310(3)
Chapter 8 Message Transformation 313(24)
Envelope Wrapper
314(3)
Content Enricher
317(4)
Immutable DoctorVisitCompleted
320(1)
Should the AccountingEnricherDispatcher Be Local?
321(1)
Content Filter
321(4)
Claim Check
325(7)
Normalizer
332(1)
Canonical Message Model
333(3)
Actor Systems Require a Canon
335(1)
Summary
336(1)
Chapter 9 Message Endpoints 337(56)
Messaging Gateway
338(6)
Messaging Mapper
344(7)
Transactional Client/Actor
351(11)
Transactional Client
353(1)
Transactional Actor
354(8)
Polling Consumer
362(9)
Resource Polling
367(4)
Event-Driven Consumer
371(1)
Competing Consumers
371(3)
Message Dispatcher
374(3)
Selective Consumer
377(2)
Durable Subscriber
379(3)
Idempotent Receiver
382(8)
Message De-duplication
383(1)
Design Messages with Identical Impact
384(1)
State Transition Renders Duplicates Harmless
384(6)
Service Activator
390(1)
Summary
391(2)
Chapter 10 System Management and Infrastructure 393(24)
Control Bus
394(1)
Detour
395(2)
Wire Tap
397(1)
Message Metadata/History
398(4)
Message Journal/Store
402(4)
Smart Proxy
406(5)
Test Message
411(3)
Channel Purger
414(2)
Summary
416(1)
Appendix A Dotsero: An Akka-like Toolkit for .NET 417(12)
Dotsero Actor System
417(3)
Actors Using C# and .NET
420(5)
Dotsero Implementation
425(2)
Summary
427(2)
Bibliography 429(4)
Index 433
Vaughn Vernon is a veteran software craftsman and thought leader in simplifying software design and implementation. The author of the best-selling Implementing Domain-Driven Design (Addison-Wesley, 2013), he has taught his IDDD Workshop to hundreds of software developers worldwide, consults, and speaks frequently at industry conferences. Vaughns interests include distributed computing, messaging, and Actor model. He first used Akka in 2012 on a GIS system and has specialized in applying Actor model with Domain-Driven Design ever since. He discusses his latest work at VaughnVernon.co and on Twitter at @VaughnVernon.