Hexagonal Architecture

 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):

DDD Layers

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 application part and infrastructure part. In addition, it should also contain interfaces that define the API to communicate with external parts, like the database, which the domain interacts with.

Finally, the infrastructure layer is the part that contains anything that the application needs to work, such as database configuration or Spring configuration. It also implements infrastructure-dependent interfaces from the domain layer.


The domain part only contains business logic, and can be easily moved to a different environment.


Hexagonal Architecture, DDD, and Spring | Baeldung


What is the difference between the Hexagonal Architecture and domain driven design:s

Hexagonal Architecture and Domain-Driven Design (DDD) are distinct concepts in software development, though they can often be used together. DDD focuses on modeling and understanding the business domain, while Hexagonal Architecture provides a way to structure your application to promote testability and decoupling. 


Hexagonal Architecture – System Design | GeeksforGeeks




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

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

Observer design pattern

Image
Observer Design Pattern Example To understand observer design pattern, lets take an example: Consider a scenario where you have a weather monitoring system. Different parts of your application need to be updated when the weather conditions change. Challenges or difficulties while implementing this system without Observer Design Pattern Components interested in weather updates would need direct references to the weather monitoring system, leading to  tight coupling . Adding or removing components that react to weather changes requires modifying the core weather monitoring system code, making it hard to maintain. How Observer Pattern helps to solve above challenges? The Observer Pattern facilitates the decoupling of the weather monitoring system from the components that are interested in weather updates (via interfaces). Every element can sign up as an observer, and observers are informed when the weather conditions change. The weather monitoring system is thus unaffected by the add...
Read more