Hibernate之关联映射（上）

最新推荐文章于 2017-10-16 19:40:45 发布
最新推荐文章于 2017-10-16 19:40:45 发布
阅读量134 收藏
点赞数
分类专栏： 理论知识 xml代码 hibernate 文章标签： hibernate 关联映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21954477/article/details/77880112
版权

关联映射可分为四种：
分别为：一对一，一对多，多对一，多对多。
1、一对多和多对一：适用于一个部门有多个员工等场景。
用买家与订单的关系来做演示：
买家：User.java

public class User {
    private int uId;
    private String uPassword;
    private Set<String> addresses=new HashSet<String>();
    private Set<Good> goods=new HashSet<Good>();
    public int getuId() {
        return uId;
    }
    public void setuId(int uId) {
        this.uId = uId;
    }
    public String getuPassword() {
        return uPassword;
    }
    public void setuPassword(String uPassword) {
        this.uPassword = uPassword;
    }
    public Set<String> getAddresses() {
        return addresses;
    }
    public void setAddresses(Set<String> addresses) {
        this.addresses = addresses;
    }
    public Set<Good> getGoods() {
        return goods;
    }
    public void setGoods(Set<Good> goods) {
        this.goods = goods;
    }
    @Override
    public String toString() {
        return "User [uId=" + uId + ", uPassword=" + uPassword + ", addresses=" + addresses + ", goods=" + goods + "]";
    }
}

User的映射文件：User.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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
            default-lazy="false"
 -->       
 <hibernate-mapping  package="com.wc.entity"  > 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="User" table="u_user">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="uId">
            <generator class="native"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列  
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)


        -->
        <property name="uPassword"></property>
        <set name="addresses" table="t_address" cascade="save-update">
            <key column="uId"></key>

             <element column="address" type="java.lang.String"></element>
        </set>
        <set name="goods" table="t_good" cascade="save-update">
            <key column="uId"></key>
            <one-to-many class="Good" />
        </set>

    </class>
</hibernate-mapping>

一对多的主要代码：当用一的一边去维护多的一边，配置该关联。（用买家去维护订单）

    <set name="goods" table="t_good" cascade="save-update">
            <key column="uId"></key>
            <one-to-many class="Good" />
        </set>

订单：Good.java

public class Good {
    private int gId;
    private String gName;
    private User user;
    private String address;
    public int getgId() {
        return gId;
    }
    public void setgId(int gId) {
        this.gId = gId;
    }
    public String getgName() {
        return gName;
    }
    public void setgName(String gName) {
        this.gName = gName;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }

    public Good(String gName, String address) {
        super();
        this.gName = gName;

        this.address = address;
    }
    @Override
    public String toString() {
        return "Good [gId=" + gId + ", gName=" + gName + ", address=" + address + "]";
    }
    public Good() {
        super();
    }

}

订单的配置文件：Good.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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
 -->       
 <hibernate-mapping  package="com.wc.entity"> 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="Good" table="u_good">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="gId">
            <generator class="native"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列        
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)


        -->
        <property name="gName"></property>
        <many-to-one name="user" class="User" column="uId" cascade="all"></many-to-one>
       <property name="address"></property>

    </class>
</hibernate-mapping>

多对一的主要代码：当用多的一边去维护一的一边，配置该关联。（订单去维护买家）

 <many-to-one name="user" class="User" column="uId" cascade="all"></many-to-one>

注意：多对一与一对多，用哪一边去维护另一边，就用哪一边来配置映射文件的关系。也可以两边都配。（T维护t：就是通过T去绑定t,换句话说，就是在创建T对象的时候，把t作为T的属性）

2、多对多：适用于老师与学生的这种关系
老师有多个学生，学生有多个老师。
实例：
学生类：Student.java

public class Student {
    private int sId;
    private String sPassword;
    private Set<Teacher> teachers=new HashSet<Teacher>();
    public int getsId() {
        return sId;
    }
    public void setsId(int sId) {
        this.sId = sId;
    }
    public String getsPassword() {
        return sPassword;
    }
    public void setsPassword(String sPassword) {
        this.sPassword = sPassword;
    }
    public Set<Teacher> getTeachers() {
        return teachers;
    }
    public void setTeachers(Set<Teacher> teachers) {
        this.teachers = teachers;
    }


}

学生映射文件：Student.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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
 -->       
 <hibernate-mapping  package="com.wc.entity"  default-lazy="false"> 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="Student" table="u_student">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="sId">
            <generator class="native"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列  
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)


        -->
        <property name="sPassword"></property>
        <set name="teachers" table="t_real" cascade="save-update">
            <key column="sId"></key>
            <many-to-many class="Teacher" column="tId"></many-to-many>
        </set>

    </class>
</hibernate-mapping>

主要代码：

    <set name="teachers" table="t_real" cascade="save-update">
            <key column="sId"></key>
            <many-to-many class="Teacher" column="tId"></many-to-many>
        </set>

老师类：Teacher.java

public class Teacher {
    private int tId;
    private String tName;
    private Set<Student> students=new HashSet<Student>();
    public int gettId() {
        return tId;
    }
    public void settId(int tId) {
        this.tId = tId;
    }
    public String gettName() {
        return tName;
    }
    public void settName(String tName) {
        this.tName = tName;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }

}

映射文件：Teacher.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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
 -->       
 <hibernate-mapping  package="com.wc.entity"  default-lazy="false"> 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="Teacher" table="u_user">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="tId">
            <generator class="native"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列  
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)


        -->
        <property name="tName"></property>
        <set name="students" table="t_real" cascade="save-update">
            <key column="tId"></key>
            <many-to-many class="Student" column="sId"></many-to-many>
        </set> 

    </class>
</hibernate-mapping>

主要代码：

<set name="students" table="t_real" cascade="save-update">
            <key column="tId"></key>
            <many-to-many class="Student" column="sId"></many-to-many>
        </set>

T维护t，就在T的映射文件中配置多对多的映射关系。也可以两边都配。

w春
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate映射解析之关联映射详解
08-31
Hibernate是Java开发中常用的持久层框架，它简化了数据库操作，其中关联映射是实现对象关系映射的关键部分。关联映射允许我们将对象之间的关联关系映射到数据库的表结构中，使得对象模型和数据库模型能够无缝对接。...
hibernate一对多关联映射学习小结
08-29
Hibernate的关联映射是其核心功能之一，可以将Java对象之间的关系映射到数据库表之间的关系中。 一对多关联映射是Hibernate中的一种常见的关联映射类型，它表示一个对象可以拥有多个其他对象的引用。在Hibernate中...
hibernate多对多关联映射
04-05
总之，Hibernate的多对多关联映射是解决复杂关系数据库设计的关键技术之一。通过合理的配置和使用，开发者可以轻松管理实体之间的多对多关系，提高开发效率。理解并熟练掌握这部分知识对于提升Java企业级应用开发...
hibernate关联映射实例
09-01
本文将深入探讨“hibernate关联映射实例”中的关键知识点，包括一对多、多对多和继承映射，这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**： 在现实世界中，一个实体可能会与多个其他实体相关联，...
hibernate之关于关联映射的综合应用
03-21
综上所述，Hibernate的关联映射是实现对象关系映射的关键，它允许我们在Java代码中直接操作对象，而无需关心底层数据库的细节。通过合理配置`@ManyToMany`、`@OneToMany`等注解，以及使用中间表和级联操作，可以有效...
Spring七大模块之DAO（上）
qq_21954477的博客
09-14 2964
Spring的Dao模块式Spring框架中对应持久层的解决方式，提供了对JDBC、Hibernate、JDO等DAO层支持。 Spring框架对JDBC进行了封装，完全抛弃了JDBC API。数据库连接、事务等也交给了Spring打点，开发者只需要使用封装好的JdbcTemplate执行SQL语句，然后得到需要的结果。 需要的包： 项目目录： User.javapublic cla
Hibernate xml配置
qq_21954477的博客
09-04 1660
配置Hibernate
异常之java.lang.NoSuchMethodError
qq_21954477的博客
10-16 1182
Exception in thread “main” java.lang.NoSuchMethodError: org.hibernate.cfg.annotations.reflection.XMLContext.(Lorg/hibernate/boot/spi/ClassLoaderAccess;)V 此处的错误的原因是： 在一个java项目中，直接建一个lib文件夹，加入第三方的包
Spring七大模块之Core
qq_21954477的博客
09-12 779
Core这个核心功能包就是用来实现IOC/DI的。* IOC：*控制反转，指的是用配置文件或注解来完成对象的创建。 * DI：*依赖注入。 依赖：就是我们的层与层之间的依赖， 在实际开发中引入各个框架的时候也会形成一定的依赖，例如Servlet 依赖于 service，service 依赖于 dao。 注入：就是生成对象或值。
Spring与Hibernate整合(注解模式)
qq_21954477的博客
09-14 426
整个程序代码 User.javapublic class User { private int uId; private String uName; private String uPassword; public int getuId() { return uId; } public void setuId(int uId) {
Spring七大模块之AOP
qq_21954477的博客
09-13 331
AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理
Spring七大模块之DAO (下)
qq_21954477的博客
09-14 329
操作数据库，需要严谨，所以需要事务。 例如，在做转账的时候，如果不严谨，就会造成一方的钱减少了，另一方的钱却没增加；或者是一方的钱增加了，另一方的钱却没减少。 首先通过配置方式,来实现事务。 UserDao.java (数据库中已有数据)public class UserDao{ //下面这个就是访问数据库的对象 private JdbcTemplate jdbcTempla
Java接口回调
qq_21954477的博客
09-15 316
突然想起了，今天刚自学了java的接口回调，来整理一下。 实例：我经常叫我同学帮我买早饭，就拿这个做例子。 场景：我在上班时给他发了个短信：“帮我买一下早饭”然后我就去坐车了;然后他收到信息后，就去买早饭了，买到后就给我回复短信：买到了。 然后就开始实现： 1、一个回调接口：ICallBack.java/** * 回调接口 * @author Administrator * */ p
Spring与Hibernate整合(配置模式)
qq_21954477的博客
09-14 266
Spring与Hibernate整合的作用： 1、使用Spring的IOC容器管理SessionFactory对象 2、让Hibernate使用上Spring的声明式事务 Hibernate和Spring整合的时候的整合的关键点：SessionFactory 整合步骤： (1)、添加jar包 Hibernate核心功能包 Spring的相关包 Spring和Hi
Hibernate之查询
qq_21954477的博客
09-07 261
Hibernate的查询常用的分为三种： 1、HQL—>Hibernate Query Language 2、 SQL—>本地的查询 3、Cretiria查询:是Hibrnate的设计者为了方便 不会编写Sql语句的人使用的 其中最常用的是HQL，这里主要说的也是HQL。 HQL(在Hibernate中使用最多的) 面向对象的查询 具有高的可移植性 和底层的表没有关系 即
MyBatis入门（二）
qq_21954477的博客
09-26 254
Sql片段的使用，可以将重复的部分提出来，成为Sql片段。<select id="findUserByManyCondition" parameterType="map" resultType="com.wc.test01.User"> select * from t_user <where> 1=1 </where> <if test="uName
初识Spring
qq_21954477的博客
09-11 210
初识Spring 以前提到web经常会听到Spring这个框架，今天初识了Spring。 Spring是整合框架，它开发了我们开发中要使用的框架，同时它也给我们整合了许多其他好用的框架，例如：Hibernate、Mybatis、Shiro等等。 Spring是什么？ Spring是整合框架，它开发了我们开发中要使用的框架，同时它也给我们整合了许多其他好用的框架，例如：Hibernate、Myba
23种设计模式之简介
qq_21954477的博客
09-13 203
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。 作用：使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 设计模式分类： 第一类：创建型模式 工厂模式（Factory Pattern） 抽象工厂模式（Abstract Factory Patt
MyBatis入门（一）
qq_21954477的博客
09-26 189
MyBatis（iBatis）与Hibernate类似，也是一个持久层解决方案，是我们更方便的操作数据库。 MyBatis的特点： 执行效率：JDBC>MyBatis>Hibernate 代码我复杂度：JDBC>MyBatis>Hibernate 执行流程： 1>:加载我们的mybatis.xml文件 2>:加载的是我们的mapper的映射文件 3>:通过你调用的方法 找到我们的ma
Hibernate关联映射详解：从基础到租房系统应用
本资源是一份名为"02-Hibernate 关联映射.pdf"的PDF电子书，主要讲解了Hibernate框架中的关联映射...通过这份资料，读者可以深入理解Hibernate关联映射在实际项目中的运用，提升数据库操作的灵活性和代码组织的清晰度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值