System Architectural Styles

 

What is Monolithic Architecture?

Monolithic architecture is a software design methodology that combines all of an application's components into a single, inseparable unit. Under this architecture, the user interface, business logic, and data access layers are all created, put into use, and maintained as one, unified unit.

  • In contrast, alternative architectural approaches, like microservices, divide the application into smaller, separately deployable services.
  • Software development used to be dominated by monolithic architecture, which was preferred for its simplicity and ease of initial setup.

Monolithic-Architecture

Characteristics of Monolithic Architecture

Monolithic architecture exhibits several defining characteristics:

  • Single Codebase: The program is simpler to manage and implement since all of its components are created and maintained in a single codebase.
  • Tight Coupling: The architecture's components are closely linked, rely on one another, and frequently exchange resources and data directly.
  • Shared Memory: Monolithic applications typically share the same memory space, allowing components to communicate efficiently without the need for network overhead.
  • Centralized Database: Data storage is centralized within the application, typically using a single database instance for all data storage needs.
  • Layered Structure: The structure of monolithic systems is frequently layered, with separate layers for data access, business logic, and presentation. This might result in dependencies across layers even while it separates issues.
  • Limited Scalability: Because the entire application must be scaled at once, scaling a monolithic application can be difficult and frequently leads to inefficiencies and higher resource usage.

What is Microservice Architecture?


Microservices are an architectural approach to developing software applications as a collection of small, independent services that communicate with each other over a network. Instead of building a monolithic application where all the functionality is tightly integrated into a single codebase, microservices break down the application into smaller, loosely coupled services.

microservices


How do Microservices work?

Microservices break complex applications into smaller, independent services that work together, enhancing scalability, and maintenance. Below is how microservixes work:

  • Applications are divided into self-contained services, each focused on a specific function, simplifying development and maintenance.
  • Each microservice handles a particular business feature, like user authentication or product management, allowing for specialized development.
  • Services interact via APIs, facilitating standardized information exchange and integration.
  • Different technologies can be used for each service, enabling teams to select the best tools for their needs.
  • Microservices can be updated independently, reducing risks during changes and enhancing system resilience.

What are the main components of Microservices Architecture?

Main components of microservices architecture include:

  • Microservices: Small, loosely coupled services that handle specific business functions, each focusing on a distinct capability.
  • API Gateway: Acts as a central entry point for external clients also they manage requests, authentication and route the requests to the appropriate microservice.
  • Service Registry and Discovery: Keeps track of the locations and addresses of all microservices, enabling them to locate and communicate with each other dynamically.
  • Load Balancer: Distributes incoming traffic across multiple service instances and prevent any of the microservice from being overwhelmed.
  • Containerization: Docker encapsulate microservices and their dependencies and orchestration tools like Kubernetes manage their deployment and scaling.
  • Event Bus/Message Broker: Facilitates communication between microservices, allowing pub/sub asynchronous interaction of events between components/microservices.
  • Database per Microservice: Each microservice usually has its own database, promoting data autonomy and allowing for independent management and scaling.
  • Caching: Cache stores frequently accessed data close to the microservice which improved performance by reducing the repetitive queries.
  • Fault Tolerance and Resilience Components: Components like circuit breakers and retry mechanisms ensure that the system can handle failures gracefully, maintaining overall functionality.

Comments

Post a Comment

Popular posts from this blog

Archunit test

  ArchUnit  integrates nicely with the  JUnit  test framework, and so, they are typically used together.  All we have to do is add the  archunit-junit 5  dependency to match our  JUnit  version: < dependency > < groupId > com.tngtech.archunit </ groupId > < artifactId > archunit-junit5 </ artifactId > < version > 0.14.1 </ version > < scope > test </ scope > </ dependency > Step 1: The first step is to create a set of Java classes that will be checked for rules violations . We do this by instantiating the  ClassFileImporter  class and then using one of its  importXXX()  methods: JavaClasses jc = new ClassFileImporter () .importPackages( "com.baeldung.archunit.smurfs" ); Step 2:  Let’s try to implement the first rule defined above using this API. We’ll use the  classes()  method as our anchor and add additional constraints ...
Read more

Hexagonal Architecture

Image
  Hexagonal architecture is a model of  designing software applications around domain logic  to isolate it from external factors. The domain logic is specified in a business core, which we’ll call the inside part, with the rest being outside parts.  Access to domain logic from the outside is available through  ports  and  adapters .  here we divide our application into three layers:  application (outside), domain (inside), and infrastructure (outside): Through  the application layer, the user or any other program interacts  with the application. This area should contain things like user interfaces, RESTful controllers, and JSON serialization libraries. It includes anything  that exposes entry to our application, and orchestrates the execution of domain logic. In the domain layer, we keep the code that touches and implements business logic . This is the core of our application. This layer should be isolated from both the applica...
Read more

visitor design pattern

Image
  The Visitor design pattern is a  behavioral pattern  that allows you to add new operations to a group of related classes without modifying their structures. Real-World Example of Visitor Design Pattern A simple example of the Visitor design pattern is in an online shopping cart. Imagine you have different items like books, electronics, and clothing. Each item can accept a visitor that performs actions like calculating the total price or applying discounts. This way, you can add new features without changing the item classes, making the system easier to maintain and update. UML Class Diagram of Visitor design pattern Components of Visitor Design Pattern The Visitor design pattern consists of several key components that work together to enable its functionality. Here’s a breakdown of these components: Visitor Interface : This interface declares a visit method for each type of element in the object structure. Each method is designed to handle a specific element type. Concr...
Read more