五、关系映射

1、第五部分 关系映射映射一对多关联关系映射一对多关联关系 一对多关联关系单项关联：仅仅建立从Order到Customer的多对一关联，即仅仅在Order类中定义customer属性。或者仅仅建立从Customer到Order的一对多关联，即仅仅在Customer类中定义orders集合。双项关联：既建立从Order到Customer的多对一关联，又建立从Customer到Order的一对多关联。单项多对一单项一对多双项多对一建立多对一的单向关联关系 单向 n-1 关联只需从 n 的一端可以访问 1 的一端 域模型: 从 Order 到 Customer 的多对一单向关联需要在Order 类中定义

2、一个 Customer 属性, 而在 Customer 类中无需定义存放 Order 对象的集合属性 关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMERS 表的主键ORDERS 表CUSTOMERS 表建立多对一的单向关联关系Hibernate 使用 元素来映射多对一关联关系many-to-one属性:* name:设定待映射的持久化类的名字。* column:设定和持久化类的属性对应的表的外键。* class:设定持久化类的属性的类型。* not-null:是否允许为空。建立多对一的单向关联关系知识点知识点1:先保存订单，再保存客户先保存订单，再保存客户Hib

3、ernate的输出结果:Hibernate: insert into orders (order_number, price, customer_id) values (?, ?, ?)Hibernate: insert into customers (name) values (?)Hibernate: update orders set order_number=?, price=?, customer_id=? where id=?Jdbc执行执行: * insert into orders (id,order_number, price, customer_id) values (?,

4、 ?, ?,null); * insert into customers (id,name) values (?,?) * c_id=select id from customers * update orders set order_number=?, price=?, customer_id=? where id=?建立多对一的单向关联关系知识点知识点2:先保存客户，再保存订单先保存客户，再保存订单Hibernate的输出结果:Hibernate: insert into customers (name) values (?)Hibernate: insert into orders (o

5、rder_number, price, customer_id) values (?, ?, ?)Jdbc执行执行: * insert into customers (id,name) values (?,?) * c_id=select id from customers * insert into orders (id,order_number, price, customer_id) values (?, ?, ?,cid);建立多对一的单向关联关系知识点知识点3:查询订单查询订单Hibernate的输出结果:Hibernate: select order0_.id as id1_1_,

6、 order0_.order_number as order2_1_1_, order0_.price as price1_1_, order0_.customer_id as customer4_1_1_, customer1_.id as id0_0_, customer1_.name as name0_0_ from orders order0_ left outer join customers customer1_ on order0_.customer_id=customer1_.id where order0_.id=?Jdbc执行执行: SELECT * FROM custom

7、ers c LEFT OUTER JOIN orders o ON(c.id=o.customer_id) WHERE o.id=2建立多对一的单向关联关系知识点知识点4:先保存订单，再保存客户，并且把下面的代码中注释掉先保存订单，再保存客户，并且把下面的代码中注释掉session.save(c),会有什么后果会有什么后果产生如下异常org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushin

8、g: cn.itcast.many2one.Customer建立多对一的单向关联关系 ?知识点知识点4:级联保存和更新当hibernate持久化一个临时对象时，在默认情况下，他不会自动持久化所关联的其他临时对象，会抛出TransientObjectException.如果设定many-to-one元素的cascade属性为save-update的话，可实现自动持久化所关联的对象。建立一对多的双向关联关系双向 1-n 与 双向 n-1 是完全相同的两种情形双向 1-n 需要在 1 的一端可以访问 n 的一端, 反之依然.域模型:从 Order 到 Customer 的多对一单向关联需要在Orde

9、r 类中定义一个 Customer 属性, 而在 Customer 类中需定义存放 Order 对象的集合属性关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键ORDERS 表CUSTOMERS 表建立一对多的双向关联关系Hibernate使用set元素来映射一对多关联关系 元素来映射持久化类的元素来映射持久化类的 set 类型的属性类型的属性name:设定待映射持久化类的属性名。cascade:设定级联操作的程度。key子属性:设定与所关联的持久化类对应的表的外键。 * column: 指定关联表的外键名one-to-many子属性:设定所关联的持久

10、化类(集合中存放的对象)。 * class: 指定关联的持久化类的类名 映射一对多关联关系 Hibernate要求在持久化类中定义集合属性时，必须把属性声明为接口类型，如Set、Map、List.声明为接口类型可提高持久化类的透明性，当hibernate调用setOrders()方法时，传递的参数是Hibernate自定义的实现该接口类的实例。如果定义成类(如HashSet)型，强迫hibernate把该类型的实例传给他。 底层代码: Set orders= PersistentSet class PersistentSet implements java.util.Set 通常在定义集合属性

11、时，直接初始化为一个实现类的实例。 private Set orders = new HashSet(); 可避免空指针异常。知识点知识点5:定义为接口类型建立一对多的双向关联关系知识点知识点6:保存客户和订单保存客户和订单(客户和订单建立双向关联客户和订单建立双向关联)建立一对多的双向关联关系知识点知识点7:保存客户和不保存订单保存客户和不保存订单在下面的代码中注释掉在下面的代码中注释掉session.save(order1),会有什么后果会有什么后果产生如下异常org.hibernate.TransientObjectException: object references an unsa

12、ved transient instance - save the transient instance before flushing: cn.itcast.many2one.Customer建立一对多的双向关联关系知识点知识点7:级联保存和更新 当hibernate持久化一个临时对象时，在默认情况下，他不会自动持久化所关联的其他临时对象，会抛出TransientObjectException.如果设定set元素的cascade属性为save-update的话，可实现自动持久化所关联的对象。 元素来映射持久化类的元素来映射持久化类的 set 类型的属性类型的属性cascade:设定级联操作的

13、程度。建立一对多的双向关联关系知识点知识点8:查询客户和订单查询客户和订单Jdbc实现select customer0_.id as id0_0_, customer0_.name as name0_0_ from customers customer0_ where customer0_.id=?select orders0_.customer_id as customer4_0_1_, orders0_.id as id1_, orders0_.id as id1_0_, orders0_.order_number as order2_1_0_, orders0_.price as pri

14、ce1_0_, orders0_.customer_id as customer4_1_0_ from orders orders0_ where orders0_.customer_id=?建立一对多的双向关联关系知识点知识点8:查询客户和订单查询客户和订单(图图)建立一对多的双向关联关系1、order1关联到关联到customer 而而customer没有关联到没有关联到order12、customer关联到关联到order2 order3 而而order2 order3 没有关联到没有关联到customer问题问题 session.save(order1) 插入几条记录插入几条记录-4

15、session.save(customer) 插入几条记录插入几条记录-3 session.save(order2) 插入几条记录插入几条记录-1知识点知识点9:对象导航对象导航建立一对多的双向关联关系知识点知识点9:对象导航对象导航Order orders1=new Order();orders1.setOrderNumber(o_001);Order orders2=new Order();orders2.setOrderNumber(o_002);Order orders3=new Order();orders3.setOrderNumber(o_003);Customer c=new

16、Customer();c.setName(杨逍);/orders1关联关联c c不关联不关联order1orders1.setCustomer(c);/c关联关联order2和和order3 order2和和order3不关联不关联cc.getOrders().add(orders2);c.getOrders().add(orders3);/session.save(orders2);session.save(orders1);建立一对多的双向关联关系知识点知识点10:保持程序的健壮性保持程序的健壮性Order orders1=new Order();orders1.setOrderNumbe

17、r(o_001);Customer c=new Customer();c.setName(杨逍);/订单和客户关联orders1.setCustomer(c);/客户和订单关联 /c.getOrders().add(orders1); 这句话是否是可有可无的,为了保持程序的健壮性,加上/保存客户session.save(c);/保存订单session.save(orders1);方法名(Customer c) c.getOrders().size.=0 这是在使用订单的时候就关联不上订单了建立一对多的双向关联关系更改订单表id=6的customer_id=3更改为4上面的代码产生两条updat

18、e语句 ,如何产生一条语句呢,完成上面的功能呢?Hibernate: update orders set order_number=?, price=?, customer_id=? where id=?Hibernate: update orders set customer_id=? where id=?知识点知识点11:订单订单变更客户变更客户建立一对多的双向关联关系更改订单表id=6的customer_id=3更改为4* 使用session缓存的监控功能讲解为什么产生两条update语句Hibernate会自动清理缓存中的所有持久化对象，按照持久化对象的改变来同步更新数据库，因此执行了

19、上述的两条更新语句所以会产生两条update语句知识点知识点11:订单订单变更客户变更客户建立一对多的双向关联关系 在hibernate中通过对 inverse 属性的值决定是由双向关联的哪一方来维护表和表之间的关系. inverse=false 的为主动方，inverse=true 的为被动方, 由主动方负责维护关联关系 在没有设置 inverse=true 的情况下，父子两边都维护父子关系 在 1-n 关系中，将 n 方设为主控方将有助于性能改善(如果要国家元首记住全国人民的名字，不是太可能，但要让全国人民知道国家元首，就容易的多) 在 1-N 关系中，若将 1 方设为主控方 会额外多出

20、update 语句。知识点知识点11:set中中inverse属性属性建立一对多的双向关联关系/查询客户Customer c4=(Customer)session.load(Customer.class, 4);/查询订单Order o6=(Order)session.load(Order.class, 6);/建立关联关系o6.setCustomer(c4);/c4.getOrders().add(o6); /加上和不加没有影响加上和不加没有影响(不按照集合的变化来更新数据库不按照集合的变化来更新数据库)-以上代码仅设置了order对象的customer属性，hibernate仍然会按照or

21、der对象的状态的变化来同步更新数据库，执行以下sql语句：Update orders set order_number=,customer_id=2where id = 2知识点知识点11:set中中inverse属性属性建立一对多的双向关联关系/查询客户Customer c4=(Customer)session.load(Customer.class, 4);/查询订单Order o6=(Order)session.load(Order.class, 6);/建立关联关系/o6.setCustomer(c4); /去掉去掉(有影响不会更新有影响不会更新)c4.getOrders().add

22、(o6); -以上代码仅设置了customer对象的orders属性，由于元素的inverse属性为true，因此，hibernate不会按照customer对象的状态变化来同步更新数据库。知识点知识点11:set中中inverse属性属性建立一对多的双向关联关系结论：1.在映射一对多的双向关联关系时，应该在one方把inverse属性设为true(被动方)， 这可以提高性能。2.在建立两个对象的关联时，应该同时修改关联两端的相应属性： customer.getOrders().add(order); order.setCustomer(customer);这样才会使程序更加健壮，提高业务逻辑

23、层的独立性，使业务逻辑层的程序代码不受Hibernate实现类的影响。同理，当删除双向关联的关系时，也应该修改关联两端的对象的相应属性：Customer.getOrders().remove(order);Order.setCustomer(null);知识点知识点11:set中中inverse属性属性建立一对多的双向关联关系知识点知识点12:解除关联关系解除关联关系解除6号订单和3号客户的关联建立一对多的双向关联关系知识点知识点13:级联删除删除1号客户的同时，删除1号客户所关联的订单如果如果cascade属性取默认值属性取默认值none，不会自动删除和，不会自动删除和customer关联的

24、其他持久化对象。如关联的其他持久化对象。如果希望删除果希望删除customer时，自动删除和时，自动删除和customer关联的关联的order对象，可把对象，可把cascade属性设属性设为为delete。 再运行删除方法的时候，会自动删除order对象，此时hibernate执行如下语句：delete from orders where customer_id = 1;delete customers where id = 1;delete from orders where id=1建立一对多的双向关联关系知识点知识点14:理解什么是理解什么是父子关系所谓父子关系：是指父方来控制子方的持

25、久化生命周期，子方对象必须和一个父方对象关联。Customer(父方)Order(子方)建立一对多的双向关联关系知识点知识点14:解除关联关系解除关联关系 -父子关系 解除6号订单和3号客户的关联,同时删除6号订单/查询客户Customer c3=(Customer)session.load(Customer.class, 3);/查询订单Order o6=(Order)session.load(Order.class, 6);/设置订单关联的客户为nullo6.setCustomer(null); /儿子不由父亲行使监护权/从客户集合删除订单c3.getOrders().remove(o6)

26、; /父亲从户口本上将该儿子除名mit();-如果cascade为默认值none，hibernate会执行如下语句：update orders set Customer_id = null where ID = 2;如果希望程序自动删除不再和如果希望程序自动删除不再和customer关联的关联的order对象，可以把对象，可以把cascade属性设为属性设为all-delete-orphan 或或 delete-orphan delete from orders where id=6建立一对多的双向关联关系知识点知识点14:解除关联关系解除关联关系 -父子关系当customer.hbm.xml

27、的元素的cascade属性取值为all-delete-orphan, Hibernate会按照如下方式处理customer对象：1.当保存或更新customer对象时，级联保存或更新所有关联的order对象， 相当于save-update.2.当删除customer对象时，级联删除所有的order对象，相当于delete。3.删除不再和customer对象关联的所有order对象。 当关联双方存在父子关系时，就可以把父方的cascade属性设为all-delete-orphan.cascade 属属性性在对象在对象 关系映射文件中关系映射文件中, 用于映射持久化类之间关联关系的元素用于映射持久

28、化类之间关联关系的元素, , 和和 都有一个都有一个 cascade 属属性性, 它用于指定如何操纵与当前对象关联的其他对象它用于指定如何操纵与当前对象关联的其他对象. 建立一对多的双向关联关系 元素有一个 order-by 属性, 如果设置了该属性, 当 Hibernate 通过 select 语句到数据库中检索集合对象时, 利用 order by 子句进行排序 order-by 属性中还可以加入 SQL 函数知识点知识点15:在数据库中对集合排序映射一对一关联关系映射一对一关联关系映射一对一外键双向关联 一对一关联指两个表之间的记录是一一对应的关系。分为两种：外键关联和主键关联。 比如一家

29、公司(Company)和它所在的地址(Address)。在业务逻辑中要求一家公司只有唯一的地址，一个地址也只有一家公司。 下图表现为外键关联关系。fkpk唯一映射一对一外键双向关联对于基于外键的1-1关联，其外键可以存放在任意一边，在需要在需要存放外键一端，增加存放外键一端，增加 many-to-one many-to-one 元素元素。为 many-to-one元素增加 unique=“true” 属性来表示为1-1关联，并用name属性来指定关联属性的属性名另一端需要使用one-to-one元素，该元素使用 property-property-ref(ref(可以不加) ) 属性指定使用被

30、关联实体主键以外的字段作为关联字段映射一对一外键双向关联映射一对一外键双向关联public void insert()Session session=sessionFacoty.openSession();Transaction tx=session.beginTransaction(); Company company=new Company();company.setName(“丝路);Address address=new Address();address.setCity(“西安);address.setCountry(中国);company.setAddress(address);a

31、ddress.setCompany(company);session.save(address);session.save(company);mit(); session.close(); 知识点1:测试保存测试保存映射一对一外键双向关联public void insertUnique()Session session=sessionFacoty.openSession();Transaction tx=session.beginTransaction(); /创建公司Company company=new Company();company.setName(“BaoGang);/查询地址Ad

32、dress address=(Address)session.load(Address.class, 1);/建立双向关联company.setAddress(address);address.setCompany(company);/保存公司session.save(company);mit(); session.close(); 知识点2:测试唯一性测试唯一性 映射一对一主键双向关联 一对一的另一种解决方式就是主键关联，在这种关联关系中，要求两个对象的主键必须保持一致，通过两个表的主键建立关联关系，无须外键参与。 映射一对一主键双向关联基于主键的映射策略:指一端的主键生成器使用 forei

33、gn 策略,表明根据”对方”的主键来生成自己的主键，自己并不能独立生成主键. 子元素指定使用当前持久化类的哪个属性作为 “对方”采用foreign主键生成器策略的一端增加 one-to-one 元素映射关联属性，其 one-to-one 属性还应增加 constrained=“true” 属性；另一端(company)增加one-to-one元素映射关联属性。constrained(约束):指定为当前持久化类对应的数据库表的主键添加一个外键约束，引用被关联的对象(“对方”)所对应的数据库表主键 映射一对一主键双向关联 映射一对一主键双向关联public void insert()Session

34、 session=sessionFacoty.openSession();Transaction tx=session.beginTransaction(); Company company=new Company();company.setName(“SoftRoad);Address address=new Address();address.setCity(“Xian);address.setCountry(“China);company.setAddress(address);address.setCompany(company);session.save(address);sessi

35、on.save(company);mit(); session.close(); 知识点3:测试保存测试保存映射多对多双向关联关系 映射多对多双向关联关系 多对多的实体关系模型也是很常见的，比如学生和课程的关系。一个学生可以选修多门课程，一个课程可以被多名学生选修。在关系型数据库中对于多对多关联关系的处理一般采用中间表的形式，将多对多的关系转化成两个一对多的关系。 映射多对多双向关联关系双向 n-n 关联需要两端都使用集合属性双向n-n关联必须使用中间表集合属性应增加 key 子元素用以映射外键列, 集合元素里还应增加many-to-many子元素关联实体类在双向 n-n 关联的两边都需指定连

36、接表的表名及外键列的列名. 两个集合元素 set 的 table 元素的值必须指定，而且必须相同。 映射多对多双向关联关系 set元素的两个子元素：key 和 many-to-many 都必须指定 column 属性， 其中，key 和 many-to-many 分别指定本持久化类和关联类在连接表中的外键列名， 因此两边的 key 与 many-to-many 的column属性交叉相同。也就是说，一边的set元素的key的 cloumn值为a,many-to-many 的 column 为b；则另一边的 set 元素的 key 的 column 值 b,many-to-many的 colum

37、n 值为 a. 对于双向对于双向 n-n 关联关联, 须把其中一端的须把其中一端的 inverse 设置为设置为 true, 否则可能会造成主键冲突否则可能会造成主键冲突. 映射多对多双向关联关系 映射多对多双向关联关系public void saveMany2Many()Course c1=new Course(语文);Course c2=new Course(数学);Student s1=new Student(张飞);Student s2=new Student(关羽);c1.getStus().add(s1);c1.getStus().add(s2);c2.getStus().add(

38、s1);c2.getStus().add(s2);s1.getCourses().add(c1);s1.getCourses().add(c2);s2.getCourses().add(c1);s2.getCourses().add(c2);session.save(s1);session.save(s2);session.save(c1);session.save(c2);知识点4:测试保存测试保存 映射多对多双向关联关系解除解除1号学生和号学生和1号课程的关联关系号课程的关联关系public void removeMany2Many()Session session=sessionFaco

39、ty.openSession();Transaction tx=session.beginTransaction(); Student s=(Student)session.load(Student.class, 1);Course c=(Course)session.load(Course.class, 1);s.getCourses().remove(c);c.getStus().remove(s);mit(); session.close(); 以上代码会产生delete语句,删除中间表的数据 delete from student_course where cid=? and sid=

40、?知识点5:解除解除1号学生和号学生和1号课程的关联关系号课程的关联关系 映射多对多双向关联关系改变改变1号学生和号学生和2号课程的关联关系号课程的关联关系,改为改为1号学生和号学生和1号课程号课程public void changeMany2Many()Session session=sessionFacoty.openSession();Transaction tx=session.beginTransaction(); Student s1=(Student)session.load(Student.class, 1);Course c1=(Course)session.load(Cou

41、rse.class, 1);Course c2=(Course)session.load(Course.class, 2);/解除1号学生和2号课程的关联关系s1.getCourses().remove(c2);c2.getStus().remove(s1);/设置1号学生和1号课程的关联关系s1.getCourses().add(c1);c1.getStus().add(s1);mit(); session.close(); 以上代码先在中间表插入1 1 再删除1 2 insert into student_course (cid, sid) values (?, ?) delete fro

42、m student_course where cid=? and sid=?知识点6:改变改变1号学生和号学生和2号课程的关联关系号课程的关联关系,改为改为1号学生和号学生和1号课程号课程 映射多对多双向关联关系/删除删除2号学生号学生public void removeStudent()Session session=sessionFacoty.openSession();Transaction tx=session.beginTransaction(); /此时不能删除，出现外键关联异常Student s2=(Student)session.load(Student.class, 2);s

43、ession.delete(s2);mit(); session.close(); 知识点7:删除删除2号学生号学生 映射多对多双向关联关系删除删除1号课程号课程,对应的中间表的对应的中间表的1号课程的信息将被删除号课程的信息将被删除public void removeCourse()Session session=sessionFacoty.openSession();Transaction tx=session.beginTransaction(); /此时可以删除,因为course一端是主控方，不用使用级联删除配置Course c1=(Course)session.load(Course

44、.class, 1);session.delete(c1);mit(); session.close()知识点8:删除删除1号课程号课程 映射多对多双向关联关系级联删除级联删除public void removeCourseCascade()Session session=sessionFacoty.openSession();Transaction tx=session.beginTransaction(); Course c1=(Course)session.load(Course.class, 1);session.delete(c1);mit(); session.close(); /

45、这不能级联删除因为这不能级联删除因为2号课程还应用号课程还应用1 2号学生号学生知识点9:删除1号课程的同时,要把1号和2号学生删掉？映射继承关系映射继承关系EmployeeidnameHourEmployeerateSalaryEmployeesalary映射继承关系 Hibernate支持三种继承映射策略： 每个具体类一张表(table per concrete class) 将域模型中的每一个实体对象映射到一个独立的表中，也就是说不用在关系数据模型中考虑域模型中的继承关系和多态。 每个类分层结构一张表(table per class hierarchy) 对于继承关系中的子类使用同一个表

46、，这就需要在数据库表中增加额外的区分子类类型的字段。 每个子类一张表(table per subclass) 域模型中的每个类映射到一个表，通过关系数据模型中的外键来描述表之间的继承关系。这也就相当于按照域模型的结构来建立数据库中的表，并通过外键来建立表之间的继承关系。采用 subclass 元素的继承映射id:员工编号etype:员工类型(he 小时工，se 正式员工,ee刚入职的员工)name:员工姓名rate:小时工的工资salary:正式员工的工资父类和子类使用同一张表父类和子类使用同一张表pk区分类型的字段采用 subclass 元素的继承映射 采用采用 subclass 的继承映射

47、可以实现的继承映射可以实现对于继承关系中对于继承关系中父父类和子类使用同一张表类和子类使用同一张表 因为父类和子类的实例全部保存在同一个表中，因此需需要在该表内增加一列要在该表内增加一列，使用该列来区分每行记录到底是哪个类的实例-这个列被称为辨别者列(discriminatordiscriminator). 在这种映射策略下，使用使用 subclass subclass 来映射子类来映射子类，使用使用 class class 或或 subclass subclass 的的 discriminator-value discriminator-value 属性指属性指定辨别者列的值定辨别者列的值

48、所有子类定义的字段都不能有非空约束所有子类定义的字段都不能有非空约束。如果为那些字段添加非空约束，那么父类的实例在那些列其实并没有值，这将引起数据库完整性冲突，导致父类的实例无法保存到数据库中采用 subclass 元素的继承映射采用 subclass 元素的继承映射知识点1: 保存员工信息public void saveEmployee() Employee e=new Employee(); e.setName(xxxx); HourEmployee h=new HourEmployee(); h.setName(zhang); h.setRate(10d); SalaryEmployee

49、 s=new SalaryEmployee(); s.setName(wu); s.setSalary(1000d); session.save(e); session.save(h); session.save(s);采用 subclass 元素的继承映射知识点2: 查询钟点工信息public void findHourEmployee() Session session=sessionFacoty.openSession(); Transaction tx=session.beginTransaction(); Query query=session.createQuery(from Ho

50、urEmployee); query.list(); mit(); session.close(); 采用 joined-subclass 元素的继承映射l关系树的每个类对应一个表主表 id是主键子表: eid是主键,同时又是外键.参照主表的id子表: eid是主键,同时又是外键.参照主表的id表和表之间存在主表和子表的概念采用 joined-subclass 元素的继承映射 采用 joined-subclass 元素的继承映射可以实现每个子类一张表 采用这种映射策略时，父类实例保存在父类表中，子类实例由父类表和子类表共同存储。因为子类实例也是一个特殊的父类实例，因此必然也包含了父类实例的属性

51、。于是将子类和父类共有的属性保存在父类表中，子类增加的属性，则保存在子类表中。 在这种映射策略下，无须使用鉴别者列，但需要为每个子类使用 key 元素映射共有主键，该主键必须与父类标识属性的列名相同。但如果继承树的深度很深，可能查询一个子类实例时，需要跨越多个表，因为子类的数据一次保存在多个父类中。 子类增加的属性可以添加非空约束。因为子类的属性和父类的属性没有保存在同一个表中采用 joined-subclass 元素的继承映射采用 joined-subclass 元素的继承映射知识点3: 保存员工信息public void saveEmployee() Employee e=new Empl

52、oyee(); e.setName(xxxx); HourEmployee h=new HourEmployee(); h.setName(zhang); h.setRate(10d); SalaryEmployee s=new SalaryEmployee(); s.setName(wu); s.setSalary(1000d); session.save(e); session.save(h); session.save(s);采用 joined-subclass 元素的继承映射知识点4: 查询钟点工信息public void findHourEmployee() Session sess

53、ion=sessionFacoty.openSession(); Transaction tx=session.beginTransaction(); Query query=session.createQuery(from HourEmployee); query.list(); mit(); session.close(); 采用 joined-subclass 元素的继承映射知识点5: 查询员工信息public void findEmployee() Session session=sessionFacoty.openSession(); Transaction tx=session.beginTransaction(); Query query=session.createQuery(from Employee); query.list(); mit(); session.close(); 采用 joined-subclass 元素的继承映