Hexagonal architecture – overview and best practices

Have you ever ever thought of hexagonal structure?

On this article, we’re going to clarify what it’s, the way it works and when your group ought to go for it. We’re additionally going to make a easy train for these extra code-oriented.

We’ve bought loads to cowl so let’s break it down.

What you’ll be taught

We’re going to speak about:

• numerous kinds of architectures that preceded the hexagonal structure, often known as the ports and adapters structure. A few of their shortcomings impressed what’s often known as hexagonal structure immediately,
• fundamental details and historical past of the hexagonal structure,
• the way it works in idea,
• sensible advantages of the hexagonal strategy on your venture,
• most applicable and fashionable use circumstances,
• sensible code-packed hexagonal structure implementation utilizing an instance app.

Let’s begin with some background that can enable you perceive the context through which hexagonal structure was conceptualized.

Software program structure tendencies

Hexagonal structure might be higher understood within the wider context of contemporary software program structure tendencies.

Layered architectures

The idea of a standard layered structure is easy – by dividing your software into separate chunks, which embody modules and lessons that carry out comparable duties, you acquire quite a lot of advantages in numerous areas of software program improvement. Particularly, you get separation of considerations and area logic, which makes monitoring bugs, duplicates and different upkeep points a lot simpler.

There are various examples of layered structure. The most typical kind includes division into Presentation Layer, Logic Layer / Area Layer, and Knowledge Layer.

Area-driven design

Area-driven design or area mannequin is one more architectural sample pattern, which makes a case for layered structure. On the architectural stage, it promotes the advantages of organizing the construction of your software in accordance with the enterprise capabilities it fulfils. Separating the enterprise guidelines from the consumer interface or database undoubtedly helps in attaining that.

With that in thoughts, let’s get to the hexagonal structure.

Hexagonal structure –  the genesis

The idea of hexagonal structure was first launched in 2005 by an American pc scientist Alistair Cockburn, well-known additionally for his contributions to the Agile motion. At this time, this strategy is fashionable throughout a wide range of programming languages and frameworks.

Cockburn reached a conclusion that the core software interacts with the consumer interface or databases or automated take a look at in a remarkably comparable means. Subsequently, all of those exterior techniques might be separated from the core app / enterprise logic and made to speak with it in a technology-agnostic means.

Sounds complicated? It can all be clear after we take the idea of the hexagonal structure underneath a microscope.

Hexagonal structure – let’s break it down!

It is a fundamental overview of hexagonal structure. Within the following sections, we’re going to briefly discuss every high-level aspect of this structure.

The fundamentals – ports and adapters

The hexagonal structure follows a few fundamental rules, together with adapters structure, ports and adapters:

• Specific separation of user-side, server-side, and enterprise logic.
• The separation is achieved by the usage of Ports and Adapters (adapters structure).
• All dependencies transfer from the user-side / consumer interface and server-side in direction of the enterprise logic.

In hexagonal structure, the core software contains all of the enterprise logic in addition to the companies chargeable for numerous functionalities and use circumstances. The core receives from and sends instructions/queries to exterior techniques utilizing Ports and Adapters.

Ports

The time period “ports” merely refers to entry factors to the applying core. They comprise (sometimes technology-neutral) interfaces that make it potential for exterior entities to acquire a algorithm for speaking with the core. For the reason that ports are primarily simply gateways, one other agent is important to really make the communication occur. These are adapters.

Adapters

The adapters actively provoke the communication between exterior entities and the core. Every port can serve many adapters. A typical instance of a controller might be a REST controller or every other API request handler.

Right here is an especially essential factor in regards to the adapters structure – ports/adapters work with each the exterior techniques that begin the communication (driving aspect) and those that obtain it (pushed aspect). However the actual mechanism barely differs.

Driving aspect

The driving actors are people who begin the interplay with the applying by initiating a question. For instance, it may be the cell software interface or consumer interface code of an internet app. The consumer enter handed into the UI is taken by the adapter and despatched to the core by the port. Each the port (interface) and the implementation of the interface will likely be contained in the core/hexagon.

Pushed aspect

The pushed actors are people who want the core software to work together with them. It might be databases and even different functions. On this case, the applying calls the exterior (pushed) entity. Then, the pushed adapter implements the port for the core to make use of. This time, the implementation is throughout the pushed adapter.

Why a hexagon?

The six ends, on their very own, don’t actually have any specific that means so far as software code is worried. So why a hexagon?

The hexagon form (as within the above instance) is just a handy approach to depict that on this specific structure:

• The core logic and companies are inside,
• They impart with numerous exterior actors (ends) utilizing Ports and Adapters,
• These might be divided into driving and pushed actors, which once more is straightforward to depict utilizing a symmetrical form.

Let’s see now see what hexagonal structure can do for you.

Hexagonal structure – advantages

Organizing your code within the method prescribed by the hexagonal patterns has quite a lot of potential advantages:

• When finished accurately, it makes it potential to isolate the applying and enterprise logic from exterior components in order that they’ll all be examined simply and individually.
• On the identical, their dependencies might be simply mocked. 
• Designing the consumer interfaces by their function fairly than expertise ensures that your software’s expertise stack can freely develop over time.
• Helps implement the Area-Pushed Design by ensuring that the area logic doesn’t leak out of the core.
• The ports and adapters are simply as replaceable as all of the exterior entities, additional contributing to the scalability of the whole software.
• The superior separation of considerations additionally makes the app simpler to keep up, as altering the code in a single place or including new dependencies/methods to work together with the app, don’t require vital code modifications.
• Since one can take a look at outdoors dependencies with none further mocking instruments, enhancing the general testability of the applying.

TSH’s Frontend Developer Robert Goik believes that hexagonal structure has the potential to make the app a lot simpler to manage in the long term:

Hexagonal structure – when to make use of?

With all these advantages, it will appear that utilizing hexagonal structure is a no brainer? Is it actually the case? Let’s ask Robert once more:

“Ought to we use hexagonal structure in our initiatives? As at all times the reply is <it relies upon>. If it’s a pretty easy CRUD software, it’s in all probability not price it. Nevertheless, the extra advanced the venture is, the extra refined options are required. 

We construct functions with a bunch of various instruments. Frameworks are certainly one of them. Frameworks have the tendency to dominate. With the hexagonal structure, we will maintain frameworks in line and maintain the Core Utility framework agnostic.”

To sum it up – organizing your app in a means hexagonal structure calls for and maintaining the separation of concern just isn’t essentially a simple process. It does require talent and time. However it can repay in the long term. Offering that your app is huge and sophisticated sufficient for the “long term” to be price it! 

If it isn’t, it’s possible you’ll contemplate implementing just some facets of the structure to enhance separation of concern. There are various methods to go about it and it’s one thing that you must focus on together with your improvement workforce as the reply could also be totally different for any given venture.

Hexagonal structure in follow

Let’s make a easy train to indicate how hexagonal structure works in follow.

Solely just lately, a colleague at TSH printed a really fascinating learn regarding TSH’s Node.js boilerplate. It simply so occurs that that is the right alternative to confirm if a boilerplate works with hexagonal structure.

Let’s observe a easy HTTP request that can create a brand new consumer and ship an e-mail notification.

First, we ship a HTTP POST request. To this finish, we are going to use the specific.js framework, which can invoke an motion:

The motion will execute a command:

We have to have a supply mechanism. On this case, the CQRS sample (Command and Question Accountability Segregation) is in use. The Command Bus will likely be our supply mechanism that can execute CreateUserCommand. Instructions are state-changing operations (we are going to create a brand new consumer within the database). Queries (executed by Question Bus respectively) are data-retrieval operations.

At this level, we will see that the command might be executed in any means. Cron Job, GraphQL mutation, or CLI interface. We’re not coupled to precise.js and HTTP POST requests.

Lastly, the Command bus will set off the handler by executing the command:

Right here we will see that the brand new consumer is created within the database with the usage of userRepository. Then,  EmailNotificationEvent is dispatched, which can set off EmailNotificationService.

The e-mail notification service is outdoors our core software and we communicated with the database by a repository.

With hexagonal structure we should always pretty simply change the framework, it needs to be framework agnostic. To be compliant with hexagonal structure we want interfaces that outline the contract that we have to maintain on.

For instance our userRepository will implement a repository interface, and will persist with it. The identical goes for the EmailNotificationService. We should always be capable of use the service MailchimpService, SendGridService, or every other concrete implementation with our EmailNotificationService, outlined by particular interface.

Hexagonal structure with ports and adapters – abstract

And right here we’re! That’s nearly it for immediately’s weblog publish. What do you suppose? Is hexagonal structure one thing you may use in your venture? We certain suppose so. We’re additionally going to proceed to increase this text to make it even higher, with matters corresponding to onion structure, major and secondary adapters, batch scripts, dependency inversion precept, area objects, or the database entry facet.

To sum up a very powerful issues:

• Hexagonal structure is a sample that makes use of the mechanism of ports and adapters to realize separation of considerations and isolate exterior techniques and different exterior code corresponding to consumer interfaces and databases from the core software.
• It has quite a lot of advantages for the testability and scalability of your software and when it comes to freedom of precise implementation of your core area, software layer and enterprise logic.
• However it requires a sure stage of complexity from the app for these advantages to really shine.
• A partial implementation of the structure could also be an answer for smaller initiatives, nevertheless it requires additional consultations with builders on a project-by-project foundation.

It might be our workforce!