Hibernate schlägt fehl, indem der Name der Eigenschaft Fully qualified für den Namen der Eigenschaft ManyToMany-Verknüpfung vorangestellt wird

Question

Ich versuche, zwei Objekte mithilfe einer ManyToMany Zuordnung zuzuordnen, aber aus irgendeinem Grund scheint Hibernate verwirrt zu werden, wenn ich die Eigenschaft mappedBy verwende über genau das, was ich kartiere. Das einzig Seltsame an meiner Zuordnung ist, dass die Zuordnung in einem Primärschlüsselfeld in einem der Einträge nicht erfolgt (das Feld ist jedoch eindeutig).

Die Tische sind:

Sequence (
    id NUMBER, 
    reference VARCHAR, 
) 

Project (
    id NUMBER 
) 

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

Die Objekte aussehen (Anmerkungen auf dem Getter sind, setzen sie auf den Feldern etwas zu kondensieren):

class Sequence { 
    @Id 
    private int id; 

    private String reference; 

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

Und die besitzende Seite:

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; 
} 

Dieser schlägt mit einem MappingException:

Immobilien-ref [_test_local_entities_Project_sequences] nicht auf Einheit gefunden [test.local.entities.Project]

Es scheint, den vollständig qualifizierten Klassennamen von Unterstrichen geteilt weirdly Zierer. Wie kann ich das vermeiden?

EDIT: Ich spielte mit diesem ein bisschen mehr. Ändern des Namens des mappedBy Eigenschaft eine andere Ausnahme ausgelöst, und zwar:

org.hibernate.AnnotationException: mappedBy Referenz eine unbekannte Zieleinheit Eigenschaft: test.local.entities.Project.sequences

So Die Annotation wird korrekt verarbeitet, aber irgendwie wird die Eigenschaftsreferenz der internen Konfiguration von Hibernate nicht korrekt hinzugefügt.

Answer 1

Ich habe das gleiche Szenario von Ihrer Frage vorgeschlagen. Und wie erwartet bekomme ich die selbe Ausnahme. Nur als ergänzende Aufgabe, habe ich das gleiche Szenario aber mit Eins-zu-viele viele-zu-eins mit einem Nicht-Primärschlüssel als verbundene Spalte wie Referenz getan. Ich bekomme jetzt

SecondaryTable JoinColumn kann nicht Referenz ein nicht Primärschlüssel

Nun, es kann ein Fehler sein ??? Nun ja (und Ihre Workaround funktioniert gut (+1)). Wenn Sie einen Nicht-Primärschlüssel als Primärschlüssel verwenden möchten, müssen Sie sicherstellen, es ist eindeutig. Vielleicht erklärt es, warum Hibernate es nicht erlaubt, einen Nicht-Primärschlüssel als Primärschlüssel zu verwenden (Nicht-Benutzer können unerwartetes Verhalten erhalten).

Wenn Sie die gleiche Zuordnung verwenden möchten, können Sie Ihre @ManyToMany Beziehung in @ OneToMany-ManyToOne Durch die Verwendung von Verkapselung aufgeteilt, brauchen Sie nicht über Ihre Klasse verbunden

Projekt

zu kümmern

@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; 
    } 

} 

Sequenz

@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

Ich habe es endlich herausgefunden, mehr oder weniger. Ich denke, das ist im Grunde ein Winterschlaffehler.

edit: Ich habe versucht, es zu beheben, indem Sie die besitzende Seite des Vereins zu ändern:

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; 
} 

Das funktionierte aber verursachte Probleme an anderer Stelle (siehe Kommentar). Also gab ich auf und modellierte die Assoziation als eine Entität mit Eins-zu-Eins-Assoziationen in Sequenz und Projekt. Ich denke, das ist zumindest ein Dokumentations-/Fehlerbehandlungsfehler (die Ausnahme ist nicht sehr relevant und der Fehlermodus ist einfach falsch) und wird versuchen, es den Hibernate-Entwicklern zu melden.

Answer 3

IMHO was Sie versuchen zu erreichen ist nicht möglich mit JPA/Hibernate Annotationen. Leider ist die APIDoc von JoinTable hier ein wenig unklar, aber alle Beispiele, die ich fand, verwenden Primärschlüssel beim Mapping von Join-Tabellen.

Wir hatten das gleiche Problem wie Sie in einem Projekt, in dem wir auch das alte Datenbankschema nicht ändern konnten. Die einzige praktikable Option war es, Hibernate zu löschen und MyBatis (http://www.mybatis.org) zu verwenden, wo Sie die volle Flexibilität von nativem SQL haben, um komplexere Join-Bedingungen auszudrücken.

Answer 4

ich laufe in dieses Problem ein Dutzend Mal jetzt und die einzige Abhilfe, die ich gefunden macht die Konfiguration der @JoinTable zweimal mit vertauschten Spalten auf der anderen Seite der Beziehung:

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; 

} 

ich noch nicht versucht, es mit einer anderen Spalte als der Primärschlüssel.