Hibernate学习-10-组件映射和继承映射

最新推荐文章于 2021-02-25 06:40:02 发布
最新推荐文章于 2021-02-25 06:40:02 发布
阅读量149 收藏
点赞数
分类专栏： 过去的酱油文章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010281209/article/details/53522286
版权
类的关系

    组合关系

       一个类中包含了另一个类。这两个类就是组合关系

    继承关系

      一个类继承一个关系

组件映射

com.cx.component.Car

package com.cx.component;

/**
 * Created by cxspace on 16-8-3.
 */
public class Car {

    private int id;

    private String name;

    private Wheel wheel;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Wheel getWheel() {
        return wheel;
    }

    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }
}

com.cx.component.Wheel

package com.cx.component;

/**
 * Created by cxspace on 16-8-3.
 */
public class Wheel {

    private int count;
    private int size;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }
}

com/cx/component/Car.hbm.xml

<?xml version="1.0"?>
<!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.cx.component">

    <class name="Car" table="t_car">
        <id name="id">
            <generator class="native"></generator>
        </id>

        <property name="name" length="20"></property>

        <!--组件映射-->

        <component name="wheel">
            <property name="size"></property>
            <property name="count"></property>
        </component>

    </class>

</hibernate-mapping>

测试类
package com.cx.component;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Created by cxspace on 16-8-3.
 */
public class Test {
    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Car.class)
                .buildSessionFactory();
    }


    @org.junit.Test

    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();

        Wheel wheel = new Wheel();
        wheel.setCount(2);
        wheel.setSize(37);

        Car car = new Car();
        car.setName("路虎");
        car.setWheel(wheel);

        session.save(car);


        session.getTransaction().commit();
        session.close();


        /*
        *
        * Hibernate:
    insert
    into
        t_car
        (name, size, count)
    values
        (?, ?, ?)

        * */
    }
}

继承映射

一.简单的继承映射实例

com.cx.extend1.Animal

package com.cx.extend1;

/**
 * Created by cxspace on 16-8-4.
 */
public class Animal {

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

com.cx.extend1.Cat

package com.cx.extend1;

/**
 * Created by cxspace on 16-8-4.
 */
public class Cat extends Animal{

    private String catchMouse;

    public String getCatchMouse() {
        return catchMouse;
    }

    public void setCatchMouse(String catchMouse) {
        this.catchMouse = catchMouse;
    }
}

com/cx/extend1/Cat.hbm.xml

<?xml version="1.0"?>
<!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.cx.extend1">

    <class name="Cat" table="t_Cat">

        <!--父类属性直接写,每个对象写一个映射文件-->
        <id name="id">
            <generator class="native"></generator>
        </id>

        <property name="name"></property>

        <property name="catchMouse"></property>
    </class>

</hibernate-mapping>

com.cx.extend1.Test

package com.cx.extend1;

import org.apache.jasper.tagplugins.jstl.core.Catch;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import java.util.List;

/**
 * Created by cxspace on 16-8-4.
 */
public class Test {
    private static SessionFactory sf;

    static {
        sf = new Configuration().configure().addClass(Cat.class).buildSessionFactory();
    }

    @org.junit.Test
    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();


//        Cat cat = new Cat();
//        cat.setName("大花猫");
//        cat.setCatchMouse("抓老鼠");
//        session.save(cat);

        /*
        * Hibernate:
            insert
            into
                t_Cat
                (name, catchMouse)
            values
                (?, ?)
        *
        *
        * */



        /*
            当用hql查询的时候，通过父类查询必须写上类的全名
         */

        Query q = session.createQuery("from com.cx.extend1.Animal");

        List<Animal> list = q.list();

        System.out.println(list);

        /*
        *
        * Hibernate:
                select
                    cat0_.id as id0_,
                    cat0_.name as name0_,
                    cat0_.catchMouse as catchMouse0_
                from
                    t_Cat cat0_
            [com.cx.extend1.Cat@3c947bc5]
        *
        * */

        session.getTransaction().commit();
        session.close();
    }
}

二.所有的子类都映射到一张表实例

com.cx.extend2.Animal

package com.cx.extend2;

/**
 * Created by cxspace on 16-8-4.
 */
public class Animal {
    private int id;
    private String name;


    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

com.cx.extend2.Cat

package com.cx.extend2;

/**
 * Created by cxspace on 16-8-4.
 */
public class Cat extends Animal{
    private String catchMouse;

    public String getCatchMouse() {
        return catchMouse;
    }

    public void setCatchMouse(String catchMouse) {
        this.catchMouse = catchMouse;
    }

}

com.cx.extend2.Monkey

package com.cx.extend2;

/**
 * Created by cxspace on 16-8-4.
 */
public class Monkey extends Animal{
    // 吃香蕉
    private String eatBanana;

    public String getEatBanana() {
        return eatBanana;
    }

    public void setEatBanana(String eatBanana) {
        this.eatBanana = eatBanana;
    }

}

com/cx/extend2/Animal.hbm.xml

<?xml version="1.0"?>
<!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.cx.extend2">

    <class name="Animal" table="t_animal">
        <id name="id">
            <generator class="native"></generator>
        </id>

        <!--指定鉴别器字段（用来区分不同的子类）-->
        <discriminator column="type_"></discriminator>

        <property name="name"></property>

        <!--
           子类：猫

               每个子类都要用subclass节点映射
               一定要指定鉴别器字段，否则报错！
                鉴别器字段
                discriminator-value="cat_"
                指定总表鉴别器字段的值
        -->
        <subclass name="Cat" discriminator-value="cat_">
            <property name="catchMouse"></property>
        </subclass>

        <!--
          猴子子类
        -->

        <subclass name="Monkey" discriminator-value="monkey_">
            <property name="eatBanana"></property>
        </subclass>

    </class>

</hibernate-mapping>

com.cx.extend2.Test

package com.cx.extend2;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Created by cxspace on 16-8-4.
 */
public class Test {
    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Animal.class)
                .buildSessionFactory();
    }

    @org.junit.Test
    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();

        Cat cat = new Cat();
        cat.setName("大话猫");
        cat.setCatchMouse("抓老鼠");

        Monkey m = new Monkey();
        m.setName("猴子");
        m.setEatBanana("吃香蕉");

        session.save(cat);
        session.save(m);

        /*
        *
        *
        *   Hibernate:
                insert
                into
                    t_animal
                    (name, catchMouse, type_)
                values
                    (?, ?, 'cat_')
            Hibernate:
                insert
                into
                    t_animal
                    (name, eatBanana, type_)
                values
                    (?, ?, 'monkey_')

        *
        *
        * */

        session.getTransaction().commit();
        session.close();
    }
}

三.一个对象映射一张表

实体类

package com.cx.extend3;

/**
 * Created by cxspace on 16-8-4.
 */
public class Animal {

    private int id;
    private String name;


    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

package com.cx.extend3;

/**
 * Created by cxspace on 16-8-4.
 */
public class Cat extends Animal{
    // 抓老鼠
    private String catchMouse;

    public String getCatchMouse() {
        return catchMouse;
    }

    public void setCatchMouse(String catchMouse) {
        this.catchMouse = catchMouse;
    }

}

package com.cx.extend3;

/**
 * Created by cxspace on 16-8-4.
 */
public class Monkey extends Animal{

    // 吃香蕉
    private String eatBanana;

    public String getEatBanana() {
        return eatBanana;
    }

    public void setEatBanana(String eatBanana) {
        this.eatBanana = eatBanana;
    }


}

映射配置

com/cx/extend3/Animal.hbm.xml

<?xml version="1.0"?>
<!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.cx.extend3">
    <class name="Animal" table="t_animal">
        <id name="id">
            <generator class="native"></generator>
        </id>

        <property name="name"></property>

        <!--
          子类-猫对应表t_cat
          key 指定t_cat表的外键字段
        -->
        <joined-subclass name="Cat" table="t_cat">
            <key column="t_animal_id"></key>
            <property name="catchMouse"></property>
        </joined-subclass>

        <joined-subclass name="Monkey" table="t_monkey">
            <key column="t_animal_id"></key>
            <property name="eatBanana"></property>
        </joined-subclass>

    </class>

</hibernate-mapping>

测试

package com.cx.extend3;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Created by cxspace on 16-8-4.
 */
public class Test {
    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Animal.class)
                .buildSessionFactory();
    }

    @org.junit.Test

    public void save(){

        Session session = sf.openSession();
        session.beginTransaction();

        // 保存
        Cat cat = new Cat();
        cat.setName("大花猫");
        cat.setCatchMouse("抓老鼠");

        Monkey m = new Monkey();
        m.setName("猴子");
        m.setEatBanana("吃香蕉");

        // 保存
        session.save(cat);
        session.save(m);


        /*
        *
        *

       4条sql
Hibernate:
    insert
    into
        t_animal
        (name)
    values
        (?)
Hibernate:
    insert
    into
        t_cat
        (catchMouse, t_animal_id)
    values
        (?, ?)
Hibernate:
    insert
    into
        t_animal
        (name)
    values
        (?)
Hibernate:
    insert
    into
        t_monkey
        (eatBanana, t_animal_id)
    values
        (?, ?)
        *
        * */

        session.getTransaction().commit();
        session.close();

    }
}

结果

四.继承映射-每个类对应一张表（父类不对应表）

实体类

package com.cx.extend4;

public class Animal {

    private String id;
    private String name;
    
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

package com.cx.extend4;

public class Cat extends Animal{


    private String catchMouse;

    public String getCatchMouse() {
        return catchMouse;
    }

    public void setCatchMouse(String catchMouse) {
        this.catchMouse = catchMouse;
    }

    
}

package com.cx.extend4;

public class Monkey extends Animal {

    private String eatBanana;

    public String getEatBanana() {
        return eatBanana;
    }

    public void setEatBanana(String eatBanana) {
        this.eatBanana = eatBanana;
    }

}

映射文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!--
   继承映射-每个类对应一张表（父类不对应表）
-->

<!--

  abstract="true" 指定实体类对象不对应表
-->

<hibernate-mapping package="com.cx.extend4">
    <class name="Animal" abstract="true">
        <!--如果用union-subclass节点,主键生成策略不能为自增长！-->
        <id name="id">
            <generator class="uuid"></generator>
        </id>

        <property name="name"></property>

        <!--
             union-subclass
             table指定未表名
             表的主键即为id列
        -->

        <union-subclass name="Cat" table="t_cat">
            <property name="catchMouse"></property>
        </union-subclass>

        <union-subclass name="Monkey" table="t_monkey">
            <property name="eatBanana"></property>
        </union-subclass>
    </class>

</hibernate-mapping>

测试

package com.cx.extend4;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Created by cxspace on 16-8-4.
 */
public class Test {

    private static SessionFactory sf;
    static {
        sf = new Configuration()
                .configure()
                .addClass(Animal.class)
                .buildSessionFactory();
    }


    @org.junit.Test
    public void Save() {

        Session session = sf.openSession();
        session.beginTransaction();

        // 保存
        Cat cat = new Cat();
        cat.setName("大花猫");
        cat.setCatchMouse("抓大老鼠");

        Monkey m = new Monkey();
        m.setName("猴子");
        m.setEatBanana("吃香蕉");

        // 保存
        session.save(cat);
        session.save(m);

        session.getTransaction().commit();
        session.close();

    }
    /*
    *
    * Hibernate:
    insert
    into
        t_cat
        (name, catchMouse, id)
    values
        (?, ?, ?)
Hibernate:
    insert
    into
        t_monkey
        (name, eatBanana, id)
    values
        (?, ?, ?)
    *
    *
    *
    * */

}

 

无问_
关注
专栏目录
Hibernate第九篇【组件映射、继承映射】
zhong_fucheng
05-08 1396
前言到目前位置，我们已经学习了一对一、一对多、多对一、多对多映射了…既然Hibernate是ORM实现的框架，它还提供了组件映射和继承映射..本博文主要讲解组件映射和继承映射Java主要的类主要有两种方式 组合关系，组合关系对应的就是组件映射 继承关系，继承关系对应的就是继承映射 组件映射组件映射实际上就是将组合关系的数据映射成一张表，组件类和被包含的组件类映射成一张表有的时候，两个类的关系明显不是
Hibernate实例--注解配置表映射
深之JohnChen的专栏
08-12 1306
Hibernate实例 注解配置表映射
SSH框架之Hibernate的组件映射、简单继承映射
一点一滴
12-22 369
一、组件映射 1、类组合关系的映射，也叫做组件映射！ 2、注意：组件类和被包含的组件类，共同映射到一张表！ 3、需求： 汽车与车轮 4、数据库设计： t_car 主键 汽车名称 轮子大小 个数 1 保时捷 77 6 5、javabean设计： 1）Car.java 2）Wheel.java
Hibernate-----核心配置文件、映射文件
qq_36098284的博客
04-22 1005
1.核心配置文件两种方式配置：下面分别是上面3个可选配置的具体应用：1.1 控制台打印一般在写程序的时候多数会用到主要为了测试sql语句是否正常生成。为了显示sql更清楚，可以使用格式化显示。1.2 整合C3P0连接池不在使用默认的hibernate的连接池，而是自己进行设置。1.3 自动建表该属性有4个参数。一般用于测试；create基本不会被使用；所以一般常用的就是update。如果你对jav...
java继承 映射_Hibernate第九篇【组件映射、继承映射】
weixin_29883023的博客
02-25 119
前言到目前位置，我们已经学习了一对一、一对多、多对一、多对多映射了…既然Hibernate是ORM实现的框架，它还提供了组件映射和继承映射..本博文主要讲解组件映射和继承映射Java主要的类主要有两种方式组合关系，组合关系对应的就是组件映射继承关系，继承关系对应的就是继承映射组件映射组件映射实际上就是将组合关系的数据映射成一张表，组件类和被包含的组件类映射成一张表有的时候，两个类的关系明显不是继承...
Hibernate--Hibernate 的配置文件和对象映射关系表
a1773570500的博客
04-23 727
Hibernate 的配置文件和对象映射关系表Hibernate 的配置文件hibernate.cfg.xml的常用属性JDBC 连接属性C3P0 数据库连接池属性其他对象映射关系表映射文件说明hibernate-mapping标签class标签映射对象标识符id标签unsaved-valuegenerator标签increment 标识符生成器identity 标识符生成器sequence标识符...
三、Hibernate组件映射与继承映射
vincentpu2009的博客
12-15 149
**组件映射与继承映射** 类的关系 组合关系 一个类中包含了另外一个类。这2个类中就是组合关系。 需求： 汽车与车轮 继承关系 一个类继承另外一个类。这2个类中就是继承关系。 需求：动物 猫 猴子1、组件映射 类组合关系的映射，也叫做组件映射！ 注意：组件类和被包含的组件类，共同映射到一张表！（所
Hibernate-继承映射
love_jk的专栏
03-15 1202
hibernate的继承映射有三种：subclass、joined-subclass、union-subclass 这三种各有其能，在不能的情况能发挥不能作用。   1、subclass 一张大表 需要引入辨别者列（discriminator） disc
六、映射 -- 总结（关联映射、组件映射、继承映射）
weixin_45602227的博客
07-23 4250
一、关联映射 +++ 关联映射 1.一对多、多对一映射 案例: 部门与员工 表结构: 两张表。（主表、外键表） 映射的主键表，可以有复杂字段。 b.多对多映射 三张表。（主表1、 主表2、 关系表--只有两个字段，分别是主表1和主表2的主键。）
六、映射 -- 关联映射【组件映射与继承映射】（四）
weixin_45602227的博客
07-14 229
一、类的关系 类的关系 +++ 组合关系 一个类中包含了另外一个类。这2个类中就是组合关系。 需求： 汽车与车轮 +++ 继承关系 一个类继承另外一个类。这2个类中就是继承关系。 需求：动物 猫 猴子 由类的关系，即继承关系、组件关系。我们来设计映射方式。 二、组件映射（映射到一张表） Car.java public class Car { private String id; private String name; priva
hibernate-orm-master.zip
12-01
实体类需要继承Hibernate的Entity接口或使用@Entity注解，属性通过@Id和@Column等注解进行映射。 四、查询机制 Hibernate提供了两种查询方式：HQL和 Criteria API。HQL是面向对象的查询语言，类似于SQL，但操作的是...
hibernate-release-4.3.8.Final
08-15
Hibernate支持多种持久化模型，如单态、聚合、继承等，允许开发者根据业务需求灵活选择。 七、性能优化 在4.3.8.Final版本中，Hibernate进一步提升了性能，包括优化查询执行、减少数据库连接开销、提高缓存效率等。...
hibernate-jpa-2.1-api-1.0.0.final-sources.jar.zip
03-16
4. Inheritance Strategies：Hibernate支持多种继承策略，如单表继承、联合继承和表 per class。在源码中，可以看到这些策略如何在`org.hibernate.mapping`包下的实体类映射中实现。 5. Transactions：JPA提供了...
Hibernate继承映射
04-21
【Hibernate继承映射】是Java开发中...以上就是关于Hibernate继承映射、一对一关系、组件映射以及HQL的基础知识，这些概念和实践技巧在Java企业级开发中非常常见，熟练掌握能有效提高数据操作的效率和代码的可维护性。
Hibernate教程17_继承映射
04-13
在Java世界中，ORM（对象关系映射）框架如Hibernate极大地简化了数据库操作。本教程主要探讨的是Hibernate中的“继承映射...学习并实践这些例子，有助于巩固对Hibernate继承映射的理解，并提升在实际项目中的应用能力。
mybatis入门(一)-mybatis介绍和获取SqlSession
浮夸的程序员
11-27 5984
首先什么是MyBatis呢？要找到这个问题的答案，当然最准确的说法肯定在开发出它的人那，谁是开发它的人呢。然后...        我们就要用到学软件必不可少的神器了 https://github.com/ , 如果不知道github的话，赶快去百度谷歌搜索，知道了之后就注册一个github账户，并学会GitHub的使用,由于这篇文章重点不再这里，所以不会专门讲这些操作。        我们在
画图理解软件工程-进行详细的需求分析（二）
浮夸的程序员
11-27 3562
首先,我们看下从用户那里获取到整理成SRS文档的过程 我们怎么从用户那里获取详细需求呢可以从下面这一些列的问号入手 系统将要做什么？ 系统什么时候做？ 有多种操作模式吗？ 必须执行什么种类的计算和数据转换？ 对可能刺激合适的反应是什么？ 输入、输出系统的格式是什么？ 在任何时间都必须保留任何数据吗？ 设备安放在哪？ 在一个地还是多个地方？ 是否有任何环境限制？ 是否对系统的设计规模有限制？ 是
画图理解软件工程-UML统一建模语言-用例图（三）
浮夸的程序员
11-27 3317
UML定义 Unified Modeling Language (UML)又称统一建模语言或标准建模语言，是始于1997年一个OMG标准，它是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持，包括由需求分析到规格，到构造和配置。 面向对象的分析与设计(OOA&D，OOAD)方法的发展在80年代末至90年代中出现了一个高潮，UML是这个高潮的产物。它不仅统一了Boo
画图理解软件工程-UML统一建模语言-类图和时序图(四)
浮夸的程序员
11-30 2144
首先我们再整理一下合理软件开发的流程 一、需求分析阶段 需求是产品优劣的关键 二、系统设计阶段 三、开发阶段 四、测试阶段 五、维护阶段        发布系统，维护系统(备份系统数据)，数据软件系统运行是出问题，与开发人员合作修复问题。 ======================================================
Hibernate组件与继承映射详解
而对于继承映射，可能需要配置`@Inheritance(strategy=InheritanceType.JOINED)`等注解来控制继承策略。 Component和Inheritance映射是Hibernate中提高ORM设计灵活性和效率的重要工具。正确理解和使用这两种映射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值