जेपीए के लिए एक सामान्य डीएओ बनाना जो मैं

Question

से प्राप्त कर सकता हूं, मैं एक रिपोजिटरी क्लास बनाने की कोशिश कर रहा हूं जिसे मैं मूल सीआरयूडी कार्यक्षमता प्राप्त करने के लिए प्राप्त कर सकता हूं। EntityManager.find (..) को कक्षा तर्क की आवश्यकता है। हालांकि, आप इसे T पास नहीं कर सकते (किसी कारण से मुझे अभी तक समझ में नहीं आता है ... टाइप मिटाएं)। इसलिए मुझे वह विधि मिली जो इकाई वर्ग लौटाती है और मैंने इसे देखा एक और प्रश्न से जोड़ा। सबसे पहले, यह कैसे काम करता है और दूसरा प्रदर्शन पर इसका अधिक असर होगा? मैं इसे प्रतिबिंब का उपयोग करता हूं।

@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]; 
    } 
} 

---

नए दृष्टिकोण:

@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; 
    } 
} 

और

सार्वजनिक वर्ग QuestionSqlRepository फैली AbstractSqlRepository लागू करता QuestionRepository {

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

}

क्या यह एक बुरा दृष्टिकोण है?

Answer 1

यह कहा गया है कि प्रतिबिंब ओवरहेड जोड़ देगा लेकिन आपको मेरी राय में हर बार वस्तु का वर्ग प्राप्त करने की आवश्यकता नहीं है।

बस इसे पहली बार ढूंढें और बाद में शून्य के लिए जांचें, यह एक सुपर क्लास विधि कॉल करने की तुलना में बहुत कम ओवरहेड जोड़ता है।

कन्स्ट्रक्टर पैरामीटर के खिलाफ एकमात्र तर्क यह है कि आपकी कक्षा POJO नहीं होगी।

यहाँ नमूना कोड है:

@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); 
    } 

}