十四、Hibernate实体映射（每个具体类映射成一张表）

最新推荐文章于 2021-02-24 01:31:05 发布
原创 最新推荐文章于 2021-02-24 01:31:05 发布 · 649 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#hibernate #pig #session #exception #null
#class
本文介绍了Hibernate中每个具体类映射成一张表的策略，讲解了实体类与表之间的关系，展示了创建表的SQL语句，以及Animal、Bird、Pig类的实体映射和对应的hbm.xml配置文件。通过测试类展示了如何使用Hibernate进行数据的保存和查询操作，强调了在多态查询时load和get方法的区别以及注意事项。

一、一Hibernate实体映射（每个具体类映射成一张表）

（1）实体类与表间的关系

                    Animal                   t_animal       t_pig          t_bird

                 id:int                      id:int         id:int         id:int

                 name:String                 name:varchar   name:varchar   name:varchar

                 sex:boolean                 sex:big        sex:big        sex:big

          Ping              Bird                            weight:int     height:int

          weight:int        height:int

 

（2）、创建表语句   


CREATE TABLE `animal` (
  `id` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  `sex` bit(1) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 

CREATE TABLE `t_bird` (
  `id` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  `sex` bit(1) DEFAULT NULL,
  `height` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 

CREATE TABLE `t_pig` (
  `id` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  `sex` bit(1) DEFAULT NULL,
  `weight` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert into t_pig (name, sex, weight, id) values ('猪猪', true, 100, 1);
Hibernate: insert into t_bird3 (name, sex, height, id) values ('鸟鸟', false, 50, 2);

 

（3）、创建实体类与映射文件

Animal.java

public class Animal {
    private int id;
   
    private String name;
   
    private boolean sex;
   
    public Animal(){

       
    }

  //省略set、get方法

}

Bird.java

public class Bird extends Animal {
    private int height;
   
    public Bird(){
       
    }

  //省略set、get方法

}

Pig.java

public class Pig extends Animal1 {
   
    private int weight;
   
    public Pig1(){
       
    }

  //省略set、get方法

}

extends.hbm.xml

<hibernate-mapping package="com.keli.pojo">
    <class name="Animal" abstract="true">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="name"/>
        <property name="sex"/>
        <union-subclass name="Pig" table="t_pig">
            <property name="weight"/>
        </union-subclass>
        <union-subclass name="Bird" table="t_bird">
            <property name="height"/>
        </union-subclass>
    </class>
 </hibernate-mapping>

 

（4）、测试

public class ExtendsTest3 extends TestCase {
    public void testSave1() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Pig3 pig = new Pig3();
            pig.setId(1);
            pig.setName("猪猪");
            pig.setSex(true);
            pig.setWeight(100);
            session.save(pig);

            Bird3 bird = new Bird3();
            bird.setId(2);
            bird.setName("鸟鸟");
            bird.setSex(false);
            bird.setHeight(50);
            session.save(bird);
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
     * 采用load，通过Pig查询
     */
    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Pig3 pig = (Pig3) session.load(Pig3.class, 1);
            System.out.println(pig.getName());
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
     * 采用load，通过Animal查询
     */
    public void testLoad2() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal3 animal = (Animal3) session.load(Animal3.class, 1);
            System.out.println(animal.getName());
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
     * 采用load，通过Animal查询
     */
    public void testLoad3() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal3 animal = (Animal3) session.load(Animal3.class, 1);
            // 因为load默认值是lazy，因为我们看到的Animal的代理对象
            // 所以通过instanceof是反应不出真实的对象类型的
            // 因此load在默认情况下是不支持多态查询的
            if (animal instanceof Pig3) {
                System.out.println(animal.getName());
            } else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
     * 采用load，通过Animal查询,将<class>标签上的lazy=false
     */
    public void testLoad4() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal3 animal = (Animal3) session.load(Animal3.class, 1);
            // 可以正确的判断出Pig的类型，因为lazy=false，返回的是具体的Pig类型
            // 此时load支持多态查询
            if (animal instanceof Pig3) {
                System.out.println(animal.getName());
            } else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
     * 采用get，通过Animal查询
     */
    public void testLoad5() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal3 animal = (Animal3) session.get(Animal3.class, 1);
            // 可以正确的判断出Pig的类型，因为返回的是具体的Pig类型
            // get支持多态查询
            if (animal instanceof Pig3) {
                System.out.println(animal.getName());
            } else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
     * 采用get，通过Animal查询
     */
    public void testLoad6() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();
            // List animalList = session.createQuery("from Animal3").list();
            // for(Iterator iter = animalList.iterator();iter.hasNext();){
            // Animal3 a =(Animal3)iter.next();
            // //能够正确的鉴别出真实的类型，hql是支持多态查询的
            // if(a instanceof Pig3){
            // System.out.println("是Pig");
            // }else if(a instanceof Bird3){
            // System.out.println("是Bird");
            // }
            // }

            List list = session.createQuery("from java.lang.Object").list();
            for (Iterator iter = list.iterator(); iter.hasNext();) {
                Object o = iter.next();
                if (o instanceof Pig3) {
                    System.out.println("是Pig");
                } else if (o instanceof Bird3) {
                    System.out.println("是Bird");
                }
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }
}

 

说明：

每个具体类映射成一张表

1、理解如何映射
    这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，
    即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，
    joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：
    父类用普通<class>标签定义即可
    子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：
    Union-subclass标签不再需要包含key标签（与joined-subclass不同）
    Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
    也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass
    标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，
    定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，
    但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所
    有属性的映射字段。
   
注意：在保存对象的时候id是不能重复的（不能使用自增生成主键）   

    ：设置abstract属性：由于父类不需要映射数据表，所以将此属性设置为“true”，这样不需要创建animal表

 

jack18688
关注
【Hibernate】——实体类映射到数据库表
热门推荐
相由心生-心随相改~
12-30 1万+
上回说到， Hibernate是一个开放源代码的对象关系映射框架，其核心应该也就是映射了，所以，今天我们了解一下Hibernate是如何将实体和数据库映射的。--即Hibernate根据实体自动建立表和字段。 为了让大家更明了，小编写了一个小demo。实现了将实体映射到数据库表。希望通过这个小程序，让大家有所收获。
hibernate继承映射关系 —— 每个具体类映射成一张表
zs20082012的博客
03-06 570
“每个具体类一张表”的意思是:使继承体系中每一个子类都对应数据库中的一张表。每一个子类对应的数据库表都包含了父类的信息，并且包含了自己独有的属性。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段。这种策略是使用&lt;union-subclass&gt;标签来定义子类的。通过mysql建立worker表和student表Person类：package com...
Entity Framework Code First 学习日记（10）-兼容遗留数据库
weixin_30840573的博客
02-27 301
在开始写本次的日记之前，首先需要给大家道个歉。因为最近一直忙于新的项目，所以有一个多月都没有继续更新了。 本篇日记我们将详细探讨如何将表现领域的类映射到现有的数据库。现在的经济形势不是太好，很多公司都取消了开发新系统的预算。在这种情况下，通常的做法是把原有的几个系统修改一下做个集成，先凑合用着得了。如果要对原有的系统做功能提升的话，肯定要重用原来的数据库结构并做一些小的改进，在这种情况下我们怎样使...
Hibernate每个具体类一张表映射(使用注释）
dengjuanshou7445的博客
08-23 231
在每个类创建一张表的情况下， 表中不使用Null值的列。 这种方法的缺点是在子类表中创建了重复的列。 在这里，我们需要在父类中使用@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)注释，并在子类中使用@AttributeOverrides注释。@Inheritance(strategy = InheritanceType.T...
hibernate继承映射关系 —— 每个子类映射成一张表
zs20082012的博客
03-06 979
上一篇介绍了hibernate的继承映射关系，类继承树映射成一张表；该篇介绍第二种继承映射关系：每个子类映射成一张表，所谓“每个子类一张表”：父类一张表，每个子类一张表，父类的表保存公共有信息，子类的表只保存自己特有的信息      这种策略是使用&lt;joined-subclass&gt;标签来定义子类的。父类、子类都对应一张数据库表。在父类对应的数据库表中，它存储了所 有记录的公共信息，实际...
Hibernate 继承 - 每个实现类映射成一个表
R812656252的博客
12-01 353
Hibernate 继承 类与类之间的继承是Java的绝对核心，hibernate作为一个用于ORM框架，将类与类之间的继承映射成表的关系，也是hibernate所支持的功能之一。 实际上在hibernate中有三种方式支持这一特性。 1. 每个实现类映射成一个表 2. 根类映射成一个表 3. 每个类都映射成一个类 为了描述这种关系，工作图片和生活图片都继承自图片类/接口，每个图片都属于一个学...
Hibernate映射解析---继承映射
黄爱岗廊坊师范学院信息技术提高班 第七期
07-25 3753
现实世界中有很多种动物，比如：Pig（猪），Bird（鸟）等等，当我用面向对象的思想分析时，我们一般会将它们的共同部分抽取出来增加一个抽象类Animal（动物），这样在编写程序时Pig和Bird只需要继承它们的父类Animal就可以省去很多重复的代码。Java代码中只需要extends关键字就可以轻松实现这种继承关系，但是对于我们使用的关系型数据库是没有任何关键字可以指明这种继承关系的。为了将这种
hibernate继承映射策略之每个具体类一张表
想念的专栏
08-15 454
对于“每个具体类一张表”的映射策略，可以采用两种方式。第一种方式是使用。另一种方法时采用隐式多态。 以上一篇博客《hibernate单表继承映射》所述案列为例，我们主要学习第一种方式。 与上篇文章不同的Person.hbm.xml配置文件 测试类： public class Hiberna
Hibernate映射类继承之每个带有隐式多态的具体类一张表(每个子类各一张表,有各自的映射文件)
fhd001的专栏
09-12 820
Hibernate映射类继承之每个带有隐式多态的具体类一张表(每个子类各一张表)
hibernate实体类与数据表映射的两种方式
Gavin的博客
07-11 1万+
1、传统方法是通过XX.hbm.xml映射文件      注意：1）JPA jar包在hibernate3.6之后被放入hibernate-core包中。               2) 2、java5.0以后可以通过注解方式取代XX.hbm.xml映射文件      注意1）需要在Hibernate配置文件中注册该实体类：            2）实体类的属性声明顺序和数
Hibernate中实体类映射
longzhanqing的博客
01-03 922
实体类映射技巧 即Hibernate访问持久化类的方法 通过get、set方法 通过java反射机制 缺少setter和getter方法的实体类在映射时，可将元素的access属性设置为field。这种方式将无法适用于下面这种方式 <!-- 通过指定access的值为field，来使用反射机制，当使用该方式时，没有了类的getter、setter方法也可以拿到对应的值 --> <property name="username" not-null="true" type="java.la
EF Code First 学习笔记：表映射
weixin_33895475的博客
01-25 314
多个实体映射到一张表 Code First允许将多个实体映射到同一张表上，实体必须遵循如下规则： 实体必须是一对一关系 实体必须共享一个公共键 观察下面两个实体： public class Person { [Key] public int PersonId { get; set; } public in...
hibernate一个实体类映射多张表
weixin_33800463的博客
01-06 1122
2019独角兽企业重金招聘Python工程师标准>>> ...
Hibernate--实体类与表映射01
BtWangZhi的博客
07-06 634
1 主键映射;<!-- package声明pojo类所在的包，如果不写那么在class中需要指明pojo类所在的包 --> <hibernate-mapping package="cn.siggy.pojo"> <!-- class指映射一个pojo类提供了公共的无参构造方法 通过反射产生对象属性用private修饰， 并且生成对应的get/set方法 ，name表示pojo类名
02.Hibernate映射基础
weixin_34259559的博客
02-03 336
前言：Hibernate的核心功能是根据数据库到实体类的映射，自动从数据库绑定数据到实体类。使我们操作实体类(Java对象)就能对数据库进行增、删、查、改，而不用调用JDBC API使数据操作变得简单而不繁琐。本文就主要讲解Hibernate的映射文件的映射机制，但本文讲解的重点在于通过Hibernate如何配置实体类到数据库表的映射，至于数据库表(或实体类)之间的各种关联关系的映射会在后...
java hibernate标签_hibernate是通过什么标签实现实体类和表的映射的
weixin_34207964的博客
02-24 335
展开全部10.1 实体类的映射从Java的角度讲，实体类就是普通的Java封装类(有人32313133353236313431303231363533e4b893e5b19e31333361306339称为POJO有人称为VO)。仅从实体类中的代码信息，Hibernate并不能得知该实体类对应哪个数据表，因此还需要以某种方式配置一下。常用的方式有*.hbm.xml文件配置与@注解配置两种。hbm...
hibernate -- 注解映射实体和表
zhangjunli的博客
09-14 2275
表名的映射 //代表此类参与ORM映射，此注解必须要有 @Entity //代表user这个类映射了一个表user50，如果表名和类名一样，此注解可以省略 @Table(name="user50") public class User { 回到顶部 主键的映射 //主键，此注解必须要有 @Id //数据库表中主键列名为id,如果实体类属性名和列名相...
Hibernate实体类，映射成数据表
xutao5641745的专栏
12-02 407
用过Hibernate的人都知道，可以通过数据库表来生成实体类，但是有时候，工作需求，项目可能需要在不同的数据库中正常运行，如果用导入导出的方法，我想肯定会不成功。原因就是，不同数据库会有不同的语法，这个时候，难道我们要手工的创建这些表么？   其实大可不必，仔细研读，我们发现，其实Hibernate帮我们提供了这种功能。如何操作呢？下面请听我详细道来。   第一步：在Hibernate....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值