How to avoid Spring Repository<T, ID> to leak persistence information into service tier-CodePudding

I'm using spring-data-mongodb at the moment so this question is primarily in context of MongoDB but I suspect my question applies to repository code in general.

Out of the box when using a MongoRepository<T, ID> interface (or any other Repository<T, ID> descendent) the entity type T is expected to be the document type (the type that defines the document schema).

As a result injecting such a repository into service component means this repository is leaking database schema information into the service tier (highly pseudo) :

class MyModel {
    UUID id;
}

@Document
class MyDocument {
    @Id
    String id;
}

interface MyRepository extends MongoRepository<MyDocument, String> {
}

class MyService {
    MyRepository repository;

    MyModel getById(UUID id) {
        var documentId = convert(id, ...);
        var matchingDocument = repository.findById(documentId).orElse(...);
        var model = convert(matchignDocument, ...);

        return model;
    }
}

Whilst ideally I'd want to do this :

class MyModel {
    UUID id;
}

@Document
class MyDocument {
    @Id
    String id;
}

@Configuration
class MyMagicConversionConfig {
    ...
}

class MyDocumentToModelConverter implements Converter<MyModel, MyDocument> {
   ...
}

class MyModelToDocumentConverter implements Converter<MyDocument, MyModel> {
   ...
}

// Note that the model and the model's ID type are used in the repository declaration
interface MyRepository extends MongoRepository<MyModel, UUID> {
}

class MyService {
    MyRepository repository;

    MyModel getById(UUID id) {
        // Repository now returns the model because it was converted upstream
        // by the mongo persistence layer.
        var matchingModel = repository.findById(documentId).orElse(...);

        return matchingModel ;
    }
}

Defining this conversion once seems significantly more practical than having to consistently do it throughout your service code so I suspect I'm just missing something.

But of course this requires some way to inform the mongo mapping layer to be aware of what conversion has to be applied to move between MyModel and MyDocument and to use the latter for it's actual source of mapping metadata (e.g. @Document, @Id, etc.).

I've been fiddling with custom converters but I just can't seem to make the MongoDB mapping component do the above.

My two questions are :

Is it currently possible to define custom converters or implement callbacks that allow me to define and implement this model <-> document conversion once and abstract it away from my service tier.
If not, what is the idiomatic way to approach cleaning this up such that the service layer can stay blissfully unaware of how or with what schema an entity is persisted? A lot of Spring Boot codebases appear to be fine with using the type that defines the database schema as their model but that seems supoptimal. Suggestions welcome!

Thanks!

CodePudding user response：

I think you're blowing things a bit out of proportion. The service layer is not aware of the schema. It is aware of the types returned by the repository. How the properties of those are mapped onto the schema, depends on the object-document mapping. This, by default, uses the property name, as that's the most straightforward thing to do. That translation can either be customized using annotations on the document type or by registering a FieldNamingStrategy with Spring Data MongoDB.

Spring Data MongoDB's object-document mapping subsystem provides a lot of customization hooks that allows transforming arbitrary MongoDB documents into entities. The types which the repositories return are your domain objects that - again, only by default - are mapped onto a MongoDB document 1:1, simply because that's the most reasonable thing to do in the first place.

If really in doubt, you can manually implement repository methods individually that allow you to use the MongoTemplate API that allows you to explicitly define the type, the data should be projected into.

CodePudding user response：

You can use something like MapStruct or write your own Singleton Mapper. Then create default methods in your repository:

interface DogRepository extends MongoRepository<DogDocument, String> {
    DogDocument findById(String id);
    default DogModel dogById(String id) {
        return DogMapper.INSTANCE.toModel(
            findById(id)
        );
    }
}