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 (?, ?)

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

P.S。增加混乱：

当我使用这个课时：

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

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

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

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

尽量避免使用分离的对象。在业务方法开始时启动事务，然后使用Hibernate，只附加对象，然后提交事务。

休眠，无法保存多对一的关系

1 个答案: