Hibernate(三)对应关系

最新推荐文章于 2019-06-25 16:37:43 发布
转载 最新推荐文章于 2019-06-25 16:37:43 发布 · 131 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/u/3234821/blog/1830227

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

参考：https://www.cnblogs.com/alsf/category/1113061.html

 

一、单向多对一

　　　多个用户属于同一个组，多个学生属于同一个班级，多个学生属于同一个宿舍，等等，很多关系是这种多对一。因为上面是拿班级和学生来举测例子，那么所有的例子我度会用这个。为了方便和你们阅读。　　

　　　多个学生属于同一个班级。单向多对一　　　　

　　　User和Classes类的关系图。

　　　　　　　　　　　　　　　

　　　　　　　　　　　　数据库中存在外键值关系

　　　　　　　　　　　　

Hibernate映射

User类

package com.test.pojo;

import com.demo.pojo.BaseEntity;
import org.hibernate.annotations.GenericGenerator;
;

import javax.persistence.*;

@Entity
@Table(name = "ts_user01")
public class TUser  {



    private String uid;

    private String username;

    private String password;

    private TClass tClass;

    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    @ManyToOne()
    @JoinColumn(name = "cid")
    public TClass gettClass() {
        return tClass;
    }

    public void settClass(TClass tClass) {
        this.tClass = tClass;
    }




}

Class类

package com.test.pojo;

import com.demo.pojo.BaseEntity;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;

@Entity
@Table(name = "ts_class02")
public class TClass  {



    private String cid;

    private String name;


    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    public String getCid() {
        return cid;
    }

    public void setCid(String cid) {
        this.cid = cid;
    }



    public String getName() {
        return name;
    }

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

    使用Hibernate插入时 先保存class 再保存user

e867d0076051bee7516820188adc930a3d8.jpg

成功效果：

user表

4bf159ceedc3a6020e88d340882e2607cd4.jpg

class表

38ee335073b1f8b39b64f4a34b72fcd5371.jpg

模型关系图

31e193026ff674f86eed30749de77a9d86a.jpg

二、单向一对多

        说了单向多对一，现在来说说单向一对多，根据前面我们讲的，其实就是换了一个角度去想这个问题，学生和班级，现在站在班级这方去看，肯定是需要通过班级能知晓所有在这个班学习的同学的信息。　　　　

　　　　　　　　　　　　

　　　　　　　　数据库中还是没变，不管是单向一对多还是单向多对一，永远都市通过外键来维护关系的，单向多对一：通过映射文件知道，User的外键能够查找到对应的班级。单向一对多：又是怎么来实现通过User的外键找到属于本班的所有学生的呢？这就要看xx.hbm.xml映射文件如何写了。看下去你就会知道。

　　　　　　　　　　　　

　　　　User 不需要多方来维护关系(维护关系的意思就是不需要通过多方找到一方的信息。)所以就不在需要many-to-one了

User类

@Entity
@Table(name = "ts_user001")
public class User2 {
    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    private String uid;



    private String username;


    private String password;

    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

 Class类

@Entity
@Table(name = "ts_class002")
public class Class2 {
    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    private String cid;


    private String cname;

    @OneToMany(cascade= {CascadeType.ALL},fetch=FetchType.LAZY)
    @JoinColumn(name="cid")
    private Set<User2> user2Set;

    public String getCid() {
        return cid;
    }

    public void setCid(String cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public Set<User2> getUser2Set() {
        return user2Set;
    }

    public void setUser2Set(Set<User2> user2Set) {
        this.user2Set = user2Set;
    }
}

保存方法

a76ed2d1bd1fd7e26b495579f40375afede.jpg

user表效果

83d5dec726350b7a0fd6c65cb87a6079a5c.jpg

class表效果

e2e6ff28ac37f886bd814bd0165e97ed734.jpg

逆向数据库模型

6b35e45b064fa46e4804e7d1c6b060e80ab.jpg

三、双向多对一（一对多）

　不管哪种叫法都市一样的，别搞混淆了。

　　　　　　既然知道了单向一对多，和单向多对一，这个也就很简单了，就是通过双方度能够找到对方的信息。

　　　　　　　　　　　　　　　　　　

 

　　　　　　　　　数据库关系：还是跟上面两种是一样的。

　　　　　　　　

 

User类

package com.test.pojo;


import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Table;

import javax.persistence.*;

@Entity
@javax.persistence.Table(name = "tst_user003")
public class User3 {
    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    private String uid;

    private String username;

    private String password;

    @ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
    @JoinColumn(name = "cid")
    private Class3 class3;

    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Class3 getClass3() {
        return class3;
    }

    public void setClass3(Class3 class3) {
        this.class3 = class3;
    }
}

Class类

package com.test.pojo;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;
import java.util.Set;
@Entity
@Table(name = "tes_class003")
public class Class3 {

    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    private String cld;

    private String cname;

    @OneToMany(cascade= {CascadeType.ALL},fetch=FetchType.LAZY)
    @JoinColumn(name = "cid")
    private Set<User3> user3Set;

    public String getCld() {
        return cld;
    }

    public void setCld(String cld) {
        this.cld = cld;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public Set<User3> getUser3Set() {
        return user3Set;
    }

    public void setUser3Set(Set<User3> user3Set) {
        this.user3Set = user3Set;
    }






}

保存

62a4f556af8eec5da096b843ca8f44b772a.jpg

成功user表效果

9a8382856f59cf74910829199d4415d9b2b.jpg

成功class表

a4cd80a183bd44a05410d09801c325f5ece.jpg

逆向模型

e64cb58e47bfa3c4a3b3cb3fc083963e66c.jpg

四、建议用双向多对一  替代一对一

五、多对多

161155_1kFM_3234821.png

play类

package com.hibeTest.pojo;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "player")
public class Player {
    @Id
    @GeneratedValue
    private Integer pid;
    private String pname;
    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "pg", joinColumns = @JoinColumn(name = "pid"), inverseJoinColumns = @JoinColumn(name = "gid"))
    private Set<Game> games = new HashSet<Game>();

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public Set<Game> getGames() {
        return games;
    }

    public void setGames(Set<Game> games) {
        this.games = games;
    }
}

game类

package com.hibeTest.pojo;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "game")
public class Game {

    @Id
    @GeneratedValue
    private Integer gid;
    private String gname;
    @ManyToMany(mappedBy = "games",cascade = CascadeType.ALL)
    private Set<Player> players=new HashSet<Player>();

    public Integer getGid() {
        return gid;
    }

    public void setGid(Integer gid) {
        this.gid = gid;
    }

    public String getGname() {
        return gname;
    }

    public void setGname(String gname) {
        this.gname = gname;
    }

    public Set<Player> getPlayers() {
        return players;
    }

    public void setPlayers(Set<Player> players) {
        this.players = players;
    }
}

 

转载于:https://my.oschina.net/u/3234821/blog/1830227

hibernate的对应关系
10-27
在hibernate中有多种多样的对应关系，在这里我们具体写出一对一，多对多，一对多的对应关系代码以及数据库，希望对大家有
hibernate对应关系详解
01-03
对于hibernate的9中对应关系的代码详解和继承关系数据库表结构设计
Hibernate对应关系详解
ysynlm的专栏
08-07 1031
 many-to-one节点有以下属性（摘自Hibernate文档）：(1) name: 属性名。  (2) column (可选): 字段名。  (3) class (可选 - 默认是通过反射得到属性类型): 关联的类的名字。  (4) cascade（级联） (可选): 指明哪些操作会从父对象级联到关联的对象。  (5) outer-join（外连接） (可选 - 默认为 自动): 当设置hi
Hibernate对应关系（了解）
dianzanji4884的博客
03-25 156
布置的任务要用就写一下总结一下 hibernate有以下几种关系 一对一 一对多 多对一 多对多 首先这些对应关系是分单向和双向的 单向和双向有什么区别呢？ 这个双向单向是面向对象的说法 意思就是你更新一个表另外一个表里面关联的数据跟着改变双向就是这两个表无论哪一个更新另外一个表都更新 单向就是只有一个主表更新从表才更新 从表更新主表不管 单向：就是父亲管理孩子，父...
Hibernate几种对应关系详解[转]
aitunxian4985的博客
04-26 141
一：Hibernate 一对一连接表双向关联 1:模型介绍 一个人（Person）对应一个地址（Address）。 2:实体（省略getter、setter方法） public class Person11tab_sx { private int personid; private String name; private int age; ...
Hibernate对象对应关系总结
11-22
本文主要介绍了对象之间的对应关系，包含对象之间一对一，一对多双向，多对多的关系，另外简单介绍了二级缓存和分页
Hibernate 配置跟数据库字段的对应关系
03-01
本文将深入探讨如何在Hibernate配置中设置与数据库字段的对应关系，以及相关的Mysql数据库数据类型。 首先，我们需要理解Hibernate的核心配置文件`hibernate.cfg.xml`，在这个文件中，我们定义了数据源、持久化类...
Hibernate对应关系
会飞的猪
09-30 177
一对一关联主要有3种方式 1.两主键关联 2.外键关联 3.关联表关联 这三种方式hibernate annitation都提供了支持 这里重点讲第二种配置 配置步骤 一数据库表配置 表结构见附录 sns_topic表示一个论坛主题 sns_topic_views`表示帖子浏览量 topic.views_id持有topic_views.id,为多对一关联。但我们需要的是一对一关联 所以需要在vi...
关于hibernate中的对应关系
张亮的博客
03-22 700
首先 @一对一 比如一个男生只能有一个女朋友 那么在java代码中就该这么配置 //男生 public class Man{ private int id; //配置一对一 @OneToOne One(女生)ToOne(男生) private Girl girl; } //女生 public class Girl{ private int id; //女生里面也要配置一对一 @OneToOne
Hibernate的实体对应关系总结
全栈软件工程师-陈征峰的博客
06-17 460
总结Hibernate中实体对应关系的要点
10.1hibernate入门
qq_43629005的博客
02-11 216
1.下载hibernate框架 2.创建数据库和数据表 CREATE TABLE `cst_customer` ( `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)', `cust_name` VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)', `cust_sour...
hibernate 映射关系—关系映射（一对多）
pingnanlee的专栏
06-26 1078
映射关系 关系映射 一对多
Hibernate映射关系（一）
李长有的专栏
12-13 1966
本次测试的条件：eclipse3.2+MyEclipse5.0+Sql server 2K第一、在sql中建立两个表student，与coursestudent:：字段为stuId,stuName,courseIdcourse：字段为courseId,courseName两个表的DDL如下很简单：create table "tytc"."dbo"."student"(        "st
飞速的一周—hibernate的基本用法和映射对应关系
qq_44690106的博客
05-26 167
上一篇中已经把hibernate配置好了，这一篇就来讲讲它配置的文件里都是些什么玩意，顺便来了解一下映射实体关联关系。。 Hibernate.cfg.xml <session-factory> <property name="dialect"> org.hibernate.dialect.MySQLDialect </property> &lt...
Hibernate对JPA的扩展
老年程序员的博客
04-10 1994
Hibernate 3.1 提供了多种附加的注解，这些注解可以与EJB3的实体混合/匹配使用。他们被设计成EJB3注解的自然扩展。 为了强化EJB3的能力，Hibernate提供了与其自身特性相吻合的特殊注解。org.hibernate.annotations 包已包含了所有的这些注解扩展。 实体：Entity@org.hibernate.annotations.Entity 追加了可能需要的额外...
org.hibernate.annotations和javax.persistence区别
一只勤奋的PIG
06-25 1563
Hibernate是Java持久化API的一种实现，在可能的情况下，应该使用标准注释（在javax.persistence中）。这样，理论上可以在其他JPA实现上运行代码。 只有当需要Hibernate特定的功能时，才应该使用Hibernate注释。 额外的依赖性只在jpa接口/注释jar文件上，而且非常轻。 @org.hibernate.annotations.Entity是@javax.pe...
ssh项目-hibernate注解-自动建表时有注释
privateobject的博客
08-27 5034
最近在项目中，有小组成员提出数据库的表及字段没有注释的问题。通过自己在网上和查看源码，解决创建表时，注释的添加。 字段的注释，本方法只适用于MySQL数据库，其他的数据库根据数据库sql自行修改。 第一个查到的资料，说实话本来不抱希望的，在看到这个有点信心： hibernate注解(自动建表如何有表DDL注释) -- Comment用法 在项目中，有用到hibernate Annotati...
@Entity该导入哪个包
I'm Sure
12-15 2216
在@Entity时很容易顺手导入@org.hibernate.annotations.Entity这个包，结果导致了异常。其实应该导入的是@javax.persistence.Entity [b]Always[/b] import @javax.persistence.Entity @org.hibernate.annotations.Entity是@javax.persistence.E...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值