हाइबरनेट - बिडरेक्शनल @OneToOne

Question

मेरे पास 2 कक्षाएं हैं: उपयोगकर्ता और उपयोगकर्ताचित्र जिसमें 1: 1 संबंध है।

public class User { 
    @Id 
    @GeneratedValue(strategy=GenerationType.AUTO) 
    @Column(name="id", nullable = false, unique = true) 
private int id; 

    private String firstname; 

    private String lastname; 

    @OneToOne 
    @JoinColumn(name = "picture") //field named "picture" in the database 
    private UserPicture userPicture; 

    .. 
} 


public class UserPicture { 

    @Id 
    @GeneratedValue(strategy=GenerationType.AUTO) 
    @Column(name="id", nullable = false, unique = true) 
    private int id; 

    private Blob image; 

    @OneToOne 
    @JoinColumn(name = "user") 
    User user; 

UserPicture में 'उपयोगकर्ता लोड किया जाएगा लेकिन उपयोगकर्ता में' userPicture 'नहीं - क्या मैं गलत था?

संपादित जोड़ने कि मैं सिर्फ एक UserPicture बनाने और उन्हें (मौजूदा userId के साथ) को सम्मिलित करने के है - शायद मैं UserPicture में 'उपयोगकर्ता' झरना करने की जरूरत है?

Answer 1

आपको अपनी कक्षाओं को मानचित्र बनाना होगा।

public class User { 
    ... 
    @OneToOne (mappedBy="user") 
    private UserPicture userPicture; 
    ... 
} 

public class UserPicture { 
    ... 
    @OneToOne 
    @JoinColumn (name="user") 
    private User user; 
    ... 
} 

Answer 2

अपने प्रश्न के संबंध में:

(क्योंकि मैं एक टिप्पणी में प्रतिक्रिया करने के लिए पर्याप्त प्रतिष्ठा नहीं है) "सभी स्पष्ट केवल एक प्रश्न अधिक है, यह संभव उपयोगकर्ता आलसी में userPicture बनाने के लिए है ? - user1731299 अक्टूबर 24 '12 पर 10:44 "

हां, यह आलसी लाने के लिए संभव है। हालांकि, बस "fetchType = FetchType.Lazy" काम नहीं करेगा। कारण होने के कारण, हाइबरनेट को यह देखने के लिए शामिल तालिका की जांच करने की आवश्यकता है कि यह शून्य मूल्य है, या यदि वहां कोई रिकॉर्ड है। चूंकि यह वनटोन मैपिंग है, हाइबरनेट आंकड़े बताते हैं कि यह किसी भी डेटा को वापस खींचकर डेटाबेस कॉल को सहेज सकता है, क्योंकि इसे जांचना था कि यह वैसे भी शून्य है या नहीं। यह x-to-many-mappings के मामले में नहीं है, क्योंकि हाइबरनेट जानता है कि 'कई' का मतलब है कि दूसरी तालिका पर प्रतीक्षा करने वाली एक सूची है ... चाहे वह खाली या आबादी वाली सूची हो, यह अभी भी एक सूची है। एक मूल्य के लिए, इसे वास्तविक डेटा और शून्य मूल्य के बीच अंतर करना होगा।

हाइबरनेट को यह बताने का तरीका है कि वहां हमेशा एक मूल्य होगा, और कभी भी शून्य मूल्य नहीं होगा। यह जानकर, हाइबरनेट एक स्थान धारक बना सकता है जब तक कि वह डेटा प्राप्त करने का समय न हो। एनोटेशन में आप इसे करने का तरीका अपने @OneToOne एनोटेशन में "वैकल्पिक = झूठा" जोड़ना है।

हालांकि सावधान रहें! इसके साथ कुछ मुद्दे हैं; जिसमें मैं अभी पता लगाने की कोशिश कर रहा हूं (और मैं यहां आपके प्रश्न में कैसे ठोकर आया)। यह वैकल्पिक = झूठा हाइबरनेट थोड़ा अतिरिक्त सत्यापन करता है और यह हाइबरनेट को भ्रमित करने के लिए प्रतीत होता है कि इसे कैसे सम्मिलित करना चाहिए। तो, आप इस आलसी fetching तकनीक से दूर रहना चाह सकते हैं।

Answer 3

एक से एक में आलसी लोडिंग तब भी काम करता है जब हम JoinColumn एनोटेशन में फ़ील्ड निर्दिष्ट नहीं करते हैं। हालांकि एक द्विपक्षीय वन टू वन में आलसी लोडिंग उस इकाई पर काम नहीं करती है जहां हम mappedBy = '' का उपयोग करते हैं। उदाहरण के लिए यदि हमारे पास दो इकाइयां अनुबंध और सदन हैं, जहां अनुबंध तालिका में सदन के लिए एक विदेशी कुंजी है। जब हम यहां बिडरेक्शनल वनटोन का उपयोग करते हैं और अनुबंध लोड करने का प्रयास करते हैं तो आलसी लोडिंग काम (यानी हाउस उत्सुकता से लोड नहीं होता है) लेकिन जब हम हाउस (हाउस रिपोजिटरी का उपयोग करके) लोड करने का प्रयास करते हैं तो अनुबंध हमेशा उत्सुकता से प्राप्त होता है। क्या किसी के पास कोई विचार है कि ऐसा क्यों होता है?

Public class Contract { 
    ..... 
    @onetoone(lazy) 
    @JoinColumn(name='houseid', nullable=false) 
    Private House house 
    ..... 
} 

Public class House { 
    ..... 
    @onetoone(lazy, mappedBy='house') 
    Private Contract contract 
    ..... 
} 

मैं जानता हूँ कि यह केवल एक आंशिक जवाब है, सह सवाल है। लेकिन यह यहां चर्चा से बहुत संबंधित है।