Microservices

 Microservices - also known as the microservice architecture - is an architectural style that structures an application as a collection of services that are:

  • Independently deployable
  • Loosely coupled

Services are typically organized around business capabilities. Each service is often owned by a single, small team. 

Developers can build these services in several programming languages, deploy, scale, and maintain them independently, and enable communication between them via well-defined APIs. Larger applications can remain mostly unaffected by the failure of a single module.
Communication between services is complex, more services equals more resources, debugging problems can be harder, deployment challengers, microservices are great for large companies, but can be slower to implement and too complicated for small companies who need to create and iterate quickly, and don’t want to get bogged down in complex orchestration.
Micro service Architectural Patterns
Saga architecture pattern: It provides transaction management using a sequence of local transactions.A local transaction is the unit of work performed by a Saga participant. Every operation that is part of the Saga can be rolled back by a compensating transaction. Further, the Saga pattern guarantees that either all operations complete successfully or the corresponding compensation transactions are run to undo the work previously completed.
CQRS pattern: CQRS is one of the important pattern when querying between microservices. We can use CQRS design pattern in order to avoid complex queries to get rid of inefficient joins. CQRS stands for Command and Query Responsibility Segregation. Basically this pattern separates read and update operations for a database. By this isolation, we can even use different database for reading and writing database types like using no-sql document database for reading and using relational database for crud operations.
Circuit Breaker pattern to gracefully degrade functionality when a method call fails. Use of the Circuit Breaker pattern can allow a microservice to continue operating when a related service fails, preventing the failure from cascading and giving the failing service time to recover.





Comments

Post a Comment

Popular posts from this blog

Transform values with a stream

The goal is to transform an array of numbers into a comma-delimited string using functional programming. The code snippet you provided has a minor issue: String.join(",", strings[0]) is incorrect because it tries to join a single element ( strings[0] ) rather than all elements in the strings array. Here's the corrected code for the transformValues method: import java.util.Arrays; class Answer {     // Change these boolean values to control whether you see      // the expected answer and/or hints.     static boolean showExpectedResult = true;     static boolean showHints = true;     // Transform an array of numbers into a comma-delimited list     // using functional programming.     static String transformValues(int[] numbers) {         // Convert the int array to a stream of integers         // Map each integer to its String representation         // ...
Read more

Collections Framework

 The Java Collections Framework provides a comprehensive set of interfaces, implementations, and algorithms to work with collections of objects in Java. It offers a unified architecture for representing and manipulating collections, making it easier to work with data structures in Java programs. The Collections Framework is a fundamental part of Java programming and is widely used in various applications ranging from simple data manipulation tasks to complex algorithms and data processing pipelines.  Key components of the Collections Framework: Interfaces Collection : The root interface of the Collections Framework hierarchy. Represents a group of objects, known as elements. Subinterfaces include List , Set , and Queue . List : Represents an ordered collection of elements where duplicate elements are allowed. Allows elements to be accessed and inserted by index. Implementations include ArrayList , LinkedList , and Vector . Set : Represents a collection of unique elements ...
Read more

Inspect a collection

Calculate the cart total  import java.util.List; import java.util.concurrent.atomic.AtomicReference; public class Main {     public static void main(String[] args) {         List<Item> items = List.of(             new Item("Item1", 10.0f, 2),             new Item("Item2", 5.0f, 4),             new Item("Item3", 20.0f, 1)         );         float total = getCartTotal(items);         System.out.println("Cart Total: " + total);  // Output: Cart Total: 60.0     }     static float getCartTotal(List<Item> items) {         AtomicReference<Float> total = new AtomicReference<>(0.0f);         items.forEach(item -> {             total.updateAndGet(v -> v + item.getQuantity() * item.getPrice())...
Read more