finden Sie die id in spring data jpa-Base-Repository

Ich versuche, die Implementierung eines generischen findByIdsIn Methode in der BaseRepository meiner Spring Data JPA-Klasse, so dass die Funktionalität verwendet werden kann, durch alle Klassen, implementieren diese Schnittstelle.
Ich bin ziemlich neu in Spring Data JPA, also bin ich nicht sicher, ob das möglich ist und wie es zu implementieren.

Hier der code, den ich habe, so weit. Die findByIdsIn ist die Funktionalität, die ich möchte zu implementieren. 

import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.Repository;

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

@NoRepositoryBean
public interface BaseRepository<T, ID extends Serializable> extends Repository<T, ID> {
    List<T> findAll( );
    Optional<T> findById(ID id);
    List<T> findByIdsIn(List<ID> ids); //This is the functionality I'd like to implement.
}

Habt Ihr irgendwelche Vorschläge?
Vielen Dank!

InformationsquelleAutor Jimmy | 2017-12-08
  1. 1

    Ich habe gerade eine Lösung gefunden, ich bin zufrieden mit:

    @NoRepositoryBean
public interface BaseRepository<T, ID extends Serializable> extends Repository<T, ID> {
    List<T> findAll( );
    Optional<T> findById(ID id);
    @Query("SELECT t FROM #{#entityName} t WHERE t.id IN :ids")
    List<T> findByIdsIn(@Param("ids") List<ID> ids);
}

    Ich bin gerne für andere Menschen zu tragen, wenn gibt es elegantere Lösungen, aber.

    • wäre es nicht eine Registrierung erforderlich, die BaseRepository mit JPA?
    • kannst du bitte akzeptieren Sie die Antwort auf diese Frage.
    InformationsquelleAutor Jimmy
  2. 0

    Standardmäßig SimpleJpaRepository ist der Implementierungen für grundlegende repository-Operationen. Sie implementieren sollten, und schreiben eine Klasse, die sich SimpleJpaRepository. Als generischen Typen, die zu dieser Implementierung zwei Arten von parameter wie übergeben werden, die in der Schnittstelle SimpleJpaRepository. Unten ist ein Beispiel der Umsetzung Ihrer Anforderung:

    import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import java.io.Serializable;
import java.util.Optional;

public class BaseRepositoryImpl <T, ID extends Serializable>
        extends SimpleJpaRepository<T, ID>  implements BaseRepository<T, ID> {

    private final EntityManager entityManager;

    public BaseRepositoryImpl(Class<T> domainClass, EntityManager entityManager) {
        super(domainClass, entityManager);
        this.entityManager = entityManager;
    }

    @Override
   public  List<T> findByIdsIn(List<ID> ids) {
        List<T> entities = entityManager.createQuery(
        "FROM"+this.getDomainClass()+" WHERE id IN ("+CommonUtils.concat(ids,',')+")").getResultList(); //concatenation code is not tested hence u need to fix it 
        return entities;
    }
}

    Außerdem benötigen Sie zum überschreiben der default-Implementierung, d.h.
    SimpleJpaRepository mit Ihrer Implementierung, d.h. BaseRepositoryImpl

    import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.support.JpaRepositoryFactory;
import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;
import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.core.support.RepositoryFactorySupport;

import javax.persistence.EntityManager;
import java.io.Serializable;

public class BaseRepositoryFactoryBean<R extends JpaRepository<T, I>, T,
        I extends Serializable> extends JpaRepositoryFactoryBean<R, T, I> {

    @Override
    protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
        return new BaseRepositoryFactory(entityManager);
    }

    private static class BaseRepositoryFactory<T, I extends Serializable>
            extends JpaRepositoryFactory {

        private final EntityManager entityManager;

        public BaseRepositoryFactory(EntityManager entityManager) {
            super(entityManager);
            this.entityManager = entityManager;
        }

        @Override
        protected Object getTargetRepository(RepositoryMetadata metadata) {
            return new BaseRepositoryImpl<T, I>((Class<T>) metadata.getDomainType(), entityManager);
        }

        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return BaseRepositoryImpl.class;
        }
    }
}

    Schließlich konfigurieren Sie Ihre BaseRepositoryFactoryBean im Frühjahr Konfiguration mit @EnableJpaRepositories Anmerkungen und Angabe Ihrer Klasse als unten. Dies wird Ihnen sagen, JPA, die RepositoryFactoryBean zu rufen, und die wiederum sagen, die JPA-repository zu verwenden, während, und initialisieren Sie es mit Ihrer Umsetzung mit seiner Impl-Klasse.

    @EnableJpaRepositories(basePackages = {"com.test.jpa.custom.repository"},
        repositoryFactoryBeanClass = BaseRepositoryFactoryBean.class)
class Configuration{}

    Nun könnten Sie BaseRepository und findByIdsIn verfügbar sein wird für den Einsatz in Ihrer Anwendung.

    • Ich habe versucht, genügend code, um Ihnen helfen, erstellen Sie ein benutzerdefiniertes repository. Aber es sollte einige nützliche links zu, die im detail erklären, warum Sie so viele Schritte benötigt
    • wer downvoted, können Sie bitte helfen mir zu verstehen, das Problem mit diesem Beitrag.
    InformationsquelleAutor Vinay Prajapati
Schreibe einen Kommentar