Stop Trusting Packages! Revolutionizing Spring Boot Architecture with Maven to Prevent Code Collapses
How to fix broken architectural code in Spring Boot by splitting Maven Modules and enforcing rules via the Compiler instead of relying on developer awareness.
Stock photo for illustration only, not from the actual event
- Relying on package segregation (.controller, .service) in a single module cannot genuinely prevent architectural violations.
- Solve the problem by dividing the backend project into specialized Maven modules to turn architectural rules into compilation errors.
- Extract the API contract into a separate Git repository to decouple it from backend development.
- Reduces long-term architectural decay by up to 70%, making it ideal for large-scale Enterprise systems.
A Friday afternoon code review might expose unexpected surprises, such as calling the EntityManager directly inside a REST controller while writing raw SQL and mapping data with loops, or receiving a Pageable and returning an Entity Page directly to the frontend, which exposes database structures to the outside world and completely destroys the Anti-Corruption Layer (ACL) concept.
When an application is structured within a single module and relies solely on package folder organization, we typically depend on team trust and discipline. In reality, under tight deadlines, Java package visibility rules fail to stop developers from violating architecture.
The team experimented with solving this issue by shifting away from human good intentions and directly enforcing architectural boundaries at the compiler level using a new dependency structure:
- Extract the API contract into a separate Git repository so its version remains independent of the backend code.
- Split the core backend project into highly specialized Maven modules.
- The core business logic module will have no access to dao-impl, bridge-impl, spring-boot-starter-data-jpa, Hibernate, Kafka, or Redisson in its classpath.
Transitioning to a multi-module architecture may initially introduce more complexity and boilerplate code, but for long-term Enterprise system maintenance, this approach prevents damage caused by developers taking shortcuts. It guarantees that domain boundaries remain securely protected without needing to obsess over every line during Code Reviews.
The result is that if a developer attempts to inject an EntityManager or write raw SQL commands into the core business code, the compiler will immediately reject it and the build will fail right on their local machine, unless they modify the pom.xml file to add a dependency—which instantly becomes a prominent red flag during a Code Review.
This approach is well-suited for Enterprise systems requiring long-term maintainability and high development velocity. However, for small CRUD applications with only five database tables, this strategy is considered overengineering.
Source: Dev.to
Found something wrong in this article? Report an issue with this article
Comments
Leave a Comment