hibernate学习（5）——一对多关系表达
一对多实现
1、 实现类
package com.alice.hibernate02.vo; import java.util.HashSet; import java.util.Set; public class Customer { private Integer id; private String name; // 一对多：一个客户（当前客户） 拥有 【多个订单】 // * 需要容器存放多个值，一般建议Set （不重复、无序） // * 参考集合：List、Map、Array等 // ** 建议实例化--使用方便 private Set<Order> orders = new HashSet<Order>();
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 Set<Order> getOrders() { return orders; } public void setOrders(Set<Order> orders) { this.orders = orders; } }
package com.alice.hibernate02.vo;
public class Order {
private Integer id;
private String name;
//多对一：多个订单属于【一个客户】
private Customer customer;
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 Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
}
2、 配置文件
<?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.alice.hibernate02.vo"> <class name="Customer" table="t_customer"> <id name="id" column="id"> <generator class="native"></generator> </id> <property name="name" column="name" type="string"></property> <!-- 表达一对多关系中的集合 name:集合的属性名称 inverse: 是否将关系的维护反转给对方. 默认值: false true: 在Customer 中 放弃维护外键关系 cascade :级联操作 save-update：级联保存,级联修改. 保存A时,同时保存B. delete：删除A，同时删除B，AB都不存在 delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。 如果需要配置多项，使用逗号分隔。<set cascade="save-update,delete"> all : save-update 和 delete 整合 all-delete-orphan : 三个整合 --> <set name="orders"> <!-- key 用来描述外键 column : 外键的值 --> <key column="cid"></key> <one-to-many class="Order"/> </set> </class> </hibernate-mapping>
<?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.alice.hibernate02.vo"> <class name="Order" table="t_order"> <id name="id" column="id"> <generator class="native"></generator> </id> <property name="name" column="name" type="string"></property> <!-- 表达一对多关系中的集合 name:集合的属性名称 inverse: 是否将关系的维护反转给对方. 默认值: false true: 在Customer 中 放弃维护外键关系 cascade :级联操作 save-update：级联保存,级联修改. 保存A时,同时保存B. delete：删除A，同时删除B，AB都不存在 delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。 如果需要配置多项，使用逗号分隔。<set cascade="save-update,delete"> all : save-update 和 delete 整合 all-delete-orphan : 三个整合 --> <!-- 表达多对一关系 name: 引用的属性名称 column: 外键的列名 class: 我引用的Order的完整类名 --> <many-to-one name="customer" column="cid" class="Customer"></many-to-one> </class> </hibernate-mapping>
3、一对多操作
1 public void test01() { 2 Session session = HibernateUtil.openSession(); 3 Transaction tran = session.beginTransaction(); 4 5 Customer cus = new Customer(); 6 cus.setName("alice"); 7 8 Order o1 = new Order(); 9 o1.setName("apple"); 10 11 Order o2 = new Order(); 12 o2.setName("banana"); 13 14 cus.getOrders().add(o1);// 维护关系 15 cus.getOrders().add(o2);// 维护关系 16 17 o1.setCustomer(cus); 18 o2.setCustomer(cus); 19 20 session.save(cus);//保存对象 21 session.save(o1);//保存对象 22 session.save(o2);//保存对象 23 24 tran.commit(); 25 26 session.close(); 27 28 }
4、 级联操作（读、理解）
save-update：A保存，同时保存B
delete：删除A，同时删除B，AB都不存在
delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。
如果需要配置多项，使用逗号分隔。<set cascade="save-update,delete">
all : save-update 和 delete 整合
all-delete-orphan : 三个整合
package com.alice.hibernate02.many; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.alice.hibernate02.util.HibernateUtil; import com.alice.hibernate02.vo.Customer; import com.alice.hibernate02.vo.Order; //测试 一对多关系 public class ManyTest02 { @Test //增 //我们希望在保存Customer时,自动将未保存的Orders当中的Order保存 //cascade: save-update public void test01() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = new Customer(); cus.setName("alice"); Order o1 = new Order(); o1.setName("apple"); Order o2 = new Order(); o2.setName("banana"); cus.getOrders().add(o1);// 维护关系 cus.getOrders().add(o2);// 维护关系 // o1.setCustomer(cus); // o2.setCustomer(cus); session.save(cus);//保存对象 // session.save(o1);//保存对象 // session.save(o2);//保存对象 tran.commit(); session.close(); } @Test //增 //我们希望在保存Customer时,自动将未保存的Orders当中的Order保存 //cascade: save-update public void test02() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.get(Customer.class, 2);//1条 select for(Order o :cus.getOrders()){// 1条 select o.setName("mike");// 修改订单 } tran.commit();//因为设置级联修改,自动将订单的修改保存到数据 session.close(); } //cascade: delete //删除Customer时 ,会将Customer下的订单一并删除 //inverse : false 6条sql语句 //inverse : true 5条sql语句 比上面少一条维护外键 @Test public void test03() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.get(Customer.class, 3);//1条 select session.delete(cus);//删除Customer // 删除两个Order tran.commit();//因为设置级联修改,自动将订单的修改保存到数据 session.close(); } //cascade: delete //操作的两方cascade值都为delete //需要注意: 千万不要在两方都配置 级联删除. 删除任何一方,会导致整个关系链对象全部删除. @Test public void test04() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Order o =(Order) session.get(Order.class, 6); session.delete(o);//删除Customer // 删除两个Order tran.commit();//因为设置级联修改,自动将订单的修改保存到数据 session.close(); } }
package com.alice.hibernate02.many; import java.util.Iterator; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.alice.hibernate02.util.HibernateUtil; import com.alice.hibernate02.vo.Customer; import com.alice.hibernate02.vo.Order; //测试 一对多关系 public class ManyTest03 { @Test //inverse:false //cascade: delete-orphan 孤儿删除 => 当没有任何外键引用Order时,order 会被删除 public void test02(){ Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.get(Customer.class, 4); Iterator<Order> iter = cus.getOrders().iterator(); //注意: 删除Customer下的订单时,不能使用 c.setOrders(null); c.setOrders(new HashSet()); while(iter.hasNext()){// 遍历Customer下的订单,并将订单删除 => 维护关系 iter.next(); iter.remove(); } //cascade: all-delete-orphan => 相当于配置 save-update,delete,delete-orphan } //cascade: all-delete-orphan => 相当于配置 save-update,delete,delete-orphan @Test public void fun1(){ Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); //------------------------------------------------ Customer c = new Customer(); c.setName("tom"); Order o1 = new Order(); o1.setName("肥皂"); Order o2 = new Order(); o2.setName("蜡烛"); c.getOrders().add(o1);//维护关系 c.getOrders().add(o2); //维护关系 session.save(c); //------------------------------------------------ session.getTransaction().commit(); session.close(); // 游离状态 } }
