java - hibernate，无法保存多对一关系

Question

我一直在研究@ManyToOne hibernate注释的教程，但不完全理解一些东西。为了简单解释，这里是一段代码:

@Entity
@Table
public class Student {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@Column
private String name;
@OneToMany(mappedBy = "student", fetch = FetchType.LAZY)
private Set<Book> bookList;
// getters, setters...
}

和

@Entity
@Table(name = "book")
public class Book {

@Id
@Column(name = "ID")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@Column(name = "NAME", unique = true, nullable = false, length = 100)
private String name;
@Column(name = "DESCRIPTION", unique = true, nullable = false, length = 100)
private String description;
@ManyToOne(fetch = FetchType.LAZY, optional = true)
@JoinTable(name = "CATALOG", joinColumns = @JoinColumn(name = "ID_BOOK"),  inverseJoinColumns = @JoinColumn(name = "ID_STUDENT"))
private Student student;
// getters, setters...
}

并且，当我执行这两个类时:

Session session = factory.getCurrentSession();
    //start
    System.out.println("start!");
    Book book = new Book();
    book.setName("bulk");
    book.setDescription("hulk");
    //book set
    session.beginTransaction();
    session.save(book);
    //book saved
    Student stud = new Student();
    stud.setName("Mark");
    //stud set
    Set<Book> books = new HashSet<>();
    book.setStudent(stud);
    books.add(book);
    //book add to list
    stud.setBookList(books);
    //list added to stud
    session.save(stud);

    session.getTransaction().commit();

结果显然是:

start!
Hibernate: insert into book (DESCRIPTION, NAME) values (?, ?)
Hibernate: insert into Student (name) values (?)
Hibernate: insert into CATALOG (ID_STUDENT, ID_BOOK) values (?, ?)
end

现在，当我对这两个类做同样的事情时(在我看来，显然，否则它会起作用):

@Entity
@Table(name = "client",
    uniqueConstraints = {
        @UniqueConstraint(columnNames = {"client_id"})})
public class Client {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "client_id", nullable = false, unique = true, length = 11)
private int id;
@Column(name = "client_name", length = 60, nullable = true)
private String name;
@Column(name = "client_comment", length = 60, nullable = true)
private String comment;
@Column(name = "client_activated", nullable = true)
private boolean activated;

@OneToMany(mappedBy = "client", fetch = FetchType.LAZY)
Set<AdditionalProperty> propertiesList;

// start of class properties

@Entity
@Table(name = "user_properties",
    uniqueConstraints = {
        @UniqueConstraint(columnNames = {"property_id"})})
public class AdditionalProperty {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "property_id")
private int id;
@Column(name = "property_name", length = 60, nullable = true)
private String name;
@Column(name = "property_type", length = 60, nullable = true)
private String propertyType;
//@ManyToOne(cascade = CascadeType.ALL)
//@JoinColumn(name = "property_to_client")
//@ManyToOne(fetch = FetchType.LAZY,optional=true)
//@JoinTable(name = "ref_client_to_property", joinColumns = @JoinColumn(name = "ref_property_id"), inverseJoinColumns = @JoinColumn(name = "ref_client_id"))
@ManyToOne(fetch = FetchType.LAZY, optional = true)
@JoinTable(name = "ref_client_to_prop", joinColumns = @JoinColumn(name = "id_prop"), inverseJoinColumns = @JoinColumn(name = "id_client"))
private Client client;

当我执行这段代码时:

AdditionalProperty prop = new AdditionalProperty();
    prop.setName("testf2");
    prop.setPropertyType("testt2");
    AdditionalProperty prop2 = new AdditionalProperty();
    prop2.setName("wat2");
    prop2.setPropertyType("wat");
    //props set
    new HibernateDAOAdditionalProperty().create(prop);
    new HibernateDAOAdditionalProperty().create(prop2);
    System.out.println("prop set");
    //props saved


    Client client = new Client();
    client.setName("cascadeable");
    client.setComment("ho-ho-ho");
    client.setActivated(false);
    //cli set
    Set<AdditionalProperty> propList = new HashSet<>();
    prop.setClient(client);
    prop2.setClient(client);
    propList.add(prop);
    propList.add(prop2);
    // props added to list
    client.setPropertiesList(propList);
    // list added to client
    HibernateDAOClient dao = new HibernateDAOClient();
    dao.create(client);

查询结果不是我所期望的:

Hibernate: insert into user_properties (property_name, property_type) values (?, ?)
Hibernate: insert into user_properties (property_name, property_type) values (?, ?)
prop set
Hibernate: insert into client (client_activated, client_comment, client_name) values (?, ?, ?)

我期望的地方:

Hibernate: insert into ref_client_to_prop (id_client, id_prop) values (?, ?)

请帮忙，我做错了什么？我需要将他们的关系保存在数据库中，但不知何故我不能。

附注增加困惑:

当我使用这个类时:

public class ClientProperty {
@Id
@Column(name = "ID")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
@ManyToOne(cascade=CascadeType.ALL)
@JoinColumn(name="id_client")
private Client client;
@ManyToOne(cascade=CascadeType.ALL)
@JoinColumn(name="id_characteristic")
private AdditionalProperty property;
@Column(name = "characteristic_value")
private String value;

然后执行(添加到前面的代码中):

System.out.println("try to save");
    ClientProperty cliPro = new ClientProperty();
    cliPro.setClient(client);
    cliPro.setProperty(prop);
    cliPro.setValue("vocabulary");
    DAOInterface<ClientProperty> daocp = new HibernateDAOClientProperty();
    daocp.create(cliPro);

我神奇地得到了我想要的东西。不知道怎么办。

Hibernate: insert into client_characteristic_filled (id_client, id_characteristic, characteristic_value) values (?, ?, ?)
Hibernate: update client set client_activated=?, client_comment=?, client_name=? where client_id=?
Hibernate: update user_properties set property_name=?, property_type=? where property_id=?
Hibernate: update ref_client_to_prop set id_client=? where id_prop=?
Hibernate: insert into ref_client_to_prop (id_client, id_prop) values (?, ?)

Answer 1

在第一种情况下，您在事务内、刚刚从同一事务中保存的图书上设置图书的学生。因此，该书附于本次 session 。因此，Hibernate 会跟踪其状态的所有更改，当您提交时，它会注意到该书的客户端已设置，从而保存关联。

在第二种情况下，您没有任何交易。您创建一个属性，一旦 DAO 的事务完成，该属性就变成一个独立的对象，即 Hibernate 不知道的普通旧对象，其状态根本不被跟踪。然后，您在此分离的对象上设置属性的客户端。但 Hibernate 对此一无所知，因此它不会插入关联。

请注意，设置客户端属性并保存客户端不会保存关联，因为双向关联的拥有方是 Property.client，而不是 Client.properties。而 Hibernate 只关心拥有方。

尽可能避免使用分离的对象。在业务方法的开头启动一个事务，然后使用 Hibernate，仅附加对象，然后提交事务。