发现了一篇和我类似的学习尚硅谷视频写的文章，内容如下，比我说的详细全面，可以看一下：
[原创]java WEB学习笔记87：Hibernate学习之路-- -映射 继承关系(subclass , joined-subclass,union-subclass )
抄一段对三种继承关系的解释：
Java类中有继承关系，相应的在hibernate中，也有继承关系，子类反应到数据库中，就有多种实现形式了，子类和父类可以映射到同一张表中，子类也可以单独映射成一张表，但是用不同的标签实现，子类表和父类表的关系也不同。在映射文件中，有三个标签可以实现继承关系，分别是：subclass、joined-subclass、union-subclass，先陈述一下这三个标签的区别：
subclass标签就是为子类嵌入父类的表中而设计的，而且要指定鉴别器，即用subclass一定要有判断类型的一个列，鉴别器指定记录属于哪个类型。但是subclass也提供了为子类设置单独的表的功能，即join标签。但是不管是内嵌表还是外部表，都得指定鉴别器。
joined-subclass标签，提供的功能是只能为子类设定外部表，而且没有鉴别器，即子类一张表，父类一张表，子类以父类的主键为外键。父类对应的表中，没有判断类型的列。
注意：这两个标签不能混用，若是只想要内嵌表，或者是既想要有内嵌表，又想要外部表，又或者是只想要外部表，那么只能使用subclass标签，需要注意的是，不论哪种方式，都要指定鉴别器，即父类对应的表中，一定有一个判断类型的列；而若是只想要外部表，又不想在父类对应的表中，要那个判断类型的列，那么只能使用join-subclass。
union-subclass是将父类中的属性，添加到子类对应的表中去了。包括父类中的外键。union-class和前两个的区别就在于外键的不同，前两个标签，如果子类有单独对应的表的话，这个表的外键是其父类中的主键，而使用union-class，子类对应的表中的外键则和父类的外键是一样的，因为子类把父类继承的属性，也加到了自己的表当中。这样子类和父类的地位就相当了。不过这不是一种好的理解方式。如果是这样的话，那么就可以把父类设为抽象的类，并且在映射文件中，把父类设置为abstract="true"，那么就不会再数据库中生成父类对应的表了，父类就只起到一个抽象的作用了。
下面看一下简单的例子：
subclass：
Person类
package subclass; public class Person { private Integer id; private String name; private int age; 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 int getAge() { return age; } public void setAge(int age) { this.age = age; } }
Student类
package subclass; public class Student extends Person { private String school; public String getSchool() { return school; } public void setSchool(String school) { this.school = school; } }
Person.hbm.xml
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2017-7-23 15:37:20 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping package="subclass"> <class name="Person" table="PERSON" discriminator-value="person"> <!-- Person对象对应的辨别者列的值 --> <id name="id" type="java.lang.Integer"> <column name="ID" /> <generator class="native" /> </id>
<!-- 辨别者列 --> <discriminator column="TYPE" type="string"></discriminator> <property name="name" type="java.lang.String"> <column name="NAME" /> </property> <property name="age" type="int"> <column name="AGE" /> </property> <subclass name="Student" discriminator-value="student"> <!-- Student对象对应的辨别者列的值 --> <property name="school" type="string" column="SCHOOL"></property> </subclass> </class> </hibernate-mapping>
会生成一张表，包括父类和子类的所有字段，用一个辨别者列来区分是父类还是子类的数据，当为父类数据时，相应的子类数据为null。
HibernateTest类
package subclass; import java.util.List; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import org.hibernate.service.ServiceRegistry; import org.hibernate.service.ServiceRegistryBuilder; import org.junit.After; import org.junit.Before; import org.junit.Test; public class HibernateTest { private SessionFactory sessionFactory; private Session session; private Transaction transaction; @Before public void init() { System.out.println("init"); // 1. 创建一个SessionFactory对象 sessionFactory = null; Configuration configuration = new Configuration().configure(); // before 4.0 // sessionFactory = configuration.buildSessionFactory(); ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()) .buildServiceRegistry(); sessionFactory = configuration.buildSessionFactory(serviceRegistry); // 2. 创建一个Session 对象 session = sessionFactory.openSession(); // 3. 开启事务 transaction = session.beginTransaction(); } @After public void destory() { System.out.println("destory"); // 5. 提交事务 transaction.commit(); // 6. 关闭Session session.close(); // 7. 关闭SesssionFactory sessionFactory.close(); } /** * 缺点： * 1. 使用了辨别者列 * 2. 子类独有的字段不能添加非空约束 * 3. 若继承层次较深，数据表的字段也会较多 */ /* * 插入操作： * 1. 对于子类对象只需把记录插入到一张数据表中。 * 2. 辨别者列有Hibernate自动维护。 */ @Test public void testSave() { Person person = new Person(); person.setAge(11); person.setName("AA"); session.save(person); Student stu = new Student(); stu.setAge(22); stu.setName("BB"); stu.setSchool("ATGUIGU"); session.save(stu); } /* * 查询： * 1. 查询父类记录，只需要查询一张数据表 * 2. 对于子类记录，也只需要查询一张数据表 */ @Test public void testQuery() { List<Person> persons = session.createQuery("FROM Person").list(); System.out.println(persons.size()); List<Student> stus = session.createQuery("FROM Student").list(); System.out.println(stus.size()); } }
joined-subclass：
Person类
package joinedclass; public class Person { private Integer id; private String name; private int age; 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 int getAge() { return age; } public void setAge(int age) { this.age = age; } }
Student类
package joinedclass; public class Student extends Person { private String school; public String getSchool() { return school; } public void setSchool(String school) { this.school = school; } }
Person.hbm.xml
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2017-7-23 15:37:20 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping package="joinedclass"> <class name="Person" table="PERSON"> <id name="id" type="java.lang.Integer"> <column name="ID" /> <generator class="native" /> </id> <property name="name" type="java.lang.String"> <column name="NAME" /> </property> <property name="age" type="int"> <column name="AGE" /> </property> <joined-subclass name="Student" table="STUDENT"> <key column="STUDENT_ID"></key> <!-- 和其父类一样的共有主键 --> <property name="school" type="string" column="SCHOOL"></property> </joined-subclass> </class> </hibernate-mapping>
使用joined-subclass会生成两张表， 并且对应的相关记录主键是相同的。
HibernateTest类
package joinedclass; import java.util.List; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import org.hibernate.service.ServiceRegistry; import org.hibernate.service.ServiceRegistryBuilder; import org.junit.After; import org.junit.Before; import org.junit.Test; public class HibernateTest { private SessionFactory sessionFactory; private Session session; private Transaction transaction; @Before public void init() { System.out.println("init"); // 1. 创建一个SessionFactory对象 sessionFactory = null; Configuration configuration = new Configuration().configure(); // before 4.0 // sessionFactory = configuration.buildSessionFactory(); ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()) .buildServiceRegistry(); sessionFactory = configuration.buildSessionFactory(serviceRegistry); // 2. 创建一个Session 对象 session = sessionFactory.openSession(); // 3. 开启事务 transaction = session.beginTransaction(); } @After public void destory() { System.out.println("destory"); // 5. 提交事务 transaction.commit(); // 6. 关闭Session session.close(); // 7. 关闭SesssionFactory sessionFactory.close(); } /** * 优点： * 1.不需要使用辨别者列， * 2.子列独有的字段能添加非空约束 * 3.没有冗余的字段 */ /* * 插入操作： * 1. 对于子类对象至少需要插入到两张表中 */ @Test public void testSave() { Person person = new Person(); person.setAge(11); person.setName("CC"); session.save(person); Student stu = new Student(); stu.setAge(22); stu.setName("DD"); stu.setSchool("1-ATGUIGU"); session.save(stu); } /* * 查询： * 1. 查询父类记录，做一个左外连接查询 * 2. 对于子类记录，做一个内连接查询 */ @Test public void testQuery() { List<Person> persons = session.createQuery("FROM Person").list(); System.out.println(persons.size()); List<Student> stus = session.createQuery("FROM Student").list(); System.out.println(stus.size()); } }
union-subclass：
Person类
package unionclass; public class Person { private Integer id; private String name; private int age; 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 int getAge() { return age; } public void setAge(int age) { this.age = age; } }
Student类
package unionclass; public class Student extends Person { private String school; public String getSchool() { return school; } public void setSchool(String school) { this.school = school; } }
Person.hbm.xml
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2017-7-23 15:37:20 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping package="unionclass"> <class name="Person" table="PERSON"> <id name="id" type="java.lang.Integer"> <column name="ID" /> <generator class="hilo" /> </id> <property name="name" type="java.lang.String"> <column name="NAME" /> </property> <property name="age" type="int"> <column name="AGE" /> </property> <union-subclass name="Student" table="STUDENT"> <property name="school" column="SCHOOL" type="string"></property> </union-subclass> </class> </hibernate-mapping>
使用union-subclass会生成两张表，子表包含父表的所有信息，两张表没有关联，但子表会包含父表中的列，产生大量的重复列。
HibernateTest类
package unionclass; import java.util.List; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import org.hibernate.service.ServiceRegistry; import org.hibernate.service.ServiceRegistryBuilder; import org.junit.After; import org.junit.Before; import org.junit.Test; public class HibernateTest { private SessionFactory sessionFactory; private Session session; private Transaction transaction; @Before public void init() { System.out.println("init"); // 1. 创建一个SessionFactory对象 sessionFactory = null; Configuration configuration = new Configuration().configure(); // before 4.0 // sessionFactory = configuration.buildSessionFactory(); ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()) .buildServiceRegistry(); sessionFactory = configuration.buildSessionFactory(serviceRegistry); // 2. 创建一个Session 对象 session = sessionFactory.openSession(); // 3. 开启事务 transaction = session.beginTransaction(); } @After public void destory() { System.out.println("destory"); // 5. 提交事务 transaction.commit(); // 6. 关闭Session session.close(); // 7. 关闭SesssionFactory sessionFactory.close(); } /** * 优点： * 1.不需要使用辨别者列， * 2.子列独有的字段能添加非空约束 * 缺点： * 1. 存在冗余的字段 * 2. 若更新父表的字段，更新的效率较低 */ /* * 插入操作： * 1. 对于子类对象需要插入到一张表中 */ @Test public void testSave() { Person person = new Person(); person.setAge(11); person.setName("CC"); session.save(person); Student stu = new Student(); stu.setAge(22); stu.setName("DD"); stu.setSchool("1-ATGUIGU"); session.save(stu); } /* * 查询： * 1. 查询父类记录，需把父表和子表记录汇总到一起 * 2. 对于子类记录，只需要查询一张数据表 */ @Test public void testQuery() { List<Person> persons = session.createQuery("FROM Person").list(); System.out.println(persons.size()); List<Student> stus = session.createQuery("FROM Student").list(); System.out.println(stus.size()); } @Test public void testUpdate() { String hql = "UPDATE Person p SET p.age = 20"; session.createQuery(hql).executeUpdate(); } }
1378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
