Do You Need Interfaces in the Service Layer? A Top Architect’s Perspective

Why Interfaces Are Often Considered Unnecessary

When a dependency‑injection framework like Spring is used, the author argues that interfaces in the Service layer are not required because developers can directly code against concrete classes, and Spring’s AOP can work with CGLib proxies without interfaces.

Common Arguments for Using Interfaces

Facilitates writing upper‑layer code (e.g., Controllers) before the Service implementation is ready.

Spring’s default AOP implementation relies on dynamic proxies, which need interfaces.

Allows multiple implementations of a Service.

The author refutes each point: the first adds unnecessary boilerplate in most projects; the second can be solved by switching to CGLib; the third is rarely needed and can be replaced by other patterns.

Recommended Development Flow Without Interfaces

Write Controller logic first and call the Service directly.

Use IDE auto‑completion to generate the missing class and method stubs, marking them with TODO.

After all stubs are created, fill in the business logic based on the TODOs.

This approach helps developers understand the business flow early.

Project Structures and Multi‑Implementation Scenarios

Typical three‑layer structure: Controller → Service → Dao. If multiple implementations are needed, the author presents two approaches:

Introduce a new package with additional Service implementations and configure the desired bean via Spring configuration.

Create a separate Service module (e.g., Service2) with its own implementation package and adjust module dependencies accordingly.

Both methods increase code size, but the second offers clearer modular separation.

To combine the advantages, the author suggests extracting the interface and its implementations into independent modules, then selecting one implementation at build time, allowing the same package structure for both versions.

Drawbacks of Not Using Interfaces

Without interfaces, multi‑implementation becomes harder, IDE assistance is reduced, and developers may need to copy existing code to a new module for new logic.

Conclusion

The author concludes that interfaces are unnecessary for most Service layers when using Spring, except in cases where many implementations are required; in such scenarios, interfaces remain useful.