Should I use a layer between service and repository for a clean architecture - Spring

Question

I'm working in an architecture, it is going to offer a rest api for web client and mobile apps. I'm using Spring(spring mvc, spring data jpa, ...etc). The domain model is coded with JPA specification.

I'm trying to apply some concepts of clean architecture (https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.html). Not all, because I'm going to keep the jpa domain model.

The actual flow through the layers is this:

Front end <--> API Service -> Service -> Repository -> DB

• Front end: web client, mobile apps
• API Service: Rest Controllers, here I use converters and dto's and call services
• Service: Interfaces with implementations and they contain business logic
• Repository: Repository interfaces with automatically implementations(done by spring data jpa) which contatin CRUD operations and maybe some sql queries

My doubt: Should I use an extra layer between service and repository?

I'm planning this new flow:

Front end <--> API Service -> Service -> Persistence -> Repository -> DB

Why to use this persistence layer? As it says in the clean architecture article I would like to have a service implementation(business logic or use case) that access an agnostic persistence layer. And not changes will be needed if I decide to use another "data access" pattern, for example if I decide to stop using repository.

class ProductServiceImpl implements ProductService {
    ProductRepository productRepository;
    void save(Product product) {
        // do business logic
        productRepository.save(product)
    }
}

So I'm thinking use a persistence layer like this:

class ProductServiceImpl implements ProductService {
    ProductPersistence productPersistence;
    void save(Product product) {
        // do business logic
        productPersistence.save(product)
    }
}

and implementation of the persistence layer like this:

class ProductPersistenceImpl implements ProductPersistence {
    ProductRepository productRepository;
    void save(Product product) {
        productRepository.save(product)
    }
}

So I only need to change the implementations of persistence layer, left the service without changes.Coupled with the fact that the Repository is related with the framework.

What do you think? Thanks.

Answer 1

Front end <--> API Service -> Service -> Repository -> DB

Right. This's, essentially, the design by layers proposed by Spring Framework. So you are in the "Spring's right way".

Despite Repositories, these are frequently used as DAOs, the truth is that Spring developers took the notion of Repository from Eric Evans' DDD. Repository interfaces will look often very similar to DAOs because of the CRUD methods and because many developers strive to make repositories' interfaces so generics that, in the end, they have no difference with the EntityManager (the true DAO here)¹. Repositories tho add other abstractions like queries or criteria to enhance the data access.

Translated into Spring components, your design is similar to

@RestController > @Service > @Repository >  EntityManager

The Repository is already an abstraction in between services and data stores. When we extend Spring Data JPA repository interfaces, we are implementing this design implicitly. When we do this, we are paying a tax: a tight coupling with Spring's components. Additionally, we break LoD and YAGNI by inheriting several methods we might not need or wish not to have. Moreover, we are (implicitly) assuming that the persistence data model is also the domain data model. This is quite the endemic of Spring, after many years working with Spring frameworks, you end up making everything data-centric.

That said, extending Spring Data JPA repositories is not mandatory. We implement a more plain and custom hierarchy of classes.

    @Repository
    public class DBRepository implements MyRepository{
        private EntityManager em;
        
        @Autowire
        public MyRepository (EntityManager em){    
             this.em = em;
        }

        //Interface implentation
        //...
    }

Changing the data source now just takes a new implementation which replaces the EntityManager with a different data source.

    //@RestController > @Service > @Repository >  RestTemplate

    @Repository
    public class WebRepository implements MyRepository{
        private RestTemplate rt;
    
        @Autowire 
        public WebRepository (RestTemplate rt){    
             this.rt = rt;
        }

        //Interface implentation
        //...
    }

    //@RestController > @Service > @Repository >  File

    @Repository
    public class FileRepository implements MyRepository{
       
        private File file; 
        public FileRepository (File file){    
            this.file = file;
        }

        //Interface implentation
        //...
    }

    //@RestController > @Service > @Repository >  SoapWSClient

    @Repository
    public class WSRepository implements MyRepository{
       
        private MyWebServiceClient wsClient; 

        @Autowire
        public WSRepository (MyWebServiceClient  wsClient){    
               this.wsClient = wsClient;
        }

        //Interface implentation
        //...
    }

and so on.²

Back to the question, I don't think you need more layers. The layer you propose is going to end up as a proxy in between services and repositories or as a pseudo-service-repository where to place code you are not sure whether it belongs to the business or to the persistence.

---

^{1: Unlike many developers think, repository interfaces can be totally different from each other because each repository serves different domain needs. In Spring Data JPA, the role DAO is played by the EntityManager. It manages the sessions, the access to the DataSource, mappings, etc.}

^{2: A similar solution is enhancing Spring's repository interfaces mixing them up with custom interfaces. For more info, look for BaseRepositoryFactoryBean and @NoRepositoryBean. However, I have found this approach cumbersome and confusing.}

Answer 2

The best way to prove that a design is flexible is to flex it.

You want a place in your code that is responsible for persistence but is not tied to the idea of using a repository. Fine. It's not doing anything useful at the moment... sigh, fine.

OK, lets test if this shunt layer did any good. Create a flat file layer that will persist your products in files. Now where does this new layer go in this design?

Well it should be able to go where DB is. After all we don't need DB anymore since we're using flat files. But this was also supposed to not need repository.

Consider, maybe repository is an implementation detail. After all I can talk to the DB without using the repository pattern.

Front end <--> API Service -> Service -> Repository -> DB

Front end <--> API Service -> Service -> Repository -> Files

Front end <--> API Service -> Service -> Persistence -> DB

Front end <--> API Service -> Service -> Persistence -> Files

If you can make all that work without touching Service you have flexible code.

But don't take my word for it. Write it and see what happens. The only code I trust to be flexible is flexed code.

Answer 3

I would like to add a comment on the particular case of Spring Data.

UML Solution of Laiv and candied_orange

The solutions and arguments provided by the two authors are correct. I would just like to get into the particular case of Spring Data.

@Repository
public class DBRepository implements MyRepository{
    @Autowired
    private EntityManager em;

    public void create(Product product) {
         em.save(product)
    }
}

Use of Spring Data

Product and ProductEntityJPA

But, in reality we have to use two entity :

• One for the domain entity Product
• One for the database entity ProductEntityJPA

As a result, the EntityManager class doesn't longer takes a Product but an ProductEntityJPA.

JPARepository interface

JPARepository interface provide all the necessary methods for the database management : save(), findAll(), etc ...
As result, we don't have to create you own method in DBRepository

Solutions

Solution #1

Why isn't it the best :

• We need to implement all JPARepository methods in DBRepository

Solution #2

We therefore prefer to use the methods of the JPARepository directly rather than reimplementing them.

Why isn't it the best :

• Our application core is aware of the use of the JPA library. And we want to avoid this !!

Solution #3 - add a new layer

public class DBRepository implements MyRepository{
    @Autowired
    private ProductJPARepository jpaRepository;

    public void create(Product product) {
         jpaRepository.save( transform(product) );
    }

    private ProductEntityJPA transform(Product product) {
        return new ProductJpaEntity( product.getX(), ...);
    }
}

Why it's a good solution:

• We take advantage of the JPARepository interface so we don't have to reimplements all methods
• The core is not aware of the use of JPA.

Conclusion

• We add a new layer that is an Adapter

Conclusion

In the case of Spring Data :

• We want to have two distinct entities Product and ProductEntityJPA.

• We want to take advantage of the JPARepository interface.

• Solution #1 forces us to redefine all methods

• Solution #2 is aware of the use of JPA

• Solution #3 allows not to redefine all methods and not to be aware of JPA.

=> So the use of an intermediate layer seems necessary in Spring Data.

Finally, I change the name of the classes to match the class name in the Clean Architecure diagram.