Hibernate學習-10-元件對映和繼承對映

阿新 • • 發佈：2019-02-06

類的關係

組合關係

一個類中包含了另一個類。這兩個類就是組合關係

繼承關係

一個類繼承一個關係

元件對映

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_
            [[email protected]]
        *
        * */

        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學習-10-元件對映和繼承對映

類的關係組合關係一個類中包含了另一個類。這兩個類就是組合關係繼承關係一個類繼承一個關係元件對映 com.cx.component.Car package com.cx.component; /** * Created

hibernate單表之元件對映和繼承對映

表結構: Create table customer( id int primary key, name varchar(15), home_street varchar(255), home

hibernate元件對映和繼承對映

元件對映類的關係： wheel.javapublic class Wheel { private String brandname; private int size; }Car.java public class Car { private int id; pr

MyBatis的學習總結三——輸入對映和輸出對映以及多表關聯查詢

關於MyBatis的輸入對映和輸出對映，可輸入的型別很多，輸出型別亦是如此。如圖所示：一、輸入型別是通過引數parameterType來設定的，引數型別有基本資料型別、包裝型別pojo、Map 基礎型別（String，int,long,double...） pojo型別

Mybatis學習筆記(五) —— Mapper.xml(輸入對映和輸出對映）

一、parameterType(輸入型別) 1.1 傳遞簡單型別  <select id="queryUserById" parameterType="int" resultType="cn.itc

Hibernate學習（三）———— 一對多對映關係

　序言　　　　　　　前面兩節講了hibernate的兩個配置檔案和hello world！。還有hibernate的一級快取和三種狀態，基本上hibernate就懂一點了，從這章起開始一個很重要的知識點，hibernate的關係對映。一對一、一對多、多對多的講解。，希望你們能從中學到東西，我也從中鞏固自己

Hibernate4學習總結(3)--註解形式的基礎對映，主鍵對映，基本屬性對映，複合屬性對映，繼承對映。

Hibernate Annotation即hibernate註解，可以通過另一種方式將持久化類轉化成表的相關資訊，可以簡化hibernate的配置檔案。本文主要對Hibernate的註解進行講解，由於篇幅原因，將註解部分分為兩篇文章來寫。集合對映和關聯關係對映將

hibernate學習總結之子類關係對映

關於Struts2 130529143交流。有償技術支援Q群：398162181  <?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//

Hibernate 學習經驗之談-（四）關聯對映

摘要：（待編寫） Hibernate 是一個ORM 框架，它的重點就是物件之間的關係模型，維護物件之間的關係是hibernate 的核心內容，也是這個框架中相對比較難的一點。如果能夠靈活地運用好這個框架，必須熟悉物件之間的聯絡。Hibernate 中的主

2009-04-16 | Hibernate關聯對映（繼承對映）

* 子類使用<subclass>標籤定義，在定義subclass的時候，需要注意如下幾點： Subclass標籤的name屬性是子類的全路徑名在Subclass標籤中，用discriminator-value屬性來標明本子類的discriminator欄位（用來區分不同類的欄

Hibernate對映解析---繼承對映

現實世界中有很多種動物，比如：Pig（豬），Bird（鳥）等等，當我用面向物件的思想分析時，我們一般會將它們的共同部分抽取出來增加一個抽象類Animal（動物），這樣在編寫程式時Pig和Bird只需要繼承它們的父類Animal就可以省去很多重複的程式碼。Java程式碼中只需

Hibernate支援三種基本的繼承對映策略：

Hibernate支援三種基本的繼承對映策略： 1) 每個類分層結構一張表(table per class hierarchy) 將所有類綜合到一張表上，通過設定鑑別器（標記值）來區分資料。 2) 每個子類一張表(table per subclass) 有一個總表

Hibernate學習10——Hibernate 查詢方式

9.png property ice pub gets reat sed desc ring 本章主要是以查詢Student的例子： Student.java: package com.cy.model; public class Student { priv

CSS學習摘要-層疊和繼承

In doc 示例現在 fault red select 類型 thead 當有多個選擇器作用在一個元素上時，哪個規則最終會應用到元素上？其實這是通過層疊機制來控制的，這也和樣式繼承(元素從其父元素那裏獲得屬性值)有關。元素的最終樣式可以在多個地方定義，它們以復雜的形

maven課程專案管理利器-maven 3-10 maven聚合和繼承 4星

本節主要講了以下內容： 1　　　　maven聚合 2　　　　maven繼承 1　　　　maven聚合  <groupId>com.hongxing</groupId> <artifactId&g

之間的區別是什麼高階元件(HOC)和繼承反應本地元件

我從．net背景,反應新本地這裡的問題是如何的不同於繼承與基地哦概念通過父類屬性和兒童擴充套件基礎和使用狀態,從基類屬性和基本方法。這是最好的方法來實現父- >子- >孫子在反應元件。層次關係嗎? 例如: Parent.js看起來像 class Parent extends Comp

IO的埠對映和記憶體對映（Port mapped I/O 和 Memory mapped I/O說明）

IO埠和IO記憶體的區別及分別使用的函式介面每個外設都是通過讀寫其暫存器來控制的。外設暫存器也稱為I/O埠，通常包括：控制暫存器、狀態暫存器和資料暫存器三大類。根據訪問外設暫存器的不同方式，可以把CPU分成兩大類。一類CPU（如M68K，Power

Hibernate學習筆記---通過load和get方法來查詢物件（只能根據主鍵來查詢）

下面的例子是說明如何來查詢一個物件。 get方法(get方法一經呼叫，會立即發出get方法) package com.ahuzl.hibernate; import java.util.Date;import org.hibernate.Session;import org

Netty學習10-粘包和拆包

1 粘包拆包基本概念 TPC是一個面向流的協議。所謂流就是沒有邊界的一串資料，如同河水般連成一片，其中並沒有分界線。TCP底層並不瞭解上層業務資料的具體含義，它會根據TCP緩衝區的具體情況進行包的劃分，所以在業務上認為，一個完整的包可能會被TCP拆成多個包傳送，也有可能

Hibernate學習(3) (繼承對映,配置檔案和註解版)

這篇blog準備寫怎樣在Hibernate中反應記憶體物件之間的繼承關係.我們知道,記憶體物件之間是可以有繼承關係的,但是在資料庫中,我們繼承神馬的都是浮雲,不存在的.那麼怎麼辦呢?Hibernate提供了繼承關係對映!(其實就是幫你把原來的一個類以一種特定的方

Hibernate學習-10-元件對映和繼承對映

相關推薦