Spring boot don't let me create a repository without database

Question

I've created a project on Spring Boot.

I've two providers extending the same Abstract provider, and i load on startup the one i'm interested in via Spring Profile.

One of the providers is based on JPA, the other have his interface implemented where i make calls to webservices.

This is the interface of the provider wich i don't want to use databases:

package net.worldline.mst.metro.ds.core.massilia.provider;


import net.worldline.mst.metro.ds.core.contract.IProductRepository;
import net.worldline.mst.metro.ds.core.massilia.model.MassiliaProduct;
import org.springframework.context.annotation.Profile;
import org.springframework.data.repository.NoRepositoryBean;

@Profile("massilia")
@NoRepositoryBean
public interface MassiliaProductRepository extends IProductRepository<MassiliaProduct,String> {

}

And this is the interface for the provider using database :

package net.worldline.mst.metro.ds.core.local.provider;


import net.worldline.mst.metro.ds.core.contract.IProductRepository;
import net.worldline.mst.metro.ds.core.local.model.Product;
import org.springframework.context.annotation.Profile;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

import org.springframework.stereotype.Repository;
@Profile("local")
@Repository
public interface MonBoProductRepository extends IProductRepository<Product,String> {

    @Query("select p.variants from Product p where p.ean = :ean")
    List<Product> findVariantByEan(@Param("ean") String ean);

    @Query("select p.companions from Product p where p.ean = :ean")
    List<Product> findCompanionByEan(@Param("ean") String ean);

}

They extend this interface in common :

package net.worldline.mst.metro.ds.core.contract;

import net.worldline.mst.metro.ds.core.model.AbstractProduct;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.query.Param;
import org.springframework.data.rest.core.annotation.RestResource;
import org.springframework.web.bind.annotation.PathVariable;

import java.io.Serializable;
import java.util.List;
import org.springframework.http.HttpEntity;
import org.springframework.web.bind.annotation.PathVariable;

import java.io.Serializable;
import java.util.List;


@NoRepositoryBean
public interface IProductRepository<T extends AbstractProduct,ID extends Serializable> extends CrudRepository<T, ID> {
    @RestResource(path = "byEAN")
    T findByEan(@Param("ref") Integer ean);

    T findProductByEan(@PathVariable ID ean);

    List<T> findVariantByEan(@PathVariable ID ean);

    List<T> findCompanionByEan(@PathVariable ID ean);
}

The provider wich isn't using database have an implementation, for job reasons, i can't show you the implementation, but it calls inside webservices

Like my providers, i've two models, extending the same abstract class.

One is annoted with @Entity,@Id and co, and i don't want to add this annotations on the other class, because for me, i've precised that i didn't want any database by asking none in the application-${profile}.properties.

This is this Model i used with the bdd :

package net.worldline.mst.metro.ds.core.local.model;

import net.worldline.mst.metro.ds.core.model.AbstractProduct;
import net.worldline.mst.metro.ds.core.model.AbstractProductCharacteristic;
import org.hibernate.validator.constraints.NotEmpty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;

import javax.persistence.*;
import java.util.List;



@Entity
@Table(name = "PRODUCTS")
@Profile("local")
public class Product extends AbstractProduct {

    private static final Logger log = LoggerFactory.getLogger(Product.class);

    @ManyToMany(
            fetch = FetchType.LAZY
    )
    @JoinTable(
            name="products_to_variants",
            joinColumns = @JoinColumn(name="productEan"),
            inverseJoinColumns = @JoinColumn(name="productEanVariant")
    )
    private List<Product> variants;

    @ManyToMany(
            fetch = FetchType.LAZY
    )
    @JoinTable(
            name="products_to_companions",
            joinColumns = @JoinColumn(name="productEan"),
            inverseJoinColumns = @JoinColumn(name="productEanCompanion")
    )
    private List<Product> companions;

    @Column(name = "accroche")
    private String accroche;


    @Id
    @Column(name = "ean", unique = false)
    private String ean;

    @Column(name = "descriptif")
    private String descriptif;

    @Column(name = "libelle")
    @NotEmpty
    private String libelle;

    @Column(name = "oldPrice")
    private String oldPrice;

    @Column(name = "price")
    @NotEmpty
    //@Digits(fraction = 0, integer = 10)
    private String price;

    @Column(name = "stock")
    private String stock;

    @OneToMany(mappedBy = "ean" )
    protected List<ProductCharacteristic> characteristics;

    @OneToMany(mappedBy = "product" )
    @NotEmpty
    protected List<ProductVisual> visuals;

    public List<Product> getVariants() {
        return variants;
    }

    public void setVariants(List<Product> variants) {
        this.variants = variants;
    }

    public List<Product> getCompanions() {
        return companions;
    }

    public void setCompanions(List<Product> companions) {
        this.companions = companions;
    }

    @Override
    public String getAccroche() {
        return accroche;
    }

    @Override
    public void setAccroche(String accroche) {
        this.accroche = accroche;
    }


    @Override
    public String getEan() {
        return ean;
    }

    public void setRef(String ean) {
        this.ean = ean;
    }

    @Override
    public String getLibelle() {
        return libelle;
    }

    @Override
    public void setLibelle(String libelle) {
        this.libelle = libelle;
    }

    @Override
    public String getOldPrice() {
        return oldPrice;
    }

    @Override
    public void setOldPrice(String oldPrice) {
        this.oldPrice = oldPrice;
    }

    @Override
    public String getPrice() {
        return price;
    }

    @Override
    public void setPrice(String price) {
        this.price = price;
    }

    @Override
    public String getStock() {
        return stock;
    }

    @Override
    public void setStock(String stock) {
        this.stock = stock;
    }

    @Override
    public List<? extends AbstractProductCharacteristic> getCharacteristics() {
        return characteristics;
    }

    @Override
    public List<ProductVisual> getVisuals() {
        return visuals;
    }

    public String getDescriptif() {
        return this.descriptif;
    }

    public void setDescriptif(String descriptif) {
        this.descriptif=descriptif;
    }
}

This is the model i don't want to use with a database:

package net.worldline.mst.metro.ds.core.massilia.model;


import net.worldline.mst.metro.ds.core.model.AbstractProduct;
import org.springframework.context.annotation.Profile;

import javax.persistence.*;
import java.util.List;


@Profile("massilia")
public class MassiliaProduct extends AbstractProduct {

    @Override
    public String getEan() { return this.ean; }

    @Override
    public String getLibelle() { return this.libelle; }

    @Override
    public String getPrice() { return this.price; }

    @Override
    public String getAccroche() { return this.accroche; }

    @Override
    public String getOldPrice() { return oldPrice; }

    @Override
    public String getStock() { return stock; }

    @Override
    public String getDescriptif() {
        return descriptif;
    }

    @Override
    public List<MassiliaCharacteristic> getCharacteristics() {
        return (List<MassiliaCharacteristic>)characteristics;
    }

    @Override
    public List<MassiliaProductVisual> getVisuals() {
        return (List<MassiliaProductVisual>)visuals;
    }

}

They share this model in common :

package net.worldline.mst.metro.ds.core.model;

import org.springframework.hateoas.ResourceSupport;
import org.springframework.hateoas.core.Relation;

import java.util.List;



@Relation(value = "product", collectionRelation = "product")

public abstract class AbstractProduct extends ResourceSupport {

    protected String ean;

    protected String libelle;

    protected String accroche;

    protected String price;

    protected String oldPrice;

    protected String stock;

    protected String descriptif;

    protected List<? extends AbstractProductCharacteristic> characteristics;

    protected List<? extends AbstractProductVisual> visuals;

    public abstract  String getEan();

    public abstract String getLibelle();

    public abstract String getPrice();

    public abstract String getAccroche();

    public abstract String getOldPrice();

    public abstract String getStock();

    public abstract List<? extends AbstractProductCharacteristic> getCharacteristics();

    public abstract List<? extends AbstractProductVisual> getVisuals();

    public abstract String getDescriptif();

    public void setEan(String ean) {
        this.ean = ean;
    }

    public void setLibelle(String libelle) {
        this.libelle = libelle;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    public void setAccroche(String accroche) {
        this.accroche = accroche;
    }

    public void setOldPrice(String oldPrice) {
        this.oldPrice = oldPrice;
    }

    public void setStock(String stock) {
        this.stock = stock;
    }

    public void setCharacteristics(List<? extends AbstractProductCharacteristic> characteristics) {
        this.characteristics = characteristics;
    }

    public void setVisuals(List<? extends AbstractProductVisual> visuals) {
        this.visuals = visuals;
    }

    public void setDescriptif(String descriptif) {
        this.descriptif = descriptif;
    }


}

In the application-${profile}.properties, i precise :

spring.datasource.platform = hsqldb for the jpa instance.

spring.datasource.platform = none for the instance where i call my webservices.

My problem is simple : i was hoping spring letting me do what i want by implementing the repository, but when i launch my server, spring say that my objects are not managed, so if i don't add @Entity to my model, it doesn't want to run.

So why Spring data looks like it loads JPA repository by default ?

Answer 1

It was a human error in fact.

I'v forgotten a spring.datasource.platform = hsqldb in my application.properties file.

I wasn't looking at it cause i'm using spring profiles so i was looking at my application-massilia.properties wich contains spring.datasource.platform = none and is listened now cause i've deleted the duplicate in the other file.