如何更新和删除休眠一对一映射中的记录？答案

【问题标题】：how to update and delete a record in hibernate one to one mapping?如何更新和删除休眠一对一映射中的记录？
【发布时间】：2013-10-31 19:06:56
【问题描述】：

谁能告诉我一个在一对一的休眠映射中更新和删除记录的例子吗？

我有 2 个表 customer 和 customeraddress。我可以使用以下代码在两个表中添加记录

customerForm.setcustomerAddress(customerAddress);
customerAddress.setCustomer(customerForm);
getEntityManager().persist(customerForm);

现在我要删除和更新记录。

@Entity
@Table(name="customers")
public class Customer {
@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name="id")
public int getId() {
    return id;
}
@Column(name="customerName")
public String getcustomerName() {
    return customerName;
}
@Column(name="password")
public String getpassword() {
    return password;
}


@OneToOne(mappedBy = "customer", cascade = CascadeType.ALL)  
public CustomerAddess getcustomerAddress() {
    return customerAddress;
}
//rest setter getter.....

}

@Entity
@Table(name="customer_address")
public class CustomerAddess {
@Id
@GeneratedValue(generator = "gen")  
@GenericGenerator(name = "gen", strategy = "foreign", parameters =    @org.hibernate.annotations.Parameter(name = "property", value = "customer"))  
@Column(name="id")
public int getId() {
    return id;
}

@Column(name="street_address")
public String getstreet_address() {
    return street_address;
}
@OneToOne(fetch = FetchType.EAGER)
@PrimaryKeyJoinColumn  
public Customer getCustomer() {
    return customer;
}

//rest setter getter

【问题讨论】：

你在这里混合了 Hibernate 和 JPA。你是如何定义你的映射的？每个 XML？带注释？您能否添加您对客户/地址的定义？关于删除问题：您可以查看 EntityManager#remove 方法。关于更新：只需修改打开事务中的附加实体。您可以使用 EntityManager#merge 重新附加分离的实体。
我用注释定义了映射。我们可以只使用一次 entitymanager.merge 和 remove 方法，比如对客户和地址表单都持久化吗？
这取决于你的Mapping（你可以搜索Cascade）。如果您编辑您的问题并提供您的映射，我或许可以为您提供帮助。
我加了一些代码……希望够了……是吗？

标签： hibernate hibernate-mapping

【解决方案1】：

我以您的示例创建了两个简单的测试套件，可以让您大致了解如何持久化/更新/删除实体。

我还稍微修改了您的实体（如果注释在 getter/setter 之上，我不喜欢它，所以我将它们放在字段之上，并为 getter/setter 应用了 javabeans 约定，并删除了一些拼写错误）。有一些 cmets 也可以给你一些提示。

CascadeAllTests：

@OneToOne(mappedBy = "customer", cascade = CascadeType.ALL)
    CustomerAddress customerAddress;



public class CascadeAllTests {
    private EntityManager em;

    @Before
    public void before() {
        final EntityManagerFactory emf = Persistence
                .createEntityManagerFactory("pu");
        em = emf.createEntityManager();
    }

    @After
    public void after() {
        em.close();
        em = null;
    }

    @Test
    public void persist() {
        Customer c = new Customer();
        c.setCustomerName("cName");
        c.setPassword("cPass");
        CustomerAddress addr = new CustomerAddress();
        addr.setCustomer(c);
        addr.setStreetAddress("Addr");
        c.setCustomerAddress(addr);

        em.getTransaction().begin();
        em.persist(c); // it is not necessary to call em.persist(addr)
        em.getTransaction().commit();

        Customer cStored = em.find(Customer.class, c.getId());
        assertNotNull(cStored);
        assertEquals(c.getCustomerName(), cStored.getCustomerName());
        assertEquals(addr.getStreetAddress(), cStored.getCustomerAddress()
                .getStreetAddress());
    }

    @Test
    public void update() {
        Customer c = new Customer();
        c.setCustomerName("cName");
        c.setPassword("cPass");
        CustomerAddress addr = new CustomerAddress();
        addr.setCustomer(c);
        addr.setStreetAddress("Addr");
        c.setCustomerAddress(addr);

        em.getTransaction().begin();
        em.persist(c);
        em.getTransaction().commit();

        em.detach(c); // c and c.customerAddress are detached now.

        addr.setStreetAddress("New address");
        c.setCustomerName("New Name");
        em.getTransaction().begin();
        c = em.merge(c);
        em.getTransaction().commit();
        // due to CascadeType.ALL on Customer.customerAddress the new address is
        // stored now

        Customer cStored = em.find(Customer.class, c.getId());
        assertNotNull(cStored);
        assertEquals(c.getCustomerName(), cStored.getCustomerName());
        assertEquals(addr.getStreetAddress(), cStored.getCustomerAddress()
                .getStreetAddress());
    }

    @Test
    public void deleteAddressOnly() {
        Customer c = new Customer();
        c.setCustomerName("cName");
        c.setPassword("cPass");
        CustomerAddress addr = new CustomerAddress();
        addr.setCustomer(c);
        addr.setStreetAddress("Addr");
        c.setCustomerAddress(addr);

        em.getTransaction().begin();
        em.persist(c);
        em.getTransaction().commit();

        em.detach(c); // c and c.customerAddress are detached now

        em.getTransaction().begin();
        c = em.merge(c); // c and c.customerAddress are attached again
        em.remove(c.getCustomerAddress());
        c.setCustomerAddress(null);
        em.getTransaction().commit();
        // due to CascadeType.ALL on Customer.customerAddress the new address is
        // stored now

        Customer cStored = em.find(Customer.class, c.getId());
        CustomerAddress addrStored = em.find(CustomerAddress.class,
                addr.getId());
        assertNotNull(cStored);
        assertEquals(c.getCustomerName(), cStored.getCustomerName());
        assertNull(cStored.getCustomerAddress());
        assertNull(addrStored);
    }
}

CascadeNoneTests：

@OneToOne(mappedBy = "customer", cascade = {})
    CustomerAddress customerAddress;

public class CascadeNonTests {
    private EntityManager em;

    @Before
    public void before() {
        final EntityManagerFactory emf = Persistence
                .createEntityManagerFactory("pu");
        em = emf.createEntityManager();
    }

    @After
    public void after() {
        em.close();
        em = null;
    }

    @Test
    public void persist() {
        Customer c = new Customer();
        c.setCustomerName("cName");
        c.setPassword("cPass");
        CustomerAddress addr = new CustomerAddress();
        addr.setCustomer(c);
        addr.setStreetAddress("Addr");
        c.setCustomerAddress(addr);

        em.getTransaction().begin();
        em.persist(c);
        em.persist(addr); // has to be called explicitly
        em.getTransaction().commit();

        Customer cStored = em.find(Customer.class, c.getId());
        assertNotNull(cStored);
        assertEquals(c.getCustomerName(), cStored.getCustomerName());
        assertEquals(addr.getStreetAddress(), cStored.getCustomerAddress()
                .getStreetAddress());
    }

    @Test
    public void update() {
        Customer c = new Customer();
        c.setCustomerName("cName");
        c.setPassword("cPass");
        CustomerAddress addr = new CustomerAddress();
        addr.setCustomer(c);
        addr.setStreetAddress("Addr");
        c.setCustomerAddress(addr);

        em.getTransaction().begin();
        em.persist(c);
        em.persist(addr);// has to be called explicitly
        em.getTransaction().commit();

        em.detach(c);
        em.detach(addr); // c and c.customerAddress are detached now.

        addr.setStreetAddress("New address");
        c.setCustomerName("New Name");
        em.getTransaction().begin();
        c = em.merge(c);
        addr = em.merge(addr);
        em.getTransaction().commit();

        Customer cStored = em.find(Customer.class, c.getId());
        assertNotNull(cStored);
        assertEquals(c.getCustomerName(), cStored.getCustomerName());
        assertEquals(addr.getStreetAddress(), cStored.getCustomerAddress()
                .getStreetAddress());
    }

    @Test
    public void deleteAddressOnly() {
        Customer c = new Customer();
        c.setCustomerName("cName");
        c.setPassword("cPass");
        CustomerAddress addr = new CustomerAddress();
        addr.setCustomer(c);
        addr.setStreetAddress("Addr");
        c.setCustomerAddress(addr);

        em.getTransaction().begin();
        em.persist(c);
        em.persist(addr);// has to be called explicitly
        em.getTransaction().commit();

        em.detach(c);
        em.detach(addr); // c and c.customerAddress are detached now.

        em.getTransaction().begin();
        c = em.merge(c);
        addr = em.merge(addr);
        em.remove(c.getCustomerAddress());
        c.setCustomerAddress(null);
        em.getTransaction().commit();

        Customer cStored = em.find(Customer.class, c.getId());
        CustomerAddress addrStored = em.find(CustomerAddress.class,
                addr.getId());
        assertNotNull(cStored);
        assertEquals(c.getCustomerName(), cStored.getCustomerName());
        assertNull(cStored.getCustomerAddress());
        assertNull(addrStored);
    }
}

【讨论】：