मुझे जेनरिक के साथ हाइबरनेट डीएओ बनाने के बारे में कुछ ट्यूटोरियल मिले हैं, लेकिन वे सभी SessionFactory के बजाय EntityManager का उपयोग करते हैं। मेरा प्रश्न है कि SessionFactory का उपयोग करके जेनरिक के साथ डीएओ कैसे बनाया जाए। मेरे पास अब तक नीचे है:

इंटरफेस:

public interface GenericDao<T> {

    public void save(T obj);
    public void update(T obj);
    public void delete(T obj);
    public T findById(long id);
}

कक्षा:

@Repository
public class GenericDaoImpl<T> implements GenericDao<T> {

    @Autowired
    private SessionFactory sessionFactory;

    public void save(T obj) {
        Session session = sessionFactory.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();
            session.save(obj);
            tx.commit();
        } catch (HibernateException e) {
            if(tx != null)
                tx.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }

    }

    public void update(T obj) {
        Session session = sessionFactory.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();
            session.update(obj);
            tx.commit();
        } catch (HibernateException e) {
            if(tx != null)
                tx.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }

    }

    public void delete(T obj) {
        Session session = sessionFactory.openSession();
        Transaction tx = null;
        try {
            tx = session.beginTransaction();
            session.delete(obj);
            tx.commit();
        } catch (HibernateException e) {
            if(tx != null)
                tx.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }

    }

    public T findById(long id) {
        // ??
        return null;
    }

मैं अनिश्चित हूं कि जेनेरिक का उपयोग करके findById के बारे में कैसे जाना जाए। मेरा मानना ​​है कि अन्य तरीके सही हैं, लेकिन अगर मैं गलत हूं तो मुझे सुधारें।

साइड प्रश्न: क्या EntityManager का उपयोग करना, SessionFactory के उपयोग से अधिक फायदेमंद है? मैंने इस विषय पर कुछ पोस्ट देखीं, लेकिन कुछ और राय चाहूंगा।

6
Jake Miller 27 जून 2016, 02:44
जावा में, जेनरिक को इरेज़र द्वारा कार्यान्वित किया जाता है और आपका औपचारिक प्रकार पैरामीटर T रन टाइम पर Object बन जाता है। दूसरे शब्दों में, रन टाइम पर T टाइप नहीं होता है। कोई भी सामान्य विधि जो एक नया खनन T इंस्टेंस लौटाती है, उसके लिए एक रन टाइम टाइप टोकन की आवश्यकता होगी, जिसका उपयोग उस प्रकार के इंस्टेंस को प्रतिबिंबित रूप से निर्धारित करने के लिए किया जा सकता है जिसे इसे बनाने की आवश्यकता होगी। इसलिए findById(...) के लिए एक अधिक व्यावहारिक हस्ताक्षर public T findById(Class<T> class, long id) है।
 – 
scottb
27 जून 2016, 03:07
तो क्लास <टी> टोकन का उपयोग यह निर्धारित करने के लिए किया जाएगा कि किस प्रकार की वस्तु को वापस करने की आवश्यकता है? मैं इसके बारे में बिल्कुल कैसे जाउंगा? EntityManager उदाहरणों के साथ, मैंने entityManager.find(type.class, id); देखा, लेकिन मैं इस बारे में अनिश्चित हूं कि इसे SessionFactory के साथ कैसे किया जाए।
 – 
Jake Miller
27 जून 2016, 03:12

1 उत्तर

सबसे बढ़िया उत्तर

आपको उस पद्धति के भीतर से Class<T> तक पहुंच प्राप्त करने की आवश्यकता है। आपके पास दो विकल्प हैं, आप विधि में Class<T> पास कर सकते हैं:

public T findById(long id, Class<T> clazz) {
    // method implementation
}

या आप विधि में उपयोग के लिए कक्षा के निर्माता में Class<T> पास कर सकते हैं:

@Repository
public class GenericDaoImpl<T> implements GenericDao<T> {

    private Class<T> clazz;

    protected GenericDaoImpl(Class<T> clazz) {
        this.clazz = clazz;
    }

    // other methods omitted

    public T findById(long id) {
        // method implementation
    }
}

और उपवर्ग अपनी कक्षा को सुपरक्लास में पास करेंगे:

public class UserDao extends GenericDaoImpl<User> {
    public UserDao() {
        super(User.class);
    }
}

फिर, अपने clazz इंस्टेंस का उपयोग करके आप Session#get विधि:

T entity = session.get(clazz, id);

अधिक जानकारी के लिए निम्नलिखित प्रश्न देखें:


जहां तक ​​​​पक्ष प्रश्न है, EntityManager जेपीए (जावा पर्सिस्टेंस एपीआई) का हिस्सा है। हाइबरनेट एपीआई के बजाय जावा एपीआई विनिर्देश का उपयोग करके अपने एप्लिकेशन को विकसित करना आपके एप्लिकेशन को हाइबरनेट पर निर्भर नहीं होने देता है। यह आपको अपने कोड में बदलाव किए बिना लोकप्रिय जेपीए कार्यान्वयन जैसे हाइबरनेट, ओपनजेपीए, या टॉपलिंक के बीच स्विच करने की अनुमति देता है।

इस प्रश्न में अंतर के बारे में अधिक जानकारी है।

5
Community 23 मई 2017, 13:28
आपको धन्यवाद! एक अन्य पक्ष प्रश्न - क्या EntityManager को SessionFactory से अधिक और इसके विपरीत उपयोग करने का कोई कारण है? या क्या वे दोनों मुख्य रूप से एक ही काम करते हैं?
 – 
Jake Miller
27 जून 2016, 03:18
उस super(User.class); लाइन को जोड़ने की जरूरत नहीं है। सार सामान्य वर्ग अपने बच्चों की कक्षाओं के प्रकार के तर्क का पता लगा सकता है, जैसा कि यहां देखा गया है: github.com/acdcjunior/acdcjunior-github-io-example -प्रोजेक्ट्स/…
 – 
acdcjunior
27 जून 2016, 03:20
1
EntityManager जेपीए है, SessionFactory हाइबरनेट (एक जेपीए कार्यान्वयन) है। ये एक ही चीज नहीं हैं। EntityManager (JPA) को Session (हाइबरनेट) के रूप में EntityManagerFactory (JPA) को SessionFactory (हाइबरनेट) के लिए है। आमतौर पर, हम जेपीए पसंद करते हैं। लेकिन अगर आप कभी भी हाइबरनेट से दूसरे (जैसे टॉपलिंक) में कार्यान्वयन को बदलने की योजना नहीं बनाते हैं, तो इससे कोई फर्क नहीं पड़ता (मेरा मतलब है, इस मामले में, जो कुछ भी आप पसंद करते हैं उसका उपयोग करें)।
 – 
acdcjunior
27 जून 2016, 03:22
@ जेकमिलर, मैंने इसके लिए स्पष्टीकरण के साथ उत्तर संपादित किया है।
 – 
blacktide
27 जून 2016, 03:22
बहुत अच्छा! मैंने इसे इस तरह करने के बारे में कभी नहीं सोचा था।
 – 
blacktide
27 जून 2016, 03:24