Do You Really Need Interfaces for Service and DAO Layers in Spring?

Recently I saw the question “Is it necessary to add an interface for every Service and DAO class?” and gave a brief answer: “It depends”.

When using a dependency‑injection framework like Spring, you can omit interfaces.

Why people think interfaces are needed

Allows writing upper‑layer code (e.g., Controller) before lower‑layer logic is implemented.

Spring’s default AOP uses dynamic proxies, which require interfaces.

Enables multiple implementations of a Service.

In practice, these reasons are not convincing.

First reason debunked

Writing code against an interface is useful only when different teams work on separate modules; however most projects are organized by feature, not by layer, so defining an interface for each layer adds unnecessary work.

You can simply write empty methods in the lower layer to satisfy the upper layer.

Second reason debunked

Spring’s default proxy mechanism can be switched to CGLIB, which does not require interfaces.

Third reason debunked

Multiple implementations are rarely needed; when they are, other techniques can replace interfaces.

Typical project structure

Controller

Service

Dao

If multiple implementations are required, you can organize packages like:

Controller

Service (interface package) → impl, impl2

Dao

Two approaches for handling multiple implementations:

Add a new package under Service and configure the new implementation in the DI configuration.

Create a separate Service module with its own package and configure it as the injected bean.

Both approaches increase code size; the second yields clearer module separation.

Combining advantages

Separate the interface and its implementations into an independent module, then adjust packaging so that ServiceImpl and ServiceImpl2 share the same package structure, allowing you to switch between them without changing DI configuration.

If you remove the interface module entirely, you can still have multiple implementations by adjusting module dependencies, but you lose the compile‑time contract and IDE assistance.

Conclusion: Use interfaces only when you truly need multiple implementations; otherwise, they are unnecessary.

Feel free to share your thoughts in the comments.