हाइबरनेट कई प्रकार के योग्य वर्ग नाम को प्रॉपर्टी नाम पर कई टीओएमनी एसोसिएशन

Question

पर प्रॉपर्टी नाम से प्रीपेड करने में असफल रहा है। मैं ManyToMany एसोसिएशन का उपयोग करके एक दूसरे को दो ऑब्जेक्ट्स मैप करने की कोशिश कर रहा हूं, लेकिन किसी कारण से जब मै मैप्डबी प्रॉपर्टी का उपयोग करता हूं, तो हाइबरनेट उलझन में प्रतीत होता है मैं वास्तव में क्या मैपिंग कर रहा हूँ के बारे में। यहां मेरी मैपिंग के बारे में एकमात्र अजीब चीज यह है कि एसोसिएशन किसी एक प्रविष्टि में प्राथमिक कुंजी फ़ील्ड पर नहीं किया जाता है (हालांकि फ़ील्ड अद्वितीय है)।

तालिकाओं हैं:

Sequence (
    id NUMBER, 
    reference VARCHAR, 
) 

Project (
    id NUMBER 
) 

Sequence_Project (
    proj_id number references Project(id), 
    reference varchar references Sequence(reference) 
) 

वस्तुओं की तरह लग रहे (एनोटेशन थोड़ा गाढ़ा करने के लिए खेतों पर डाल, गेटर पर हैं):

class Sequence { 
    @Id 
    private int id; 

    private String reference; 

    @ManyToMany(mappedBy="sequences") 
    private List<Project> projects; 
} 

और मालिक पक्ष:

class Project { 
    @Id 
    private int id; 

    @ManyToMany 
    @JoinTable(name="sequence_project", 
       joinColumns=@JoinColumn(name="id"), 
       inverseJoinColumns=@JoinColumn(name="reference", 
            referencedColumnName="reference")) 
    private List<Sequence> sequences; 
} 

यह मैपिंग अपवाद के साथ विफल रहता है:

संपत्ति-रेफरी [_test_local_entities_Project_sequences] इकाई पर नहीं मिला [test.local.entities.Project]

यह अजीब तरह से पूरी तरह से योग्य वर्ग के नाम, अंडरस्कोर से विभाजित पहले जोड़ें करने लगता है। मैं इसे कैसे होने से बच सकता हूं?

संपादित करें: मैंने इसके साथ थोड़ा और खेला। थ्रो एक अलग अपवाद, mappedBy संपत्ति के नाम बदलने से अर्थात्:

org.hibernate.AnnotationException: test.local.entities.Project.sequences

तो: mappedBy एक अज्ञात लक्ष्य इकाई संपत्ति का संदर्भ एनोटेशन सही तरीके से प्रसंस्करण कर रहा है, लेकिन किसी भी तरह से संपत्ति संदर्भ सही ढंग से हाइबरनेट की आंतरिक कॉन्फ़िगरेशन में नहीं जोड़ा गया है।

Answer 1

मैंने आपके प्रश्न द्वारा प्रस्तावित वही परिदृश्य किया है। और, जैसा कि अपेक्षित है, मुझे एक ही अपवाद मिलता है। पूरक कार्य के रूप में, मैंने एक ही परिदृश्य लेकिन को एक-से-कई-से-एक के साथ गैर-प्राथमिक कुंजी का उपयोग करके कॉलम जैसे संदर्भ के रूप में किया है। मैं अब मिल

SecondaryTable JoinColumn नहीं कर सकते संदर्भ एक गैर प्राथमिक एक बग कुंजी

खैर, यह हो सकता है ??? खैर, हाँ (और आपका कामकाज ठीक काम करता है (+1))। यदि आप प्राथमिक कुंजी के रूप में गैर-प्राथमिक कुंजी का उपयोग करना चाहते हैं, तो आपको यह सुनिश्चित करना होगा कि यह अद्वितीय है। शायद यह बताता है कि क्यों हाइबरनेट प्राथमिक कुंजी के रूप में गैर-प्राथमिक कुंजी का उपयोग करने की अनुमति नहीं देता है (अनजान उपयोगकर्ताओं को अप्रत्याशित व्यवहार मिल सकते हैं)।

आप एक ही मानचित्रण का उपयोग करना चाहते हैं, तो आप @ OneToMany-ManyToOne में अपने @ManyToMany संबंध विभाजित कर सकते हैं कैप्सूलीकरण का उपयोग करके आप अपने में शामिल हो गए वर्ग के बारे में चिंता करने की जरूरत नहीं

परियोजना

@Entity 
public class Project implements Serializable { 

    @Id 
    @GeneratedValue 
    private Integer id; 

    @OneToMany(mappedBy="project") 
    private List<ProjectSequence> projectSequenceList = new ArrayList<ProjectSequence>(); 

    @Transient 
    private List<Sequence> sequenceList = null; 

    // getters and setters 

    public void addSequence(Sequence sequence) { 
     projectSequenceList.add(new ProjectSequence(new ProjectSequence.ProjectSequenceId(id, sequence.getReference()))); 
    } 

    public List<Sequence> getSequenceList() { 
     if(sequenceList != null) 
      return sequenceList; 

     sequenceList = new ArrayList<Sequence>(); 
     for (ProjectSequence projectSequence : projectSequenceList) 
      sequenceList.add(projectSequence.getSequence()); 

     return sequenceList; 
    } 

} 

अनुक्रम

@Entity 
public class Sequence implements Serializable { 

    @Id 
    private Integer id; 
    private String reference; 

    @OneToMany(mappedBy="sequence") 
    private List<ProjectSequence> projectSequenceList = new ArrayList<ProjectSequence>(); 

    @Transient 
    private List<Project> projectList = null; 

    // getters and setters 

    public void addProject(Project project) { 
     projectSequenceList.add(new ProjectSequence(new ProjectSequence.ProjectSequenceId(project.getId(), reference))); 
    } 

    public List<Project> getProjectList() { 
     if(projectList != null) 
      return projectList; 

     projectList = new ArrayList<Project>(); 
     for (ProjectSequence projectSequence : projectSequenceList) 
      projectList.add(projectSequence.getProject()); 

     return projectList; 
    } 

} 

ProjectSequence

@Entity 
public class ProjectSequence { 

    @EmbeddedId 
    private ProjectSequenceId projectSequenceId; 

    @ManyToOne 
    @JoinColumn(name="ID", insertable=false, updatable=false) 
    private Project project; 

    @ManyToOne 
    @JoinColumn(name="REFERENCE", referencedColumnName="REFERENCE", insertable=false, updatable=false) 
    private Sequence sequence; 

    public ProjectSequence() {} 
    public ProjectSequence(ProjectSequenceId projectSequenceId) { 
     this.projectSequenceId = projectSequenceId; 
    } 

    // getters and setters 

    @Embeddable 
    public static class ProjectSequenceId implements Serializable { 

     @Column(name="ID", updatable=false) 
     private Integer projectId; 

     @Column(name="REFERENCE", updatable=false) 
     private String reference; 

     public ProjectSequenceId() {} 
     public ProjectSequenceId(Integer projectId, String reference) { 
      this.projectId = projectId; 
      this.reference = reference; 
     } 

     @Override 
     public boolean equals(Object o) { 
      if (!(o instanceof ProjectSequenceId)) 
       return false; 

      final ProjectSequenceId other = (ProjectSequenceId) o; 
      return new EqualsBuilder().append(getProjectId(), other.getProjectId()) 
             .append(getReference(), other.getReference()) 
             .isEquals(); 
     } 

     @Override 
     public int hashCode() { 
      return new HashCodeBuilder().append(getProjectId()) 
             .append(getReference()) 
             .hashCode(); 
     } 

    } 

} 

Answer 2

मैंने आखिरकार इसे कम या ज्यादा समझ लिया। मुझे लगता है कि यह मूल रूप से एक हाइबरनेट बग है।

संपादित करें: मैं संघ के मालिक पक्ष बदलकर इसे ठीक करने की कोशिश की:

class Sequence { 
    @Id 
    private int id; 

    private String reference; 

    @ManyToMany 
    @JoinTable(name="sequence_project", 
      inverseJoinColumns=@JoinColumn(name="id"), 
      joinColumns=@JoinColumn(name="reference", 
         referencedColumnName="reference")) 
    private List<Project> projects; 
} 

class Project { 
    @Id 
    private int id; 

    @ManyToMany(mappedBy="projects") 
    private List<Sequence> sequences; 
} 

यह काम किया लेकिन समस्याओं कहीं और की वजह से (टिप्पणी देखें)। इसलिए मैंने अनुक्रम और परियोजना में कई से एक संगठनों के साथ एक इकाई के रूप में एसोसिएशन को छोड़ दिया और मॉडलिंग किया। मुझे लगता है कि यह कम से कम एक दस्तावेज/गलती हैंडलिंग बग पर है (अपवाद बहुत प्रासंगिक नहीं है, और विफलता मोड सिर्फ गलत है) और इसे हाइबरनेट देवों को रिपोर्ट करने का प्रयास करेगा।

Answer 3

आईएमएचओ जो आप हासिल करने की कोशिश कर रहे हैं वह जेपीए/हाइबरनेट एनोटेशन के साथ संभव नहीं है। दुर्भाग्यवश, JoinTable का एपीआईडीओसी थोड़ा अस्पष्ट है, लेकिन मैंने पाया कि सभी उदाहरण प्राथमिक तालिकाओं का उपयोग करते समय प्राथमिक कुंजी का उपयोग करते हैं।

हमारे पास एक परियोजना में आपके जैसा ही मुद्दा था जहां हम विरासत डेटाबेस स्कीमा भी नहीं बदल सके। हाइबरनेट को डंप करने और MyBatis (http://www.mybatis.org) का उपयोग करने का एकमात्र व्यवहार्य विकल्प था, जहां आपके पास अधिक जटिल जुड़ने की स्थितियों को व्यक्त करने के लिए मूल एसक्यूएल की पूर्ण लचीलापन है।

Answer 4

मैं एक दर्जन बार अब इस समस्या में चलाने के लिए और केवल वैकल्पिक हल मैंने पाया संबंध के दूसरे पक्ष पर बदली कॉलम के साथ दो बार @JoinTable के विन्यास कर रहा है:

class Sequence { 

    @Id 
    private int id; 

    private String reference; 

    @ManyToMany 
    @JoinTable(
     name = "sequence_project", 
     joinColumns = @JoinColumn(name="reference", referencedColumnName="reference"), 
     inverseJoinColumns = @JoinColumn(name="id") 
    ) 
    private List<Project> projects; 

} 

class Project { 

    @Id 
    private int id; 

    @ManyToMany 
    @JoinTable(
     name = "sequence_project", 
     joinColumns = @JoinColumn(name="id"), 
     inverseJoinColumns = @JoinColumn(name="reference", referencedColumnName="reference") 
    ) 
    private List<Sequence> sequences; 

} 

मैं अभी तक की कोशिश की नहीं किया यह प्राथमिक कुंजी से अलग कॉलम के साथ।