java - जेपीए जॉइन कॉलम बनाम मैप किया गया




hibernate jpa (3)

के बीच क्या अंतर है:

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL , fetch = FetchType.LAZY)
    @JoinColumn(name = "companyIdRef", referencedColumnName = "companyId")
    private List<Branch> branches;
    ...
}

तथा

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL , fetch = FetchType.LAZY, mappedBy = "companyIdRef")
    private List<Branch> branches;
    ...
}

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

विशेष रूप से, प्रश्न में कोड के लिए सही एनोटेशन इस तरह दिखेगा:

@Entity
public class Company {
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "company")
    private List<Branch> branches;
}

@Entity
public class Branch {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "companyId")
    private Company company;
}

एनोटेशन मैप किए गए आदर्श रूप से हमेशा द्वि दिशात्मक संबंधों के अभिभावक पक्ष (कंपनी वर्ग) में उपयोग किया जाना चाहिए, इस मामले में यह बाल वर्ग (शाखा वर्ग) के सदस्य चर 'कंपनी' को इंगित करने वाली कंपनी कक्षा में होना चाहिए।

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

नीचे काम कर रहा उदाहरण है:

अभिभावक वर्ग, कंपनी

@Entity
public class Company {


    private int companyId;
    private String companyName;
    private List<Branch> branches;

    @Id
    @GeneratedValue
    @Column(name="COMPANY_ID")
    public int getCompanyId() {
        return companyId;
    }

    public void setCompanyId(int companyId) {
        this.companyId = companyId;
    }

    @Column(name="COMPANY_NAME")
    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    @OneToMany(fetch=FetchType.LAZY,cascade=CascadeType.ALL,mappedBy="company")
    public List<Branch> getBranches() {
        return branches;
    }

    public void setBranches(List<Branch> branches) {
        this.branches = branches;
    }


}

बाल वर्ग, शाखा

@Entity
public class Branch {

    private int branchId;
    private String branchName;
    private Company company;

    @Id
    @GeneratedValue
    @Column(name="BRANCH_ID")
    public int getBranchId() {
        return branchId;
    }

    public void setBranchId(int branchId) {
        this.branchId = branchId;
    }

    @Column(name="BRANCH_NAME")
    public String getBranchName() {
        return branchName;
    }

    public void setBranchName(String branchName) {
        this.branchName = branchName;
    }

    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="COMPANY_ID")
    public Company getCompany() {
        return company;
    }

    public void setCompany(Company company) {
        this.company = company;
    }


}

@JoinColumn संबंधों के दोनों किनारों पर इस्तेमाल किया जा सकता है। सवाल @JoinColumn ( @OneToMany दुर्लभ मामला) पर @OneToMany @JoinColumn का उपयोग करने के बारे में था। और यहां बिंदु भौतिक सूचना डुप्लिकेशन (कॉलम नाम) में है, साथ ही ऑप्टिमाइज़ किए गए SQL क्वेरी के साथ जो कुछ अतिरिक्त अद्यतन विवरण उत्पन्न करेगा

documentation अनुसार:

चूंकि कई से एक (लगभग) हमेशा जेपीए स्पेक में एक द्विपक्षीय संबंध के मालिक पक्ष होते हैं, इसलिए कई संगठनों में से एक को @OneToMany (mappedBy = ...) द्वारा एनोटेट किया जाता है।

@Entity
public class Troop {
    @OneToMany(mappedBy="troop")
    public Set<Soldier> getSoldiers() {
    ...
}

@Entity
public class Soldier {
    @ManyToOne
    @JoinColumn(name="troop_fk")
    public Troop getTroop() {
    ...
} 

ट्रूप की सेना के माध्यम से सैनिक के साथ कई रिश्तों के लिए एक द्विपक्षीय है। मैप किए गए पक्ष में आपको किसी भौतिक मैपिंग को परिभाषित करने की आवश्यकता नहीं है (नहीं)।

कई लोगों के लिए एक बिडरेक्शनल को मैप करने के लिए, स्वामित्व वाले पक्ष के साथ-साथ कई पक्षों के साथ , आपको मैप किए गए तत्व को निकालना होगा और कई को @ जॉइन कॉलम को डालने के लिए डालने योग्य और अद्यतन करने योग्य के रूप में सेट करना होगा। यह समाधान अनुकूलित नहीं है और कुछ अतिरिक्त अद्यतन विवरण तैयार करेगा।

@Entity
public class Troop {
    @OneToMany
    @JoinColumn(name="troop_fk") //we need to duplicate the physical information
    public Set<Soldier> getSoldiers() {
    ...
}

@Entity
public class Soldier {
    @ManyToOne
    @JoinColumn(name="troop_fk", insertable=false, updatable=false)
    public Troop getTroop() {
    ...
}




orm