How can you use clean and hexagonal architecture styles in software development?

3 How do they compare?

Both clean and hexagonal architecture styles strive for the same goals: high cohesion, low coupling, and easy testing. Yet, they differ in certain elements. For instance, clean architecture has a circular and hierarchical shape with inward and static dependencies, whereas hexagonal architecture has a polygonal and flat structure with bidirectional and dynamic dependencies. Additionally, clean architecture has a clear distinction between the domain and the application layers, whereas hexagonal architecture merges them into one application layer.

4 How can you use them?

When considering which architecture style to use in software development projects, you should keep in mind some best practices. These include applying the dependency inversion principle, using dependency injection, defining clear and consistent interfaces, and following the single responsibility principle. This will help invert the dependencies between the layers or ports and adapters so that higher-level modules or core applications do not depend on lower-level modules or external details. It also facilitates easy replacement or mocking of dependencies for testing purposes, as well as helping define contracts and boundaries between layers or ports and adapters to ensure effective communication and avoid unwanted coupling. Additionally, assigning each layer or port and adapter a single and well-defined responsibility will make them more cohesive and maintainable.

5 What are some examples?

To illustrate how you can use clean and hexagonal architecture styles in software development, here are some examples of how you can design a simple calculator application using each style.

6 # Clean architecture example

// Domain layer: defines the calculator interface and the calculation logic
interface Calculator {
  int add(int a, int b);
  int subtract(int a, int b);
  int multiply(int a, int b);
  int divide(int a, int b);
}
class CalculatorImpl implements Calculator {
  // Implement the calculation logic
}
// Application layer: defines the use cases and the input and output models
class CalculateUseCase {
  private Calculator calculator; // Inject the calculator dependency
  public CalculateUseCase(Calculator calculator) {
    this.calculator = calculator;
  }
  public CalculationOutput execute(CalculationInput input) {
    // Validate the input and perform the calculation
  }
}
class CalculationInput {
  // Define the input model
}
class CalculationOutput {
  // Define the output model
}
// Infrastructure layer: defines the adapters for the console input and output
class ConsoleInputAdapter {
  public CalculationInput readInput() {
    // Read the input from the console
  }
}
class ConsoleOutputAdapter {
  public void writeOutput(CalculationOutput output) {
    // Write the output to the console
  }
}
// Presentation layer: defines the controller that orchestrates the use case and the adapters
class ConsoleController {
  private CalculateUseCase calculateUseCase; // Inject the use case dependency
  private ConsoleInputAdapter consoleInputAdapter; // Inject the input adapter dependency
  private ConsoleOutputAdapter consoleOutputAdapter; // Inject the output adapter dependency
  public ConsoleController(CalculateUseCase calculateUseCase, ConsoleInputAdapter consoleInputAdapter, ConsoleOutputAdapter consoleOutputAdapter) {
    this.calculateUseCase = calculateUseCase;
    this.consoleInputAdapter = consoleInputAdapter;
    this.consoleOutputAdapter = consoleOutputAdapter;
  }
  public void run() {
    // Read the input, execute the use case, and write the output
  }
}        

7 # Hexagonal architecture example

// Application layer: defines the calculator interface and the calculation logic
interface Calculator {
  int add(int a, int b);
  int subtract(int a, int b);
  int multiply(int a, int b);
  int divide(int a, int b);
}
class CalculatorImpl implements Calculator {
  // Implement the calculation logic
}
// Port: defines the input port for the calculation request
interface CalculationRequestPort {
  void requestCalculation(int a, int b, String operation);
}
// Port: defines the output port for the calculation response
interface CalculationResponsePort {
  void respondCalculation(int result);
}
// Adapter: defines the driver adapter for the console input
class ConsoleInputAdapter implements CalculationRequestPort {
  private Calculator calculator; // Inject the calculator dependency
  private CalculationResponsePort calculationResponsePort; // Inject the output port dependency
  public ConsoleInputAdapter(Calculator calculator, CalculationResponsePort calculationResponsePort) {
    this.calculator = calculator;
    this.calculationResponsePort = calculationResponsePort;
  }
  public void readInput() {
    // Read the input from the console and request the calculation
  }
  public void requestCalculation(int a, int b, String operation) {
    // Perform the calculation and respond with the result
  }
}
// Adapter: defines the driven adapter for the console output
class ConsoleOutputAdapter implements CalculationResponsePort {
  public void respondCalculation(int result) {
    // Write the result to the console
  }
}        

8 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?