Hibernate实体映射关系配置

最新推荐文章于 2020-08-21 08:46:07 发布
最新推荐文章于 2020-08-21 08:46:07 发布
阅读量103 收藏
点赞数
分类专栏： Hibernate 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shen_zhenbiao/article/details/84009329
版权

Hibernate实体关系：双向关联，mappedBy必设

注解方式

1、一对一单向

@Entity       

public class Husband{

           @Id

           @GenerateValue

             pirvate int id;

             private String name;

            @OneToOne

            @JoinColumn(name="wifeId")

             private Wife wife;

      }

         @Entity

     public class Wife{

           @Id

           @GenerateValue

         private int id;

         private String name;

    }

2.、一对一双向

@Entity       

public class Husband{

           @Id

           @GenerateValue

             pirvate int id;

             private String name;

            @OneToOne

            @JoinColumn(name="wifeId")

             private Wife wife;

      }

 

         @Entity

     public class Wife{

           @Id

           @GenerateValue

         private int id;

         private String name;

       @OneToOne(mappedBy="wife")

        private Husband husband;

    }

3.、一对多单向

package com.bjsxt.hibernate;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="t_group")
public class Group {
 private int id;
 private String name;
 private Set<User> users = new HashSet<User>();
 @Id
 @GeneratedValue
 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;
 }
 @OneToMany
 @JoinColumn(name="groupId")  //不加出现3张表
 public Set<User> getUsers() {
  return users;
 }
 public void setUsers(Set<User> users) {
  this.users = users;
 }
}

package com.bjsxt.hibernate;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_user")
public class User {
 private int id;
 private String name;
 @Id
 @GeneratedValue
 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;
 }
}

4、多对一单向

package com.bjsxt.hibernate;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="t_group")
public class Group {
 private int id;
 private String name;
 @Id
 @GeneratedValue
 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.bjsxt.hibernate;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="t_user")
public class User {
 private int id;
 private String name;
 private Group group;
 @ManyToOne
 
 public Group getGroup() {
  return group;
 }
 public void setGroup(Group group) {
  this.group = group;
 }
 @Id
 @GeneratedValue
 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;
 }
}

5、一对多双向

package com.bjsxt.hibernate;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="t_group")
public class Group {
 private int id;
 private String name;
 private Set<User> users = new HashSet<User>();
 @Id
 @GeneratedValue
 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;
 }
 @OneToMany(mappedBy="group")
 
 public Set<User> getUsers() {
  return users;
 }
 public void setUsers(Set<User> users) {
  this.users = users;
 }
}

package com.bjsxt.hibernate;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_user")
public class User {
 private int id;
 private String name;
 private Group group;
 @ManyToOne
 public Group getGroup() {
  return group;
 }
 public void setGroup(Group group) {
  this.group = group;
 }
 @Id
 @GeneratedValue
 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;
 }
}

6、多对多单向

@Entity
public class Student {
 private int id;
 private String name;
 @Id
 @GeneratedValue
 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;
 }
}

@Entity
public class Teacher {
 private int id;
 private String name;
 private Set<Student> students = new HashSet<Student>();
 @Id
 @GeneratedValue
 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;
 }
 @ManyToMany
 @JoinTable(name="t_s",
  joinColumns={@JoinColumn(name="teacher_id")},
  inverseJoinColumns={@JoinColumn(name="student_id")}
  )    //改变中间表的名字和字段名字
 public Set<Student> getStudents() {
  return students;
 }
 public void setStudents(Set<Student> students) {
  this.students = students;
 }
}

7、多对多双向

@Entity
public class Student {
 private int id;
 private String name;
 private Set<Teacher> teachers = new HashSet<Teacher>();
 @ManyToMany(mappedBy="students")
 public Set<Teacher> getTeachers() {
  return teachers;
 }
 public void setTeachers(Set<Teacher> teachers) {
  this.teachers = teachers;
 }
 @Id
 @GeneratedValue
 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;
 }
}

@Entity
public class Teacher {
 private int id;
 private String name;
 private Set<Student> students = new HashSet<Student>();
 @Id
 @GeneratedValue
 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;
 }
 @ManyToMany
 @JoinTable(name="t_s",
  joinColumns={@JoinColumn(name="teacher_id")},
  inverseJoinColumns={@JoinColumn(name="student_id")}
  )
 public Set<Student> getStudents() {
  return students;
 }
 public void setStudents(Set<Student> students) {
  this.students = students;
 }
}

XML配置

1、一对一单向

<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <many-to-one name="address" 
        column="addressId" 
        unique="true"
        not-null="true"/>
</class>
 
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>

2.、一对一双向

<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <many-to-one name="address" 
        column="addressId" 
        unique="true"
        not-null="true"/>
</class>
 
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
   <one-to-one name="person" 
        property-ref="address"/>
</class>

3.、一对多单向

<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <set name="addresses">
        <key column="personId" 
            not-null="true"/>
     <one-to-many class="Address"/>
    </set>
</class>
 
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>

4、多对一单向

<class name="Person">
    <id name="id" column="personId">
        <generator class="native"/>
    </id>
    <many-to-one name="address" 
        column="addressId"
        not-null="true"/>
</class>
 
<class name="Address">
    <id name="id" column="addressId">
        <generator class="native"/>
    </id>
</class>

5、一对多双向

<hibernate-mapping>

 <class name="com.bjsxt.hibernate.Group" table="t_group">

  <id name="id">

   <generator class="native"></generator>

  </id>

  

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

  <set name="users" inverse=”true”>

   <key column="groupId"></key>  //与<many-to-one>的column一致

   <one-to-many class="com.bjsxt.hibernate.User"/>

  </set>

    </class>

 

</hibernate-mapping>

<hibernate-mapping>
 <class name="com.bjsxt.hibernate.User" table="t_user">
  <id name="id">
   <generator class="native"></generator>
  </id>
  
  <property name="name"></property>
  <many-to-one name="group" column="groupId"></many-to-one>
    </class>
</hibernate-mapping>

6、多对多单向

<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Student">
  <id name="id">
   <generator class="native"></generator>
  </id>
  
  <property name="name"></property>
    </class>
</hibernate-mapping>

 

<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Teacher">
  <id name="id">
   <generator class="native"></generator>
  </id>
  <property name="name"></property>
  <set name="students" table="t_s">
   <key column="teacher_id"></key>
   <many-to-many class="com.bjsxt.hibernate.Student" column="student_id"/>
  </set>
    </class>
</hibernate-mapping>

7、多对多双向

<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Student">
  <id name="id">
   <generator class="native"></generator>
  </id>
  
  <property name="name"></property>
  <set name="teachers" table="t_s" inverse=”true”>
   <key column="student_id"></key>
   <many-to-many class="com.bjsxt.hibernate.Teacher" column="teacher_id"/>
  </set>
    </class>
</hibernate-mapping>

<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Teacher">
  <id name="id">
   <generator class="native"></generator>
  </id>
  
  <property name="name"></property>
  <set name="students" table="t_s">
   <key column="teacher_id"></key>
   <many-to-many class="com.bjsxt.hibernate.Student" column="student_id"/>
  </set>
    </class>
</hibernate-mapping>

 

shen_zhenbiao
关注
专栏目录
4.Hibernate的映射配置
yun1996的博客
07-23 221
1.映射文件的加载 在主配置文件配置 <mapping resource="cn/itcast/a_hello/Employee.hbm.xml"/> 在类中加载（测试用） private static SessionFactory sf; static { // 创建sf对象 sf = new Configuration() .configure() .addClass(Em...
Entity Framework Core 实体关系的配置
flyingdream123的专栏
03-16 158
文章目录 1. 术语介绍 2. 关系自动配置 2.1 完整配置 2.2 无外键情况下进行配置 2.3 无“导航属性对”情况下配置 3. 关系手动配置 3.1 无“导航属性对”时手动配置 3.2 手动指定外键 3.3 无导航属性时手动配置 3.4 将外键指向到非主键上 3.5 设置外键可否为空 3.6 设置级联删除 4. 其他关系的配置 4.1 一对一 4.2 多对多 1. 术语介绍 Dependent entity: 依赖实体（子实
hibernate实体关系
Imust_can的专栏
12-11 3053
1、一对一关系 数据库中的一对一设计分两种形式： （1）      外键关联：一个表中添加一个字段作为外键，值是与其相对应一对一关系表的主键值。 （2）      主键关联：两张一对一关系的表共用一个主键，主外键是一个字段。   在实体关系中 （1）      单向关联，在任意一个实体类中添加另一个实体类型的属性 （2）      双向关联，在两个实例类中都添加另一个实体类型的属性
Hibernate设计实体及实体映射
macx_1371873xxxx的博客
07-06 645
一、如何设计实体       1、业务需求：部门、用户、岗位；根据业务需求，可以体现出以下关系：           A.用户与部门：一个用户只能有一个部门      ----一对多的关系；           B.用户与角色：一个用户可有多个角色，一个角色也可有多个用户     ----多对多的关系；           C.部门与部门：一个部门只能有一个父节点部门    ----一对一的关系；...
Hibernate总结之二实体与表的映射关系
mayiha85的专栏
02-05 509
       今天趁自己的心情不错，顺便来总结一下有关hibernate中实体与表的映射关系。写此文章有三个目的：第一，总结一下hibernate为以后查看方便。第二，通过此文章我相信能起到抛砖引玉的作用。第三，和爱好者一起切磋。        hibernate中实体与表的映射关系我大概的分了十一种形式，基本映射、普通的集合映射、组件映射、复合主键映射、  继承映射（每棵继承树映射成一张
IntelliJ IDEA下自动生成Hibernate映射文件以及实体类
08-25
在配置了数据库后，需要生成Hibernate实体类。点击窗口中的Persistence，然后在Persistence中右键项目，然后点击Generate Persistence Mapping，选择By Database Schema。在弹出的窗口中，选择数据源，配置实体类包...
浅谈hibernate中多表映射关系配置
08-30
在Java持久化框架Hibernate中，多表映射关系配置是数据库模型在对象关系映射（ORM）中的体现，它使得数据库中的多个表可以对应到Java对象间的多种关系。以下是关于Hibernate中三种主要的多表映射关系：一对一、一对...
Hibernate映射关系配置：XML方式和注解方式
03-27
`hibernate实体映射关系.doc`可能包含了详细讲解Hibernate实体映射关系的文档，涵盖XML和注解两种方式的具体配置，包括但不限于： - 实体类的创建与映射 - 主键生成策略的配置 - 不同关联关系（一对一、一对多、多...
Hibernate使用hbm.xml配置映射关系解析
08-28
Hibernate 使用 hbm.xml 配置映射关系解析 Hibernate 是一个流行的对象关系映射（ORM）工具，它提供了使用 XML 文件（hbm.xml）来配置映射关系的方式。这种方式可以将 Java 类与数据库表进行映射，使得开发者可以更...
Hibernate_关联关系映射配置
08-01
本教程将详细讲解Hibernate中的关联关系映射配置，帮助你理解和掌握如何在Hibernate中设置不同类型的关联。 一、一对一（One-to-One）关联 在现实世界中，两个实体之间可能存在一对一的关系，例如一个人只有一个...
【大话Hibernate】Hibernate两种实体关系映射详解
lmb55的专栏
06-18 4812
 实体类与数据库之间存在某种映射关系，Hibernate依据这种映射关系完成数据的存取，因此映射关系的配置在Hibernate中是最关键的。Hibernate支持xml配置文件与@注解配置两种方式。xml配置文件是最基础的配置，而@注解是Java的官方JPA（Java Persistence API）提供的。本章分别使用@注解与xml讲解Hibernate的映射配置。一、实体类映射： 从Java的...
hibernate用注解配置实体类的映射
weixin_30861797的博客
09-26 374
一、注解类 1. @Table 声明了该实体bean映射指定的表（table），目录（catalog）和schema名字 2. @Id 声明了该实体bean的标识属性（对应表中的主键）。 3. @Column 声明了属性到列的映射。该注解有如下的属性： name 可选，列名（默认值是属性名） unique 可选，是否在该列上设置唯一约束（默...
hibernate基本的配置-xml(实体映射)和简单使用
liangwenrong的博客
03-09 2988
hibernate基本配制简单使用
hibernate实体类配置文件
changyuming的专栏
02-26 5449
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    Mapping file autogenerated by MyEclipse - Hibernate Tools-->                                                                           
【HibernateHibernate实体关系映射——双边的多对一、一对多关系
lmb55的专栏
06-18 3051
双边的多对一、一对多关系      双边关系是最常见的配置。在多方有一方的引用，一方也有多方的引用。双边关系能够很方便的查询数据。下面以一个班级与学生的双边关系来深入学习。      班级（clazz类）与学生（student类）为一对多关系。班级中有学生属性，学生中有班级属性，二者是双边的关系。 具体代码如下： Clazz类中有一个id主键和一个name属性，另外还有一个List&lt;Stu...
jpa实体类之间关系配置的坑
qq_44864447的博客
08-21 444
在业务开发中我们难免有时候查询到一个实体类的数据项获取到其关联的其他实体的数据，那么这个时候就要在实体类中配置关联关系。通常我们配置关联关系之前我们会在数据库表中添加指向另外一个表的一个外键（也可以不用外键，只需在实体类中配置关系即可，不建议使用外键，因为外键有较强的关联约束），但是这个时候你得注意了虽然不配置外键也可以配置关联关系，但是今天在项目中我却遇到了一个坑。因为我配置了关联关系之后居然单表根据id查询出来的数据居然为空，我很纳闷，明明数据库中就有这条数据。在经历了一番波折之后我想到了去看jpa运行
Hibernate实体映射配置1（java@注解方式）
热门推荐
yanwushu的博客
05-17 1万+
实体和数据库之间存在某种映射关系，hibernate根据这种映射关系完成数据的存取。在程序中这种映射关系由映射文件（*.hbm.xml）或者java注解(@)定义。 本文以java注解的形式总结映射关系配置。 实体类组件以及注解标签映射关系 实体类-----------@Entity/@Table----------数据表 Id--------------@Id--------
EF里实体关系配置的方法
kxinyu的专栏
09-27 1088
EF里的实体关系配置分为Has和With系列的方法：Optional 可选的、Required 必须的、Many 多个。举例： ///     /// 用户照片类     ///     public class PersonPhoto     {         [Key]         public int PersonId { get; set; }         p
model实体类中Hibernate注解说明
dodo0_0的专栏
09-16 2438
Hibernate注解 1。@Entity(name="EntityName") 必须,name为可选,对应数据库中一的个表 2、@Table(name="",catalog="",schema="") 可选,通常和@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息 name:可选,表示表的名称.默认地,表名和
Hibernate 实体关系映射：多对多关系配置详解
以下是关于Hibernate实体关系映射的详细讲解： 1. **hibernate.show_sql**: 这个属性控制着Hibernate是否在控制台打印执行的SQL语句。当设置为`true`时，可以方便地查看和调试应用程序与数据库之间的交互。 2. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值