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

While classpath scanning is the cudgel of application assembly, Spring's Java Config is the scalpel. This approach is similar to the plain code approach introduced earlier in this chapter, but it's less messy and provides us with a framework so that we don't have to code everything by hand.



In this approach, we create configuration classes, each responsible for constructing a set of beans that are to be added to the application context.

For example, we could create a configuration class that is responsible for
instantiating all our persistence adapters:

@Configuration
@EnableJpaRepositories
class PersistenceAdapterConfiguration {
  
  @Bean
  AccountPersistenceAdapter accountPersistenceAdapter(
  		AccountRepository accountRepository,
        ActivityRepository activityRepository,
        AccountMapper accountMapper){
    return new AccountPersistenceAdapter(
      accountRepository,
      activityRepository,
      accountMapper);
  }
  
  @Bean
  AccountMapper accountMapper(){
    return new AccountMapper();
  }
  
}

# The `@Configuration` annotation

The `@Configuration` annotation marks this class as a configuration class to be picked
up by Spring's classpath scanning. So, in this case, we're still using classpath scanning,
but we only pick up our configuration classes instead of every single bean, which reduces
the chance of evil magic happening. 

# The `@Bean` annotation

The beans themselves are created within the `@Bean`-annotated factory methods of our configuration
classes. In the case above, we add a persistence adapter to the application context. 
It needs two repositories and a mapper as input to its constructor. Spring automatically provides these objects as input
to the factory methods.


# The `@EnableJpaRepositories` annotation
But where does Spring get the repository objects from? If they are created manually
in a factory method of another configuration class, Spring would automatically
provide them as parameters to the factory methods of the code example above. 
In this case, however, they are triggered by the 
`@EnableJpaRepositories` annotation and are created by Spring itself. If Spring Boot finds this annotation, it will automatically
provide implementations for all Spring Data repository interfaces we have defined.

If you're familiar with Spring Boot, you might know that we could have added the `@EnableJpaRepositories` annotation to the main application class instead of our custom configuration
class. Yes, this is possible, but it would activate JPA repositories every time the
application is started, even if we start the application within a test that doesn't
actually need persistence. So, by moving such "feature annotations" to a separate configuration "module",
we've just become much more flexible and can start up parts of our application
instead of always having to start the whole thing. 


Learn how to assemble your web application with the help of Spring's Java configuration.

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 Spring's Java Config

Java Config