Modèle de conception de référentiel - devrait-il y avoir un repo pour chaque Dao?

Question

J'ai quelques DAO dans mon application qui accèdent à une base de données pour les opérations CRUD. Disons là Nouvelles, météo et sport DAO. Donc, je suis confus sur le nombre de dépôts dont j'ai besoin. devrais-je juste utiliser un dépôt dire DataRepository et laissez-moi tenir ma base de données et tous les dao. et encapsuler des méthodes pour les opérations CRUD en elle? ou chaque DAO devrait-il avoir son propre référentiel?

Je veux dire qu'un référentiel doit renvoyer uniquement les objets de données que la couche appelante comprend. donc c'est comme une encapsulation sur les DAOs mais je ne suis pas sûr si je devrais en créer un par DAO ou juste avoir un repo par application, etc.

Si vous lisez ceci article nous commençons à comprendre que le modèle est sur-machiné ou plus distrait. C'est devenu un détail caché par rapport à la minimisation des requêtes.

Mais il semble qu'il y ait une prise en pension par DAO que l'interface elle-même ressemble à ceci:

interface Repository<T> { 
void add(T item); 
void remove(Specification specification); 
List<T> query(Specification specification); 

}

où T peut être le type/table de données DAO accès. Juste besoin d'une clarification maintenant. Pouvez-vous imaginer que j'ai 30 types différents, alors j'ai besoin de 30 implémentations Repo différentes. c'est ridicule. Il semble que le modèle de dépôt lui-même ressemble à un DAO, pas différent. Je suis si confus.

Answer 1

Je ne suis pas sûr que ce soit ce que tout ce que vous cherchez, mais dans ma demande, je me sers décrit DAO modèle avec Spring

Alors im confus sur combien Référentiels je aurais besoin.

à mon humble avis, vous aurez besoin d'au moins un référentiel unique pour chaque entité car ils conduisent à une conception simple mais puisque vous les faites génériques et ils sont dans la hiérarchie, peut être utilisé simplement avec des classes d'enfants/interfaces

Ci-dessous l'exemple

Interface pour définir toutes les méthodes de base qui utilisent couramment pour

public interface GenericDAO<T, ID extends Serializable> { 


    T findById(ID id, LockModeType lock); 

    void save(T entity); 

    T update(T entity); 

    List<T> findAll(); 
} 

mise en œuvre générique

public abstract class GenericDAOImpl<T, ID extends Serializable> implements GenericDAO<T, ID> { 

    @PersistenceContext 
    protected EntityManager em; 

    private final Class<T> entityClass; 

    public GenericDAOImpl(Class<T> entityClass) { 
     this.entityClass = entityClass; 
    } 

    @Override 
    public T findById(ID id, LockModeType lock) { 
     return em.find(entityClass, id, lock); 
    } 

    @Override 
    public void save(T entity) { 
     em.persist(entity); 

    } 

    @Override 
    public T update(T entity) { 
     return em.merge(entity); 
    } 

    @Override 
    public List<T> findAll() { 
     CriteriaQuery<T> c = em.getCriteriaBuilder().createQuery(entityClass); 
     c.select(c.from(entityClass)); 
     return em.createQuery(c).getResultList(); 
    } 
. 
. 
. 
} 

Foo classe

@Entity 
public class Foo implements Serializable { 

    private static final long serialVersionUID = 1L; 
    private Long id; 
    private String text; 
} 

Foo Repositiry

public interface FooRepositiry extends GenericDAO<Foo, Long> { 

    Foo findTextById(Long id); 

} 

Mis en œuvre Foo Repositiry

@Transactional 
@Repository 
public class FooRepoImpl extends GenericDAOImpl<Foo, Long> implements FooRepositiry { 

    public FooRepoImpl() { 
     super(Foo.class); 
    } 

    @Override 
    public Foo findTextById(Long id) { 
     CriteriaQuery<Foo> c = em.getCriteriaBuilder().createQuery(Foo.class); 
     // . 
     // . 
     // . 
     return em.createQuery(c).getSingleResult(); 
    } 

} 

même pour la classe Bar

@Transactional 
@Repository 
public class BarRepoImpl extends GenericDAOImpl<Bar, Long> implements BarRepo { 

    public BarRepoImpl() { 
     super(Bar.class); 
    } 

    @Override 
    public List<Bar> findAllBarWithText(String text) { 
     CriteriaQuery<Bar> c = em.getCriteriaBuilder().createQuery(Bar.class); 
     return em.createQuery(c).getResultList(); 
    } 
} 

Ici, cette implémentation générique nécessite deux choses pour fonctionner: un EntityManager et une classe d'entité . Une sous-classe doit fournir la classe d'entité en tant qu'argument de constructeur. EntityManager est fourni en utilisant PersistenceContext ou vous pouvez utiliser getter-setter méthodes pour le même.Puisque GenericDAOImpl est abstrait, vous ne pouvez pas l'utiliser directement, mais indirectement et la plupart des méthodes utilisées sont génériques et hiérarchisées, ce qui en fait un candidat idéal pour être réutilisé.

Vous pouvez en savoir plus sur ce livre de Java Persistence with Hibernate 2nd Edition