Hibernate学习13(映射继承关系)

映射继承关系有三种方法
  • 使用subclass元素子类数据和父类数据都存在一张表中 通过鉴别者列值进行区分
    1.查询父类记录,只需要查询一张数据表
    2.对于子记录,也只需查询一张表
    缺点:
    1.使用辨别者列
    2.子类独有字段无法添加非空判断
    3.若继承较深,数据表字段也会较多
  • oined-subclass元素 子类会生成一张新表 保存父类没有的列参照父类OID生成子类OID
    1.查询父类记录,做一个左外链接查询
    2.对于子类查询,做一个内链接查询
    优点:
    1.不需要使用辨别者列
    2.子类独有字段可以加非空约束
    3.没有冗余字段
  • union-subclass元素 子类表和父类包都是完整的表
    1.查询父类记录,需要把父表和子表做汇总查询
    2.对于子类查询,只需要查一张表
    缺点:
    1.存在冗余字段
    2.父类更新麻烦效率低
父类
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;
    }
}
子类

public class Student extends Person {
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

}

subclass元素

映射文件
  • 只需要设置父类

  • 配置鉴别者列

  • discriminator-value指定辨别者类的值

  • 映射子类 subclass映射


    
        
            
            
        
        
        
        

        
            
        
        
            
        

        
        
            
        
    

数据表
subclass元素 保存
/**
     * 映射继承关系 subclass元素在一张表中
     */
    public static void testExtendsSubclass() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        
        Person person=new Person();
        person.setAge(20);
        person.setName("张三");
        
        
        Student student=new Student();
        student.setAge(24);
        student.setName("王五");
        student.setSchool("呵呵呵");
        
        session.save(person);
        session.save(student);
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
subclass元素 查询
/**
     * 映射继承关系 subclass元素 查询
     * 1.查询父类记录,只需要查询一张数据表
     * 2.对于子记录,也只需查询一张表
     * 缺点:
     * 1.使用辨别者列
     * 2.子类独有字段无法添加非空判断
     * 3.若继承较深,数据表字段也会较多
     * */
    public static void testExtendsSubclassQuery() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        //createQuery参数是类名
        List persons = session.createQuery("FROM Person").list();
        System.out.println(persons.size());
        
        List students = session.createQuery("FROM Student").list();
        System.out.println(students.size());
        
        
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
    
    

joined-subclass元素

配置映射文件

    
        
            
            
        
        
            
        
        
            
        
        
            
            
            
        

    

父类表
子类独有字段表
保存
/**
     * 映射继承关系 joined-subclass元素 
     * 1.子类会生成一张新表 保存父类没有的列
     * 2.对于子类至少要插入两张表
     */
    public static void testExtendsJoinedSubclass() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        
        cheniso.Person person=new cheniso.Person();
        person.setAge(20);
        person.setName("张三");
        
        
        cheniso.Student student=new cheniso.Student();
        student.setAge(24);
        student.setName("王五");
        student.setSchool("呵呵呵");
        
        session.save(person);
        session.save(student);
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
    
查询
/**
     * 映射继承关系 joined-subclass元素 查询
     * 1.查询父类记录,做一个左外链接查询
     * 2.对于子类查询,做一个内链接查询
     * 优点:
     * 1.不需要使用辨别者列
     * 2.子类独有字段可以加非空约束
     * 3.没有冗余字段
     * */
    public static void testExtendsJoinedSubclassQuery() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        
        List persons = session.createQuery("FROM cheniso.Person").list();
        System.out.println(persons.size());
        
        List students = session.createQuery("FROM cheniso.Student").list();
        System.out.println(students.size());
        
        
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

union-subclass元素

配置映射文件
  • 主主键生成方式increment

    
        
            
            
        
        
            
        
        
            
        
        
            
        

    

父类表
子类表
保存
    /**
     * 映射继承关系 union-subclass元素 
     * 1.子类表和父类包都是完整的表
     * 2.子类插入只需一张表
     * 3.子类独有字段可以加非空约束
     */
    public static void testExtendsUnionSubclass() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        
        chenisoa.Person person=new chenisoa.Person();
        person.setAge(20);
        person.setName("张三");
        
        
        chenisoa.Student student=new chenisoa.Student();
        student.setAge(24);
        student.setName("王五");
        student.setSchool("呵呵呵");
        
        session.save(person);
        session.save(student);
        
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
查询
/**
     * 映射继承关系 union-subclass元素  查询
     * 
     * 1.查询父类记录,需要把父表和子表做汇总查询
     * 2.对于子类查询,只需要查一张表
     * 缺点:
     * 1.存在冗余字段
     * 2.父类更新麻烦效率低
     * */
    public static void testExtendsUnionSubclassQuery() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        
        List persons = session.createQuery("FROM chenisoa.Person").list();
        System.out.println(persons.size());
        
        List students = session.createQuery("FROM chenisoa.Student").list();
        System.out.println(students.size());
        
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

你可能感兴趣的:(Hibernate学习13(映射继承关系))