使用Hibernate“mappedBy引用未知目标实体属性”

Question

我第一次使用Hibernate，并且很难让它与我的模式一起工作。

我得到了"org.hibernate.注释异常：映射通过引用未知的目标实体属性：学生。教师在Faculty.all学生”。

一些学生共用一个导师。因此，我认为学生和教师的关系是多对多的，但我被告知这是多对多的关系。

Student.java

import javax.persistence.*;

@Entity  
@Table(name = "Student")  
@PrimaryKeyJoinColumn(name="StudentID")
public class Student extends Person
{
    @Column(name = "Classification")  
    private String Classification;

    @Column(name = "GPA")
    private double GPA;

    @OneToOne(mappedBy="Student")
    @JoinColumn(name = "FacultyID")
    private Faculty Mentor;

    @Column(name = "CreditHours")
    private int CreditHours;

    public Student()
    {

    }
    public Student(String studentID, String classification, double gpa, String mentorID, int creditHours)
    {
        //this.StudentID = studentID;
        this.Classification = classification;
        this.GPA = gpa;
        //this.MentorID = mentorID;
        this.CreditHours = creditHours;
    }
    public String getClassification()
    {
        return Classification;
    }
    public void setClassification(String classification)
    {
        this.Classification = classification;
    }
    public double getGPA()
    {
        return GPA;
    }
    public void setGPA(int gpa)
    {
        this.GPA = gpa;
    }
    public Faculty getMentor()
    {
        return Mentor;
    }
    public void setMentor(Faculty mentor)
    {
        this.Mentor = mentor;
    }
    public int getCreditHours()
    {
        return CreditHours;
    }
    public void setCreditHours(int creditHours)
    {
        this.CreditHours = creditHours;
    }
}

Faculty.java

import javax.persistence.*;
import java.util.Set;

@Entity  
@Table(name = "Faculty")  
@PrimaryKeyJoinColumn(name="FacultyID")
public class Faculty extends Person
{
    @Column(name = "Rank")  
    private String Rank;
    @Column(name = "Salary")
    private int Salary;

    @OneToMany(mappedBy="Faculty")
    private Set<Student> allStudents;

    public Faculty()
    {

    }
    public Faculty(String facultyID, String rank, int salary)
    {
        //this.FacultyID = facultyID;
        this.Rank = rank;
        this.Salary = salary;
    }
    public String getRank()
    {
        return Rank;
    }
    public void setName(String rank)
    {
        this.Rank = rank;
    }
    public int getSalary()
    {
        return Salary;
    }
    public void setSalary(int salary)
    {
        this.Salary = salary;
    }

    public Set<Student> getAllStudents()
    {
        return allStudents;
    }
    public void setAllStudents(Set<Student> allStuds)
    {
        this.allStudents = allStuds;
    }
}

数据库架构：

CREATE TABLE Person (
Name    char (20),
ID      char (9) NOT NULL,
Address char (30),
DOB     date,
PRIMARY KEY (ID));

CREATE TABLE Faculty (
FacultyID       char (9) NOT NULL,
Rank            char (12),
Salary          int,
PRIMARY KEY (FacultyID),
FOREIGN KEY (FacultyID) REFERENCES Person(ID));

CREATE TABLE Student (
StudentID       char (9) NOT NULL,
Classification  char (10),
GPA             double,
MentorID        char (9),
CreditHours     int,
PRIMARY KEY (StudentID),
FOREIGN KEY (StudentID) REFERENCES Person(ID),
FOREIGN KEY (MentorID) REFERENCES Faculty(FacultyID));

在看了留档后，我尝试了几种不同的注释，但我看不出我做错了什么。

Answer 1

首先，你需要定义学生和教师的关系。

1. 多对多：一个学生可以有多个教员，一个教员可以有多个学生

这意味着你需要有很多关系。

学生桌

id
name
bla
bla

教员表

id
name
bla
bla

关系表

id
student_id
faculty_id

这是你的冬眠映射：

特级

@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinTable(name = "faculty_student_rel", catalog = "yourDb", joinColumns = {
            @JoinColumn(name = "STUDENT_ID", nullable = false, updatable = false) },
            inverseJoinColumns = { @JoinColumn(name = "FACULTY_ID",
                    nullable = false, updatable = false) })
    public Set<Faculty> getFaculties() {
        return this.faculties;
    }

Faculty.class

@ManyToMany(fetch = FetchType.LAZY, mappedBy = "faculties")
    public Set<Student> getStudents() {
        return this.students;
    }

对于这种情况，您可以使用@Matteo Baldi的解决方案。

Answer 2

在您的实体中，您应该指向正确的属性，而不是类型：

@OneToMany(mappedBy="Mentor", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<Student> allStudents;

另外，在您的学生实体中，与教员的关系是多通，而不是一通

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "MentorID")
private Faculty Mentor;