Java 如果不使用泛型，请确保在关系映射上定义了目标实体

我是JPA新手，从中学习

我创建了两个表，一个是

Person

，另一个是

Notebook

。如果没有弄错，如果代码运行成功，将创建个人笔记本。（如果我错了，请纠正我，因为我是JPA新手）

人

   @Entity
@Table(name = "Person")
@XmlRootElement
@NamedQueries({
    @NamedQuery(name = "Person.findAll", query = "SELECT p FROM Person p")
    , @NamedQuery(name = "Person.findById", query = "SELECT p FROM Person p WHERE p.id = :id")
    , @NamedQuery(name = "Person.findByName", query = "SELECT p FROM Person p WHERE p.name = :name")
    , @NamedQuery(name = "Person.findByCompName", query = "SELECT p FROM Person p WHERE p.compName = :compName")})
public class Person implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "id")
    private Integer id;
    @Basic(optional = false)
    @Column(name = "Name")
    private String name;
    @Basic(optional = false)
    @Column(name = "CompName")
    private String compName;

    @ManyToMany
    @JoinTable(name="person_has_notebooks", joinColumns={@JoinColumn(name="person_id")}, inverseJoinColumns={@JoinColumn(name="notebook_id")})
    private List notebooks;

    public List getNotebooks() {
        return notebooks;
    }

    public void setNotebooks(List notebooks) {
        this.notebooks = notebooks;
    }

    public Person() {
    }

    public Person(Integer id) {
        this.id = id;
    }

    public Person(Integer id, String name, String compName) {
        this.id = id;
        this.name = name;
        this.compName = compName;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCompName() {
        return compName;
    }

    public void setCompName(String compName) {
        this.compName = compName;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Person)) {
            return false;
        }
        Person other = (Person) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "entity.Person[ id=" + id + " ]";
    }

}

笔记本电脑

 @Entity
@Table(name = "NoteBook")
@XmlRootElement
@NamedQueries({
    @NamedQuery(name = "NoteBook.findAll", query = "SELECT n FROM NoteBook n")
    , @NamedQuery(name = "NoteBook.findById", query = "SELECT n FROM NoteBook n WHERE n.id = :id")
    , @NamedQuery(name = "NoteBook.findBySerialName", query = "SELECT n FROM NoteBook n WHERE n.serialName = :serialName")
    , @NamedQuery(name = "NoteBook.findByRam", query = "SELECT n FROM NoteBook n WHERE n.ram = :ram")
    , @NamedQuery(name = "NoteBook.findByHd", query = "SELECT n FROM NoteBook n WHERE n.hd = :hd")})
public class NoteBook implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "id")
    private Integer id;
    @Basic(optional = false)
    @Column(name = "SerialName")
    private String serialName;
    @Basic(optional = false)
    @Column(name = "Ram")
    private int ram;
    @Basic(optional = false)
    @Column(name = "HD")
    private int hd;

    @ManyToMany(mappedBy="notebooks")
    private List person;

    public List getPersons() {
        return person;
    }

    public void setPersons(List persons) {
        this.person = persons;
    }

    public NoteBook() {
    }

    public NoteBook(Integer id) {
        this.id = id;
    }

    public NoteBook(Integer id, String serialName, int ram, int hd) {
        this.id = id;
        this.serialName = serialName;
        this.ram = ram;
        this.hd = hd;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getSerialName() {
        return serialName;
    }

    public void setSerialName(String serialName) {
        this.serialName = serialName;
    }

    public int getRam() {
        return ram;
    }

    public void setRam(int ram) {
        this.ram = ram;
    }

    public int getHd() {
        return hd;
    }

    public void setHd(int hd) {
        this.hd = hd;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof NoteBook)) {
            return false;
        }
        NoteBook other = (NoteBook) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "entity.NoteBook[ id=" + id + " ]";
    }

}

ManyToMany1

public class ManyToMany1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("ManyToMany1PU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();

        NoteBook noteA = new NoteBook();
        noteA.setSerialNumber("A0123");
        NoteBook noteB = new NoteBook();
        noteB.setSerialNumber("B0123");
        NoteBook noteC = new NoteBook();
        noteC.setSerialNumber("C0123");

        List notebooks = new ArrayList();
        notebooks.add(noteA);
        notebooks.add(noteB);
        notebooks.add(noteC);

        Person person = new Person();
        person.setName("Zorro");
        person.setNotebooks(notebooks);

        em.persist(person);

        em.getTransaction().commit();

    }

}

错误

Exception Description: Predeployment of PersistenceUnit [ManyToMany1PU] failed.
Internal Exception: Exception [EclipseLink-7214] (Eclipse Persistence Services - 2.5.2.v20140319-9ad6abd): org.eclipse.persistence.exceptions.ValidationException
Exception Description: The target entity of the relationship attribute [notebooks] on the class [class entity.Person] cannot be determined.  When not using generics, ensure the target entity is defined on the relationship mapping.
    at org.eclipse.persistence.exceptions.PersistenceUnitLoadingException.exceptionSearchingForPersistenceResources(PersistenceUnitLoadingException.java:127)
    at org.eclipse.persistence.jpa.PersistenceProvider.createEntityManagerFactoryImpl(PersistenceProvider.java:107)
    at org.eclipse.persistence.jpa.PersistenceProvider.createEntityManagerFactory(PersistenceProvider.java:177)
    at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:79)
    at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:54)
    at manytomany1.ManyToMany1.main(ManyToMany1.java:27)

---

我已经将

mappedBy

分配给了薄弱环节，但为什么仍然会出现这样的错误

为什么不按照消息告诉你的那样使用泛型呢

@ManyToMany
@JoinTable(name="person_has_notebooks", joinColumns={@JoinColumn(name="person_id")}, inverseJoinColumns={@JoinColumn(name="notebook_id")})
private List<NoteBook> notebooks;

@manytomy
@JoinTable（name=“person\u has\u notebooks”，joinColumns={@JoinColumn（name=“person\u id”）}，inverseJoinColumns={@JoinColumn（name=“notebook\u id”）}）
私人名单笔记本；

及

@ManyToMany（mappedBy=“笔记本”）
私人名单人士；

为什么不按照消息告诉您的那样使用泛型呢

@ManyToMany
@JoinTable(name="person_has_notebooks", joinColumns={@JoinColumn(name="person_id")}, inverseJoinColumns={@JoinColumn(name="notebook_id")})
private List<NoteBook> notebooks;

@manytomy
@JoinTable（name=“person\u has\u notebooks”，joinColumns={@JoinColumn（name=“person\u id”）}，inverseJoinColumns={@JoinColumn（name=“notebook\u id”）}）
私人名单笔记本；

及

@ManyToMany（mappedBy=“笔记本”）
私人名单人士；

正如错误所述，当不使用泛型时，您必须告诉提供者您指的是哪个实体。Neil Stockton下面的答案有一个如何使用泛型的例子。有一个例子，如果您不能或不想使用泛型，那么可以指定目标实体，因为JPA不知道您在引用什么类

@ManyToMany(targetEntity=com.example.NoteBook.class)
@JoinTable(name="person_has_notebooks", joinColumns={@JoinColumn(name="person_id")}, inverseJoinColumns={@JoinColumn(name="notebook_id")})
private List notebooks;

@ManyToMany(mappedBy="notebooks", targetEntity=com.example.Person.class)
private List person;

---

否则，如果您可以在列表中使用泛型，请使用Neils answer。

错误说明，当不使用泛型时，您必须告诉提供者您引用的是哪个实体。Neil Stockton下面的答案有一个如何使用泛型的例子。有一个例子，如果您不能或不想使用泛型，那么可以指定目标实体，因为JPA不知道您在引用什么类

@ManyToMany(targetEntity=com.example.NoteBook.class)
@JoinTable(name="person_has_notebooks", joinColumns={@JoinColumn(name="person_id")}, inverseJoinColumns={@JoinColumn(name="notebook_id")})
private List notebooks;

@ManyToMany(mappedBy="notebooks", targetEntity=com.example.Person.class)
private List person;

---

---

否则，如果您可以在列表中使用泛型，请使用Neils答案。

您的

@Entity

类注释在哪里？@OrtomalaLokni编辑。您为什么不使用泛型？在90年代开始编程是一个非常糟糕的主意。我会寻找更好的教程。如果这是在2011年写的，而且它没有使用泛型，谁知道它还包含了什么可怕的东西。那么Hibernate的网页呢？我只能告诉你，那是垃圾。你的

@Entity

类注释在哪里？@OrtomalaLokni编辑。你为什么不使用泛型？在90年代开始编程是一个非常糟糕的主意。我会寻找更好的教程。如果这是在2011年写的，而且它没有使用泛型，谁知道它还包含了什么可怕的东西。那么Hibernate的网页呢？我可以告诉你的是，那是垃圾。如果他在学习一个不使用泛型的教程，那么最好是放弃整个教程。

@JoinColumn（name=“person\u id”

和

@JoinColumn（name=“notebook\u id”

。这两个列名与

person\u has\u notebook

？@Kayaman@JoinColumn（name=“person\u id”和@JoinColumn（name=“notebook\u id”）中的列名相同。这两个列名与person_has_notebook中的列名相同？@JohnJoe我告诉过你找一个更好的教程。谢谢你的回答，但是我在同步过程中得到

，通过一个未标记为cascade PERSIST:entity.notebook[noteBookid=null]的关系找到了一个新对象.

错误。错误指向

em.getTransaction（）.commit（）；

如果他遵循的是一个不使用泛型的教程，那么可能最好放弃整个教程。

@JoinColumn（name=“person\u id”

和

@JoinColumn（name=“notebook\u id”

。这两个列名与

person\u has\u notebook

？@Kayaman@JoinColumn（name=“person\u id”和@JoinColumn（name=“notebook\u id”）中的列名相同。这两个列名与person_has_notebook中的列名相同？@JohnJoe我告诉过你找一个更好的教程。谢谢你的回答，但是我在同步过程中得到

，通过一个未标记为cascade PERSIST:entity.notebook[noteBookid=null]的关系找到了一个新对象.

错误。错误指向

em.getTransaction（）.commit（）；

感谢您的回答。我使用Neils的答案，但在同步过程中，通过未标记为cascade PERSIST:entity.NoteBook[noteBookid=null]的关系找到了一个新对象。错误指向

em.getTransaction（）.commit（）

这是一个新问题，可能是因为在调用persist之前向关系中添加了一个实体。在设置关系之前，可以对两个实体都调用persist，或者使用cascade persist选项设置关系。您发布的这个示例缺少使其工作所需的一些更精细的详细信息-请参阅rence还有一些。谢谢你的回答。我使用Neils answer，但在同步过程中，通过未标记为cascade PERSIST:entity.NoteBook[noteBookid=null]的关系找到了一个新对象。错误。错误指向

em.getTransaction（）.commit（）

这是一个新问题，可能是因为在调用persist之前向关系中添加了一个实体。在设置关系之前，可以对两个实体都调用persist，或者使用cascade persist选项设置关系。您发布的这个示例缺少使其工作所需的一些更精细的详细信息-请参阅还有一些其他的。