`
kidiaoer
  • 浏览: 821813 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
文章分类
社区版块
存档分类
最新评论

hibernate一对一映射外键关联

阅读更多
hibernate一对一映射外键关联
一对一外键关联

外键关联:一个外键和一个主键关联

一﹑确定数据的一对一关联关系

数据脚本

drop database if exists test;

create database test;

use test;

create table company

(

ID int auto_increment not null primary key,

companyName varchar(20) not null,

addressID int not null

);



create table address

(

ID int auto_increment not null primary key,

address varchar(20) not null

);



Address表中的主键ID与company表中的外键addressID构成一对一外键关联关系.

双向关联:可以根据company得到address,也可以根据address得到company,双向关联时需要在company.hbm.xml中配置 <many-to-one unique=”true” name=”address” column=”addressID” cascade=”all”></many-to-one>;在address.hbm.xml中配置<one-to-one name=”company” property-ref=”address”></one-to-one>,property-ref的值应与<many-to-one>中的name属性的值对应,说明company对象是与address对象建立的关联关系.



单向关联:只可以根据company得到address,单向关联时只需在company.hgm.xml中配置<many-to-one unique=”true” name=”address” column=”addressID”  cascade=”all”>



二﹑ORM映射

Company表



package com.guopeng.bo;



import java.io.Serializable;

public abstract class AbstractCompany  implements Serializable

{

    private int hashValue = 0;

    private java.lang.Integer id;

    private java.lang.String companyname;



private Address address;//address属性用于建立与address的关系



    public AbstractCompany()

    {

    }

    public AbstractCompany(java.lang.Integer id)

    {

        this.setId(id);

    }

    public java.lang.Integer getId()

    {

        return id;

    }

    public void setId(java.lang.Integer id)

    {

        this.hashValue = 0;

        this.id = id;

    }

    public java.lang.String getCompanyname()

    {

        return this.companyname;

    }

    public void setCompanyname(java.lang.String companyname)

    {

        this.companyname = companyname;

    }

    public boolean equals(Object rhs)

    {

        if (rhs == null)

            return false;

        if (! (rhs instanceof Company))

            return false;

        Company that = (Company) rhs;

        if (this.getId() != null && that.getId() != null)

        {

            if (! this.getId().equals(that.getId()))

            {

                return false;

            }

            if(! this.getCompanyname().equals(that.getCompanyname()))

            {

                   return false;

            }

        }

        return true;

    }

    public int hashCode()

    {

        if (this.hashValue == 0)

        {

            int result = 17;

            int idValue = this.getId() == null ? 0 : this.getId().hashCode();

            result = result * 37 + idValue;

            idValue = this.getCompanyname() == null ? 0 : this.getCompanyname().hashCode();

            result = result * 37 + idValue;

            this.hashValue = result;

        }

        return this.hashValue;

    }

       public Address getAddress() {

              return address;

       }

       public void setAddress(Address address) {

              this.address = address;

       }

}



Address表

package com.guopeng.bo;



import java.io.Serializable;

public abstract class AbstractAddress implements Serializable

{

    private int hashValue = 0;

    private java.lang.Integer id;

    private java.lang.String address;



private Company company;

//单向关联时不需要此属性

    public AbstractAddress()

    {

    } 

    public AbstractAddress(java.lang.Integer id)

    {

        this.setId(id);

    }

    public java.lang.Integer getId()

    {

        return id;

    }

    public void setId(java.lang.Integer id)

    {

        this.hashValue = 0;

        this.id = id;

    }

    public java.lang.String getAddress()

    {

        return this.address;

    }

    public void setAddress(java.lang.String address)

    {

        this.address = address;

    }oolean equals(Object rhs)

    {

        if (rhs == null)

            return false;

        if (! (rhs instanceof Address))

            return false;

        Address that = (Address) rhs;

        if (this.getId() != null && that.getId() != null)

        {

            if (! this.getId().equals(that.getId()))

            {

                return false;

            }

        }

        return true;

    }

    public int hashCode()

    {

        if (this.hashValue == 0)

        {

            int result = 17;

            int idValue = this.getId() == null ? 0 : this.getId().hashCode();

            result = result * 37 + idValue;

            this.hashValue = result;

        }

        return this.hashValue;

    }

       public Company getCompany() {

              return company;

       }

       public void setCompany(Company company) {

              this.company = company;

       }

}



映射XML

Company.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

                            "-//Hibernate/Hibernate Mapping DTD 2.0//EN"

                            "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >



<!-- DO NOT EDIT: This is a generated file that is synchronized -->

<!-- by MyEclipse Hibernate tool integration.                   -->

<!-- Created Mon Jul 24 21:19:07 CST 2006                         -->

<hibernate-mapping package="com.guopeng.bo">



    <class name="Company" table="company" batch-size="4" >

    <id name="id" column="ID" type="java.lang.Integer">

         <generator class="native" />

    </id>



    <property name="companyname" column="companyName"

         type="java.lang.String" not-null="true" />

  

    <!-- 与address中的one-to-one的property-ref属性相对应,property-ref的值应为many-to-one的name属性的值,表明建立了从address对象到company对象的关联-->

    <many-to-one name="address" class="Address" column="addressID"

         cascade="all" unique="true">

    </many-to-one>



    </class>



</hibernate-mapping>



Address.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

                            "-//Hibernate/Hibernate Mapping DTD 2.0//EN"

                            "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >



<!-- DO NOT EDIT: This is a generated file that is synchronized -->

<!-- by MyEclipse Hibernate tool integration.                   -->

<!-- Created Mon Jul 24 21:18:45 CST 2006                         -->

<hibernate-mapping package="com.guopeng.bo">



    <class name="Address" table="address" batch-size="4" >

    <id name="id" column="ID" type="java.lang.Integer">

         <generator class="native" />

    </id>



    <property name="address" column="address"

         type="java.lang.String" not-null="true" />

   <!—如果为单向关联,不用配置<one-to-one>可以把他删除,如果配置了<one-to-one>则address.class里面必须要有company属性 -à

    <one-to-one name="company" class="Company"

         property-ref="address">

         <!--property-ref="address"与company中的many-to-one 的name属性相对应 -->

    </one-to-one>



    </class>



</hibernate-mapping>





查询数据时,双向关联与单向关联所执行的SQL语句

双向关联

Hibernate: select company0_.ID as x0_0_ from company company0_



Hibernate: select company0_.ID as ID1_, company0_.companyName as companyN2_1_, company0_.addressID as addressID1_, address1_.ID as ID0_, address1_.address as address0_ from company company0_ left outer join address address1_ on company0_.addressID=address1_.ID where company0_.ID=?



Hibernate: select company0_.ID as ID1_, company0_.companyName as companyN2_1_, company0_.addressID as addressID1_, address1_.ID as ID0_, address1_.address as address0_ from company company0_ left outer join address address1_ on company0_.addressID=address1_.ID where company0_.addressID=?



单向关联

Hibernate: select company0_.ID as x0_0_ from company company0_



Hibernate: select company0_.ID as ID1_, company0_.companyName as companyN2_1_, company0_.addressID as addressID1_, address1_.ID as ID0_, address1_.address as address0_ from company company0_ left outer join address address1_ on company0_.addressID=address1_.ID where company0_.ID=?



由此可以看出,双向关联要比单向关联多执行一条select语句,因此在实际的应用中,如果没有必要配置双向关联就不要配,以便于提高系统性能.
分享到:
评论

相关推荐

    Hibernate一对一唯一外键关联映射(单向关联)

    在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是常见的...以上就是关于Hibernate一对一唯一外键关联映射(单向关联)的详细说明。通过这种方式,我们可以轻松地在Java应用中处理数据库的一对一关系。

    hibernate一对一之唯一外键关联(双向关联)

    本篇主要探讨的是Hibernate中的一对一(OneToOne)关系映射,特别是唯一外键关联(UniDirectional and Bidirectional Association)的情况。我们将深入理解这种关联方式的配置、实现以及它在实际应用中的价值。 1. ...

    Hibernate一对一唯一外键关联映射(双向关联)

    一、Hibernate一对一关联类型 一对一关联在现实世界中很常见,例如一个人只有一个身份证,一个身份证也只能属于一个人。在数据库设计中,这种关系通常通过主键和外键的方式实现,其中一方的主键作为另一方的外键,...

    Hibernate 一对一关联映射(主键关联VS唯一外键关联)

    总结,主键关联和唯一外键关联都是Hibernate实现一对一映射的有效方式,各有优缺点。开发者应根据具体业务需求和数据模型,选择合适的关联策略。理解并熟练运用这些关联映射,对于提升Java后端开发的效率和代码质量...

    hibernate一对一之唯一外键关联(单向关联)

    总的来说,Hibernate的一对一唯一外键关联(单向关联)是通过在一方实体中定义另一方实体的引用,并通过注解或XML映射文件进行配置来实现的。这种关联方式简化了对象关系的管理,但同时也需要开发者在操作关联对象时...

    hibernate一对一唯一外键关联映射(单项关联)

    在本案例中,我们将详细探讨“hibernate一对一唯一外键关联映射(单项关联)”。 首先,一对一关联分为两种类型:单向关联和双向关联。单向关联意味着在一个实体类中存在对另一实体的引用,而另一实体类中没有相应...

    Hibernate一对一外键映射

    **标题:Hibernate一对一外键映射** 在关系型数据库中,一对一(One-to-One)关联是一种常见的关系,它表示两个实体之间存在着唯一的关系。Hibernate,作为Java领域中的一个流行的ORM(对象关系映射)框架,提供了...

    hibernate one-to-one 一对一唯一外键关联映射_单向 and 双向

    在本文中,我们将详细介绍Hibernate一对一唯一外键关联映射的概念、配置方法和实践应用。 一对一唯一外键关联映射的概念 在Hibernate中,一对一唯一外键关联映射是指两个实体之间的关联关系,其中一个实体作为外键...

    Hibernate ORM - 一对一外键关联关系

    "一对一(One-to-One)"外键关联是Hibernate支持的一种关系映射类型,用于描述两个实体之间一对一的关联关系。这种关系通常存在于具有唯一性的实体之间,例如一个人只有一个身份证,或者一个员工只有一个办公桌。 *...

    Hibernate教程05_关系映射之一对一双向外键关联

    在本教程中,我们将深入探讨Hibernate中的一个关键概念——关系映射,特别是“一对一”双向外键关联。这种关联类型在数据库设计中很常见,尤其是在处理具有紧密耦合的实体时。Hibernate作为Java中广泛使用的对象关系...

    Hibernate教程04_关系映射之一对一单向外键关联

    2. **一对一映射**:使用@OneToOne注解来声明一对一关系。可以设置 mappedBy 属性来指定关联的反向引用字段。 3. **外键实现**:在一对一关系中,外键可以放在任一实体的表中。若外键在从表,称为单向一对一关联;...

    hibernate 双向一对一基于外键的关联映射

    在本案例中,我们将探讨如何在Hibernate中实现基于外键的双向一对一关联映射。 首先,我们来看一下双向一对一关联的基本概念。双向一对一关联意味着两个实体类A和B,它们之间存在一对一的关系,并且A能访问B,B也能...

    hibernate一对一唯一外键关联映射(双向关联)

    本篇将深入探讨Hibernate中的一对一唯一外键关联映射,特别是双向关联的实现。 ### 1. 一对一关联概述 一对一关联意味着一个实体只能与另一个实体的单一实例相关联,这种关系通常出现在两个表之间,其中一个表的...

    Hibernate一对一单向外键关联 (联合主键annotation)

    本篇将详细讲解如何使用Hibernate进行一对一单向外键关联,并且该关联涉及到联合主键的注解配置。 首先,一对一关联可以分为两种类型:单向和双向。在单向一对一关联中,只有一个实体知道另一个实体的存在,而另一...

    hibernate多对多关联映射

    在Java的持久化框架Hibernate中,多对多关联映射是一种常见的关系数据库模型映射方式,用于处理两个实体之间存在多个实例互相关联的情况。本文将深入探讨Hibernate如何实现多对多关联映射,并通过实际例子解析相关...

    Hibernate双向一对一关联映射(注解版)

    单向一对一映射通常涉及一个实体持有另一个实体的引用,而双向一对一映射则意味着两个实体都可以互相引用。这种关联关系在数据库层面通常通过主键外键约束来实现,但在代码层面则通过注解来表达。 首先,我们需要...

    hibernate一对一外键关系

    在Hibernate中,实现一对一外键关系有几种方式,包括使用主键关联(Primary Key Association)和使用外键关联(Foreign Key Association)。我们首先来看主键关联: 1. **主键关联**:在这种模式下,一方实体的主键...

Global site tag (gtag.js) - Google Analytics