Talk to an instructur:
+41 61 551 00 82
jonas@letsboot.ch

Clean Architecture with Spring Boot 

Course & Training

Applying Clean Architecture on Spring Boot applications

Refactoring a Spring Boot application: from spaghetti code to Clean Architecture: Three days of intensive refactoring to transform the internal structure of a poorly maintainable Spring Boot application into a future-proof and easily adaptable design based on Clean Architecture.

In-House Course:

We are happy to conduct tailored courses for your team - on-site, remotely or in our course rooms.

Request In-House Course

Content:


Spring Boot applications usually follow an MVC structure, with database entities (e.g. Hibernate) often being passed directly into a service via repositories and, in the worst case, even returned to the frontend via REST controllers.

As the application grows, this often results in hard-to-maintain, entangled spaghetti code applications, also called Big Ball of Mudd.

Such code typically has few meaningful abstractions, relies mainly on primitive data types to model the domain, and mixes presentation, database, and business logic.

Exchanging dependencies, such as replacing one database technology with another, is nearly impossible. This also makes testing difficult, even at the unit test level.

The result is difficult-to-maintain software systems with high error rates, long implementation cycles, and low developer and customer satisfaction.

In recent years, architecture patterns such as Ports & Adapters and their variation "Clean Architecture", together with Domain-Driven Design (DDD), have emerged as effective means to counteract such a development. However, you don't have to have used Clean Architecture from the start of the project to be able to integrate it into your application!

In this course, you will learn how to effectively migrate complicated, hard-to-maintain Spring Boot applications step-by-step to Clean Architecture with clearly separated concerns using various refactoring techniques, while keeping the application deliverable at all times.

Practically tried and tested concepts and techniques from the following topics:

- How to effectively integrate Clean Architecture into a Spring Boot application.
- Most important Code Smells and how they can negatively impact code quality.
- Basic and advanced automated and manual refactoring techniques to solve these Code Smells and transition the application step-by-step into Clean Architecture.
- Fundamentals of Ports & Adapters (Hexagonal Architecture) as the basis of Clean Architecture.
- Different components of Clean Architecture and practical implementations of them.
- Different considerations and trade-offs regarding Clean Architecture and how they affect the target design.
- Embedding Clean Architecture in Domain-Driven Design (DDD) and how selected concepts from DDD can further concretize and enhance Clean Architecture.


Disclaimer: The actual course content may vary from the above, depending on the trainer, implementation, duration and constellation of participants.

Whether we call it training, course, workshop or seminar, we want to pick up participants at their point and equip them with the necessary practical knowledge so that they can apply the technology directly after the training and deepen it independently.

Goal:

After this course, you will have the skills to transform convoluted code within Spring Boot applications into Clean Architecture using automated and manual refactoring techniques. 
You will also be able to name and identify different micro-antipatterns in the code and resolve them effectively. 
In addition, you will have a better understanding of selected elements from DDD and know various trade-offs to consider when implementing Clean Architecture.


Form:

The course is divided into sequential modules. 
The main part is dedicated to practical exercises, which can be solved mainly in smaller groups (Pair or Mob Programming). 
Depending on interest and need, different topics can be discussed in more depth.


Target Audience:

Java software engineers and/or architects, who ideally have already gained experience with Spring Boot. However, the principles and practices shown can be applied to any other framework and programming language, such as C#.


Requirements:

Basic knowledge in development with Java and Spring Boot (unsure? Contact Oliver Zihler or Alina Liburkina).


Preparation:

Java, Git, Maven, own laptop with IntelliJ or Eclipse installed. Each participant will receive a questionnaire and installation instructions before the start of the course. (On request we can provide preinstalled laptops for the course.)

Request In-House Course:

In-House Kurs Anfragen

Waitinglist for public course:

Sign up for the waiting list for more public course dates. Once we have enough people on the waiting list, we will determine a date that suits everyone as much as possible and schedule a new session. If you want to participate directly with two colleagues, we can even plan a public course specifically for you.

Waiting List Request

(If you already have 3 or more participants, we will discuss your preferred date directly with you and announce the course.)

Share by: