How do you design the ports and adapters for your hexagonal architecture applications?

1 What are ports and adapters?

Ports and adapters are the main components of hexagonal architecture. A port is an interface that defines the contract between the core logic and the external world. It can be either an incoming port, which receives requests from outside, or an outgoing port, which sends requests to outside. An adapter is an implementation of a port that connects the core logic to a specific external dependency, such as a database driver, a web framework, or a messaging system. An adapter can be either a primary adapter, which handles incoming requests, or a secondary adapter, which handles outgoing requests.

3 How to design ports and adapters?

To design the ports and adapters for your hexagonal architecture applications, you need to follow some best practices and principles. First, you need to make sure that your ports are abstract and decoupled from the adapters. This means that your ports should not depend on any specific technology or framework, but only on the domain concepts and logic. Second, you need to make sure that your adapters are thin and simple. This means that your adapters should not contain any business logic or validation, but only translate and delegate the requests to the ports. Third, you need to make sure that your ports and adapters are testable and replaceable. This means that you should use dependency injection, interfaces, and mocks to isolate and verify the behavior of your ports and adapters.

4 How to organize ports and adapters?

To organize the ports and adapters for your hexagonal architecture applications, you need to adopt a clear and consistent structure for your code. One common approach is to use a layered architecture, where you separate the core logic, the ports, and the adapters into different layers or modules. For example, you can have a domain layer that contains the core logic and the port interfaces, an infrastructure layer that contains the adapter implementations and the external dependencies, and a presentation layer that contains the user interface and the primary adapters. Another common approach is to use a package-by-feature architecture, where you group the core logic, the ports, and the adapters by the features or functionalities of your application. For example, you can have a package for each use case or scenario, such as order, customer, or product, and each package contains the domain classes, the port interfaces, and the adapter classes related to that feature.

5 How to evolve ports and adapters?

To evolve the ports and adapters for your hexagonal architecture applications, you need to be aware of the changes and the impacts that may occur in your application. You need to ask yourself: what are the new requirements or features that you need to add or modify? What are the new external dependencies or technologies that you need to integrate or replace? What are the risks or trade-offs that you need to consider? Based on these questions, you can decide how to adapt or extend your ports and adapters. For example, you can add new ports or adapters to support new functionalities or dependencies, or you can refactor existing ports or adapters to improve performance or quality.

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?