Discover Hexagonal Architecture to create web applications with isolated, testable layers. Gain insights into designing clean, maintainable modules and advocating for suitable techniques for your application.

Get Your Hands Dirty on Clean Architecture by Tom Hombergs.png

spring.tar.gz

spring1

spring1-copy

blank

This course will teach you all about creating a web application in the Hexagonal Architecture style. Hexagonal Architecture promotes the separation of concerns by encapsulating logic in different layers of the application. This enables a higher level of isolation, testability, and control over your business specific code. 

You will learn how to design software modules and complete applications in a clean and maintainable manner, while also learning how to advocate for a certain technique given your application and constraints.

By the end of this course, you will have a greater understanding of how to implement software architecture, a key skill for any senior developer.

Hexagonal Software Architecture for Web Applications

# Implementing the configuration component

There are several ways to implement a configuration component responsible for assembling the application. If we're building an application without the support of a dependency injection framework, we can create such a component with plain code:

package copyeditor.configuration;

class Application {

  public static void main(String[] args) {
    
    AccountRepository accountRepository = new AccountRepository();
    ActivityRepository activityRepository = new ActivityRepository();
    AccountPersistenceAdapter accountPersistenceAdapter =
        new AccountPersistenceAdapter(accountRepository, activityRepository);

    SendMoneyUseCase sendMoneyUseCase =
        new SendMoneyUseService(
            accountPersistenceAdapter,  // LoadAccountPort
            accountPersistenceAdapter); // UpdateAccountStatePort

    SendMoneyController sendMoneyController = 
        new SendMoneyController(sendMoneyUseCase);
    
    startProcessingWebRequests(sendMoneyController);
    
  }
}

This code snippet is a simplified example of what such a configuration component might look like. In Java, an application is started from the `main` method. Within this method, we instantiate all the classes we need, from web controller to persistence adapter, and wire them together. 

# The method `startProcessingWebRequests()`

Finally, we call the mystic method `startProcessingWebRequests()`, which exposes the web controller via HTTP[$^{8}$](https://www.educative.io/courses/hexagonal-architecture-web-apps/appendix-i#mystic). The application is then ready to process requests.

This plain code approach is the most basic way of assembling an application. It has some drawbacks, however. 

1. The code above is for an application that has only a single web controller, use case, and persistence adapter. Imagine how much code like this we would have to produce to bootstrap a full-blown enterprise application!
2. Since we’re instantiating all classes ourselves from outside of their packages, all these classes need to be public. This means, for example, that Java doesn’t prevent a use case directly accessing a persistence adapter, since it’s public. It would be nice if we could avoid unwanted dependencies like this by using package-private visibility.


Learn how to assemble your application via plain code.

Before We Begin

What's Wrong with Layers?

Inverting Dependencies

Organizing Code

Implementing a Use Case

Implementing a Web Adapter

Implementing a Persistence Adapter

Testing Architecture Elements

Mapping Between Boundaries

Assembling the Application

Enforcing Architecture Boundaries

Taking Shortcuts Consciously

Assessment

Conclusion

Appendix

Assembling via Plain Code

Implementing the configuration component