hibernate之关于多对一单向关联映射

【Hibernate】之关于多对一单向关联映射



在项目的开发中多对一的单向关联映射是最常见的,关联映射!这个着重详细讲解一下!

例如,我们现在一个组(Group)和人(Person)

(Person表)

id name
1 张三
2 李四

(Group表)

id name p_id
1 财务组 1
2 财务组 2

由上表我们发现,是不是出现数据的重复?财务组在重复!

所以,在多对一的单向映射中,我们通常是在多的一方加上外键来关联少的一方。

那么在这个关系中(Group)是少的一方,(Person)是多的一方,一个组里面可以有多个人!

(Group表)

id name
1 财务组
2 开发组

(Person表)

id name g_id
1 张三 1
2 李四 1

上面这种关系才是正常的业务逻辑!

ok,下面来看我们的Annotations配置!

@Entity
@Table(name="t_user")
publicclass Person {
    private Integer id;  
    private String name;
    private Integer age;
    private Group group;
    
    @ManyToOne
    public Group getGroup() {
       returngroup;
    }
    publicvoid setGroup(Groupgroup) {
       this.group = group;
    }
    @Id
    @GeneratedValue
    public Integer getId() {
       returnid;
    }
    publicvoid setId(Integerid) {
       this.id = id;
    }
    @Column(name="name")
    public String getName() {
       returnname;
    }
    publicvoid setName(Stringname) {
       this.name = name;
    }
    @Column(name="age")
    public Integer getAge() {
        returnage;
    }
    publicvoid setAge(Integerage) {
       this.age = age;
    }
}
@Entity
@Table(name="t_group")
publicclass Group {
    private Integer id;
    private String name;
    
    @Id
    @GeneratedValue
    public Integer getId() {
       returnid;
    }
    publicvoid setId(Integerid) {
       this.id = id;
    }
    @Column(name="name")
    public String getName() {
       returnname;
    }
    publicvoid setName(Stringname) {
       this.name = name;
    }
}

XML配置方法


package csg.hibernate.entity;
 
publicclass Person {
    private Integer id;
    private String name;
    private Integer age;
    private Group group;
    
    public Group getGroup() {
       returngroup;
    }
    publicvoid setGroup(Groupgroup) {
       this.group = group;
    }
    public Integer getId() {
       returnid;
    }
    publicvoid setId(Integerid) {
       this.id = id;
    }
    public String getName() {
       returnname;
    }
    publicvoid setName(Stringname) {
       this.name = name;
    }
    public Integer getAge() {
       returnage;
    }
    publicvoid setAge(Integerage) {
       this.age = age;
    }
}
package csg.hibernate.entity;
 
publicclass Group {
    private Integer id;
    private String name;
    
    public Integer getId() {
       returnid;
    }
    publicvoid setId(Integerid) {
       this.id = id;
    }
    public String getName() {
       returnname;
    }
    publicvoid setName(Stringname) {
       this.name = name;
    }
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="csg.hibernate.entity">
    <class name="Person" table="t_user">
       <id name="id">
           <generator class="native" />
       </id>
       <property name="name" />
       <property name="age"/>
       <many-to-one name="Group" column="group_id"/>
    </class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="csg.hibernate.entity">
    <class name="Group" table="t_group">
       <id name="id">
           <generator class="native"/>
       </id>
       <property name="name" />
    </class>
</hibernate-mapping>

到这里我们使用Junit测试一下

publicclass JuniTest {
privatestatic SessionFactory sessionFactory;
    
    @BeforeClass
    publicstaticvoid beforeClass() {
       Configuration cfg=new Configuration();
       cfg.configure();
       sessionFactory=cfg.buildSessionFactory();
    }
   
    @Test
    public  void add(){
       try {
           Group group=new Group();
           Session session = sessionFactory.getCurrentSession();
           session.beginTransaction();
           group.setName("部门");
           session.save(group);
           Person person=new Person();
           person.setAge(12);
           person.setName("张三");
           person.setGroup(group);
           session.save(person);
           session.getTransaction().commit();
       } catch (HibernateException e){
           e.printStackTrace();
       }
       
    }
    
    @AfterClass
    publicstaticvoid afterClass() {
       sessionFactory.close();
    }
}

ok!

时间: 2024-10-03 21:53:19

hibernate之关于多对一单向关联映射的相关文章

Hibernate之关于多对多单向关联映射

[Hibernate]之关于多对多单向关联映射 老师和学生,最典型的多对多关联, Teacher和Student.所谓单向意思就是说.老师知道自己的教的是哪些学生而学生不知道是哪些老师教. 也能够这么说,在查询的时候,通过老师能够级联查询出学生,可是通过学生不能够级联查询出老师. 而多对多最麻烦的是怎么自己定义我们中间表的,表名和列名,这个是重要的! Annotations配置 @Entity @Table(name="t_teacher") publicclass Teacher {

一口一口吃掉Hibernate(四)——多对一单向关联映射

hibernate对于数据库的操作,全部利用面向对象的思维来理解和实现的.一般的单独表的映射,相信大家都没有问题,但是对于一些表之间的特殊关系,Hibernate提供了一些独特的方式去简化它. 今天就来说说多对一的关联映射. 数据库中有多对一的关系,Hibernate自然也有对象的多对一的关联关系.比如用户和用户组,一个用户只属于一个组,一个组有多名用户.我们就可以说用户和用户组的关系就是多对一的关系.用对象的uml图表示一下: 在Hibernate中如何来实现呢?首先定义这两个实体类: pac

hibernate之关于一对多单向关联映射

[hibernate]之关于一对多单向关联映射 基于外键的一对多关联映射!一对多,Group(组)对于Person(人),一个组可以有多个人!ok? Hibernate主要有两种配置方法,一种是Annotations 一种是XML! 下面是Annotations的配置方法! @Entity @Table(name="t_group") publicclass Group { private Integer id; private String name; private Set<

Hibernate之关于多对多双向关联映射

[Hibernate]之关于多对多双向关联映射 多对多的双向关联映射在项目实战中还是相当重要的,所以这里着重写一下!以学生表(Student)和老师表(Teacher)为例. 首先我们还是先看Annotations配置! @Entity @Table(name="t_student") public class Student {     private Integer id;     private String name;     private Integer age;     

【SSH进阶之路】Hibernate映射——多对一单向关联映射(四)

[SSH进阶之路]Hibernate基本原理(一) ,小编介绍了Hibernate的基本原理以及它的核心,采用对象化的思维操作关系型数据库. [SSH进阶之路]Hibernate搭建开发环境+简单实例(二),小编搭建了基本Hibernate的开发环境,并做了一个简单实例,对它的基本原理有了一个理性的认识. [SSH进阶之路]Hibernate基本映射(三),我们介绍了Hibernate的基本映射(即对一个实体进行映射)的相关概念,并给大家实现相关实例,比较简单. 这篇博客,我们开始介绍基于基本映

Hibernate!!多对多(单向|双向)关联映射

多对多——单向关联映射 1 package com.hb.model; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 import javax.persistence.Entity; 7 import javax.persistence.GeneratedValue; 8 import javax.persistence.Id; 9 import javax.persistence.ManyToMany; 10 import

一口一口吃掉Hibernate(五)——一对多单向关联映射

版权声明:本文为博主原创文章,未经博主允许不得转载.如需转载请声明:[转自 http://blog.csdn.net/xiaoxian8023 ] 在上一篇博客<一口一口吃掉Hibernate(四)--多对一单向关联映射>中,介绍了多对一的关联映射,今天就反过来说一下一对多的单向关联映射. 可能有人会对这2篇博客的题目有点混淆不清,跟日常说的关系有点不同.我们日常说的比如父子关系,夫妻关系都是说的双向关系,而现在讨论的则是单向关系,所以也就有了多对一和一对多的说法. 二者的关系其实很简单,只是

【SSH进阶之路】Hibernate映射——一对一单向关联映射(五)

[SSH进阶之路]Hibernate基本原理(一) ,小编介绍了Hibernate的基本原理以及它的核心,采用对象化的思维操作关系型数据库. [SSH进阶之路]Hibernate搭建开发环境+简单实例(二),小编搭建了基本Hibernate的开发环境,并做了一个简单实例,对它的基本原理有了一个理性的认识. [SSH进阶之路]Hibernate基本映射(三),我们介绍了Hibernate的基本映射(即对一个实体进行映射)的相关概念,并给大家实现相关实例,比较简单. [SSH进阶之路]Hiberna

hibernate的映射之三(多对多单向关联)

Many-to-Many 多对多的映射可以使用一组Java集合不包含任何重复的元素来实现.我们已经看到了Hibernate如何设置映射集合. 集(SET)被映射到与映射表中<set>元素,并以java.util.HashSet初始化.您可以使用Set集合在类中时,集合不需要重复的元素. 在现实生活中多对多的例子挺多的. 例如:学生与老师,订单与商品等 下面我就以员工和项目来做例子,一个员工可以做多个项目,一个项目可以被多个员工做. 1.准备JavaBean 项目·实体·类 public cla