Skip to main content

Design Discussion over Microservices Adaption

 Terms that are most commonly used in any microservices architecture

Don't worry after watching so many new terms as below :

  1. Saga Pattern
  2. Bounded context
  3. Eventual consistency
  4. Event Command Execution 
  5. Event broker
  6. CDC (change data capture) event managment
  7. Domain driven design
  8. Event driven design
  9. CQRS (Command query responsibility segregation)
  10. Rollback operation 
  11. Asynchronous Callback operation
  12. Fault tolerance :Bulk Head & Circuit breaker
  13. Open API configurations
  14. Centralized logging ELK
  15. Stats aggregation
  16. Aggregates in Domain Driven Design
  17. FAT Domain VS Anemic Domain
  18. Ubiquitous Language 
  19. Event sourcing
  20. Event replay
  21. Scatter-Gather Pattern

  • Saga Pattern:
     A pattern which is the heart soul of any microservice architecture ,it is used to manage data consistency across multiple microservices in distributed transaction .It performs a sequence of local transactions which perform updation operation in services & publish a message or trigger the event. There are below three type of transaction which perform crucial roleplay :
  1. Compensable transaction: In case of local transaction fails then compensable transaction comes into flow.It can potentially reversed by processing another transaction with opposite effect.
  2. Pivot transaction:It can be referred as go/no-go point .If the pivot transaction is commited ,saga constraints run untils it completion
  3. Retryable transaction :This transaction follows the pivot transaction & guranteed to succeed.

  • Bounded Context:                                                                          
  • Bounded context is a logical boundary: When both sub-domains and the core domain are defined, it’s time to implement the code. Bounded context defines tangible boundaries of applicability of some sub-domain. It is an area where a certain sub-domain makes sense, while the others don’t. It can be a talk, a presentation, a code project with physical boundaries defined by the artifact. Bounded context is a pretty vague concept for a lot of developers.



As per the above image ,CQRS pattern evolve usage of event sourcing ,Now what is event sourcing which need to know ,why its required .
So in case of event driver architecture when the event-command action roleplay is perfromed ,individual action(command) triggered a event,which need to be persist .So the benefit of persisting any event is beneficial in  such a when let say in case of failure of transaction ,you know the event Transaction_failed occurs so you will managing subsequent prior event which was supposed to be happen after checkout event.

Labels:

Comments

Post a Comment

Popular posts from this blog

LOVE THE WAY SINGLETON PATTERN CAN BE DESIGNED ! WOWW...

To implement Singleton pattern, we have different approaches : 1.Eager initialization: In this method the instance of clss is created at loading time .As whenever in java there is a requirement of species at loading time we first remember of Static keyword. package com.questprogram.singleton; public class EagerInitializedSingleton { private static final EagerInitializedSingleton instance = new EagerInitializedSingleton(); //private constructor to avoid client applications to use constructor private EagerInitializedSingleton(){} public static EagerInitializedSingleton getInstance(){ return instance; } } 2. Static block initialization Static Block initialization implementation is similar to eager initialization, except that instance of class is created in the static block that provides option for exception handling. package com.questprogram.singleton; public class StaticBlockSingleton { private static StaticBlockSingleton in
Post a Comment
Read more

Before Starting MicroServices just walk through Orchestration !! Matters a lot

What is this Orchestration : Orchestration is the traditional way of handling interactions between different services in Service-Oriented Architecture (SOA). With orchestration process, there is typically one controller that acts as the “orchestrator” of the overall service interactions. This typically follows a request/response type pattern. For example, if three services needed to be called in a particular order, the orchestrator makes a call to each one, waiting for a response before calling the next. 
Post a Comment
Read more

10 points to know about volatile variable in JAVA?

Volatile variable have some specific uses.It's better to know all the major reason  why java adopt such variables .Please found the below 10 points which need to be noticed: 1.Volatile variable always get allocated in the main memory.To allocate any variable in main memory volatile keyword is used. 2.Precisely volatile variable are always read and write directly from main memory.It doesn't perform any operation from CPU 's cache. 3.Volatile variable after JAVA 5 guranatees the visibilty of changes to variable across multiple threads. 4.Volatile also provide atomicity in some cases e.g .while reading double and long data types. 5.In case of volatile long and  volatile double data types which are of 64 bytes the read operation is atomic. 6. If you know that a long field is accessed by more than one thread e.g. a counter or anything, you better make it volatile. Why? because reading to a long variable is not atomic in Java and done in two steps, If one thread is w
Post a Comment
Read more