Tworzenie ogólnego DAO dla JPA, które można dziedziczyć po

Question

Próbuję utworzyć klasę repozytorium, z której mogę dziedziczyć, aby uzyskać podstawową funkcjonalność CRUD. EntityManager.find (..) potrzebuje argumentu Class. Jednak nie możesz przekazać do niego T (Z jakiegoś powodu nie rozumiem jeszcze ... typ wymazania). Tak więc znalazłem metodę, która zwraca klasę encji i dodała ją z innego pytania, które zobaczyłem. Po pierwsze, jak to działa, a po drugie czy ma duży wpływ na performance? Widzę, że używa refleksji.

@Stateless 
public abstract class AbstractSqlRepository<T> implements Repository<T> { 

    @PersistenceContext 
    private EntityManager entityManager; 

    @Override 
    public void create(T entity) { 
     entityManager.persist(entity); 
    } 

    @Override 
    public T find(int id) { 
     return entityManager.find(getEntityClass(), id); 
    } 

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

    @Override 
    public void remove(T entity) { 
     entityManager.remove(entity); 
    } 

    public EntityManager getEntityManager() { 
     return entityManager; 
    } 

    public Class<T> getEntityClass() { 
     ParameterizedType genericSuperclass = (ParameterizedType) getClass().getGenericSuperclass(); 

     return (Class<T>) genericSuperclass.getActualTypeArguments()[0]; 
    } 
} 

---

Nowe podejście:

@Stateless 
public abstract class AbstractSqlRepository<T> implements Repository<T> { 

    @PersistenceContext 
    private EntityManager entityManager; 
    private Class<T> clazz; 

    public AbstractSqlRepository(Class<T> clazz) { 
     this.clazz = clazz; 
    } 

    @Override 
    public void create(T entity) { 
     entityManager.persist(entity); 
    } 

    @Override 
    public T find(int id) { 
     return entityManager.find(clazz, id); 
    } 

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

    @Override 
    public void remove(T entity) { 
     entityManager.remove(entity); 
    } 

    public EntityManager getEntityManager() { 
     return entityManager; 
    } 
} 

i

public class QuestionSqlRepository rozciąga AbstractSqlRepository realizuje QuestionRepository {

public QuestionSqlRepository() { 
    super(Question.class); 
} 

}

Czy to złe podejście?

Answer 1

Podkreślono, że odbicie doda wartość nad głową, ale nie zawsze trzeba mieć klasę obiektu za każdym razem, moim zdaniem.

Po prostu znajdź go za pierwszym razem i sprawdź po nim wartość zerową, to dodaje bardzo niewiele narzutów w porównaniu do wywołania metody super klasy.

Jedynym argumentem przeciwko parametrowi konstruktor jest to, że twoja klasa nie będzie POJO.

Oto przykładowy kod:

@SuppressWarnings("unchecked") 
public class HibernateBaseDao<T, Pk extends Serializable> implements Dao<Pk, T> { 

    // ... 
    private Class<T> type; 

    // ... 

    public Class<T> getType() { 

     if (this.type == null) { 

      ParameterizedType parameterizedType = (ParameterizedType) (this 
        .getClass().getGenericSuperclass()); 

      while (!(parameterizedType instanceof ParameterizedType)) { 
       parameterizedType = (ParameterizedType) parameterizedType 
         .getClass().getGenericSuperclass(); 
      } 

      this.type = (Class<T>) parameterizedType.getActualTypeArguments()[0]; 

     } 

     return this.type; 
    } 

    @Override 
    public T load(Pk id) { 

     return (T) this.sessionFactory.getCurrentSession().load(this.getType(), 
       id); 
    } 

    @Override 
    public T get(Pk id) { 
     return (T) this.sessionFactory.getCurrentSession().get(this.getType(), 
       id); 
    } 

}