हाइबरनेट एक ही मेज माता पिता/बच्चे संबंध

Question

मैं एक एकल तालिका में माता-पिता/बच्चे रिश्ता है, मान लें कि के रूप में सरल

रूप

id | parent_id | some_data 

मुझे यह समझाया गया/लागू सर्वोत्तम प्रथाओं कैसे एक के लिए हाइबरनेट कक्षाओं का निर्माण करने की कोशिश कर रहा हूँ चलो टेबल संबंध

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

फ़ीड लगता है कि

{ 
    1: 
     => 2: 
       => 3 
       => 4: 
         => 5 
     => 6 
} 

इस डेटा के रूप में DB में खत्म करना चाहिए:

1 | 0 (main rec, no parent) 
2 | 1 
3 | 2 
4 | 2 
5 | 4 
6 | 1 

और यह गहरे और गहरे जा सकते हैं ...

मैं JSON पार करने के लिए चाहते हैं ढांचे और निर्माण वर्ग जो अंत में मैं डीबी

session.save(parent) 

012 में सहेजता है

अभिभावक मेरे हाइबरनेट मैप किए गए वर्ग का उदाहरण होगा, इसे नाम दें।

हर बार जब मैं एक पेड़ उतरता हूं, तो यह एक नया फ़ीड बनाता है, इसे माता-पिता पाता है और इसे सूची में जोड़ता है।

Feed **parent** = new Feed(); 

    -> Feed child2 = new Feed(); 
     child2.setParent(parent) 
     parent.add(child2); 

     -> Feed child3 = new Feed(); 
      child3.setParent(child2) 
      child2.add(child3); 

      Feed child4 = new Feed(); 
      child4.setParent(child2) 
      child2.add(child4); 

............. 

session.save(**parent**) 

मेरा प्रश्न है कि मैं @ManyToOne और @OneToMany दृष्टिकोण का उपयोग कर सकता हूं?

मैंने @ इनहेरिटेंस (रणनीति = विरासत टाइपिंग .INGLE_TABLE) को भी देखा लेकिन मुझे नहीं लगता कि मैं इसे अपनी समस्या पर लागू कर सकता हूं क्योंकि मैं माता-पिता को नहीं जानता, वे गतिशील हैं। मैं पैरेंट क्लास नहीं बना सकता और इसे बढ़ा सकता था।

तो लब्बोलुआब यह मैं दो समस्याओं

हल करने के लिए कोशिश कर रहा हूँ

1. आसान एक माता पिता के स्तर पर बचाने

2. एक माता पिता से एक पत्ता के लिए डेटा प्राप्त करने के लिए कैसे जब मैं इसकी आवश्यकता

कुछ हाइबरनेट मैप्ड क्लासेस उदाहरण की बहुत सराहना की जाएगी।

Answer 1

सब मुझे क्या करना की जरूरत की तरह लगता है है:

@Entity 
@Table(name = "table_name") 
public class TableName{ 

...... 

@Transient 
private Long parentId; 

...... 

@ManyToOne(fetch = FetchType.LAZY, optional=true) 
@JoinColumn(name="parent_id") 
private TableName parent; 

@OneToMany(mappedBy="parent", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval=true) 
private Set<TableName> children = new HashSet<TableName>(); 

से बस

TableName papa = new TableName(); 
papa.setParent(null); // parent 

    TableName kid1 = new TableName(); 
    kid1.setParent(papa); 
    papa.getChildren().add(kid1); 

     TableName kid1_1 = new TableName(); 
     kid1_1.setParent(kid1); 
     kid1.getChildren().add(kid1_1); 

    TableName kid2 = new TableName(); 
    kid2.setParent(papa); 
    papa.getChildren().add(kid2); 


session.save(papa) 

Answer 2

क्यों आप कैस्केड = सभी को रखने वाले कई संबंधों में स्वयं को संदर्भित नहीं करते हैं। तो अलग-अलग बच्चे वस्तुओं को अलग से सहेजा नहीं जाना चाहिए। केवल माता-पिता को बचाने के लिए पर्याप्त है। उदाहरण के लिए।

Adding a one to many relationship to a self reference parent/child