hibernate 注解方式讲解映射关系

注解方式讲解映射关系

1       One-To-One Unidirectional with Foreign Key

单向关联外键方式。

1.1         关系如下

学生和地址关系的例子。一个学生住在一个地址上。一个地址只能由一个学生占用。

1.2         Address代码:

package com.daodaofun.domain;

import javax.persistence.*;

@Entity
@Table(name="STUDENT")
public class Student {

    @Id
    @GeneratedValue
    @Column(name="STUDENT_ID")
    private Long id;

    @Column(name = "FIRST_NAME")
    private String firstName;

    @Column(name = "LAST_NAME")
    private String lastName;

    @OneToOne
    @JoinColumn(name = "ADDRESS_ID")
    private Address address;

    public Student() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}

这样可以不用写hbm.xml,还是挺方便的。此时注意在Student一端配置了JoinColumn,也就是关联的列,那么就会在Student表当中添加home_address_id这一列,作为外键。

外键名称如果需要指定可以使用@Foreignkey,遗憾的是这个版本已经是过时了,JPA的注解没有过时,但是无法加在这个属性之上,所以要么使用过时的注解,要么你忍受,或者你自行建表。

2       One-To-One Bidirectianal

所谓的双向配置也差不了多少,就是在另外一端一样加上引用即可,即在Address这一段一样持有Student。并且加上如下注解即可:

@OneToOne

private Student student;

但是这样有个问题,会导致双外键,这个明显属于冗余,这个时候我们需要指明谁来主导,外键由谁来建设的问题,所以我们需要额外设置一下如下:

@OneToOne(mappedBy = "address")

private Student student;

这样就比较合理了。

3      
Many-To-One Bidirectional

多对一双向

我们以学生与大学的关系为例,一所大学可以有很多学生。

关系图如下:

3.1        
University代码:

-··在一的一方配置OneToMany,同样的由于我们会将外键设置在多的一方,所以要将这个建设权交给对方,所以要加上mappedBy。

package com.daodaofun.domain;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="UNIVERSITY")
public class University {

    @Id
    @GeneratedValue
    @Column(name="UNIVERSITY_ID")
    private Long id;

    @Column(name="NAME")
    private String name;

    @Column(name="COUNTRY")
    private String country;

    @OneToMany(mappedBy = "university",cascade = CascadeType.ALL)
    private List<Student> students;

    public University() {
    }

    public University(String name, String country) {
        this.name = name;
        this.country = country;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }

}

3.2         Student代码:

package com.daodaofun.domain;

import javax.persistence.*;

@Entity
@Table(name="STUDENT")
public class Student {

    @Id
    @GeneratedValue
    @Column(name="STUDENT_ID")
    private Long id;

    @Column(name = "FIRST_NAME")
    private String firstName;

    @Column(name = "LAST_NAME")
    private String lastName;

    @ManyToOne(optional = false)
    @JoinColumn(name = "UNIVERSITY_ID")
    private University university;

    public Student() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public University getUniversity() {
        return university;
    }

    public void setUniversity(University university) {
        this.university = university;
    }
}

在多的一方,同样的指明建设外键是什么列加上JoinColumn,此外这里有一个optional=false,这个是什么含义呢?

(Optional) Whether the association is optional. If set

to false then a non-null relationship must always exist.

关联关系是否可选,如果设置为了false,那么就必须为非空关系。

4       Many-To-Many Bidirectional

双向多对多

在多对多关联中,使用了一个额外的表(称为联接表),其主键是两个关联表的主键的组合。换句话说,联接表和关联表之间存在外键关联表。

讨论一个学生和学科关系的例子。一名学生可以注册多个科目。一个科目可以有多个学生注册。

关系图如下:

向这种多多关系其实都是通过一张中间表来体现的。

4.1         Student代码:

package com.daodaofun.domain;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name="STUDENT")
public class Student {

    @Id
    @GeneratedValue
    @Column(name="STUDENT_ID")
    private Long id;

    @Column(name = "FIRST_NAME")
    private String firstName;

    @Column(name = "LAST_NAME")
    private String lastName;

    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "STUDENT_SUBJECT",joinColumns = {@JoinColumn(name = "STUDENT_ID")},
                inverseJoinColumns = {@JoinColumn(name = "SUBJECT_ID")})
    private List<Subject> subjects = new ArrayList<>();

    public Student() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public List<Subject> getSubjects() {
        return subjects;
    }

    public void setSubjects(List<Subject> subjects) {
        this.subjects = subjects;
    }
}

4.2         subject代码:

package com.daodaofun.domain;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "SUBJECT")
public class Subject {

    @Id
    @GeneratedValue
    @Column(name = "SUBJECT_ID")
    private Long id;

    @Column(name = "name")
    private String name;

    @ManyToMany(mappedBy = "subjects")
    private List<Student> students = new ArrayList<>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }
} 

这里可以指定任意一方来负责设置表的生成方式,此处是由subjects来设置,需要注意的是

@JoinTable(name = "STUDENT_SUBJECT",joinColumns = {@JoinColumn(name = "STUDENT_ID")},
                inverseJoinColumns = {@JoinColumn(name = "SUBJECT_ID")})通过name指定了中间表名称,然后指明需要生成的列,两列就是student表和subject表各自的主键。

以上几种是比较实用的映射关系方式,hibernate可以配置映射的方式特别多,上面几种差不多够用了。

原文地址:https://www.cnblogs.com/qiudaozhang/p/8468718.html

时间: 2024-11-06 03:53:14

hibernate 注解方式讲解映射关系的相关文章

Hibernate中的一对一映射关系

Hibernate中的一对一映射关系有两种实现方法(一对一关系:例如一个department只能有一个manager) I使用外键的方式 步骤:1在一对一关联的持久化类中互相添加对方对象属性,   例如在department中添加private manager manager属性:   department代码如下: package com.atguigu.hibernate.one2one.foreign; public class Department { private Integer d

Hibernate的七种映射关系之七种关联映射(二)

继续上篇博客 七.Hibernate双向一对多关联映射:让多的一端来维护关系. 主要是解决一对多单向关联的缺陷,而不是需求驱动的. 1.在Student.java实体类里添加Classes引用.private Classes classes; 2.Student.hbm.xml里添加many-to-one标签:<many-to-one name="classes" column="classesid"/>.Classes.hbm.xml在例子(六)里的那

Hibernate的七种映射关系之七种关联映射(一)

关联映射就是将关联关系映射到数据库里,在对象模型中就是一个或多个引用. 一.Hibernate多对一关联映射:就是在"多"的一端加外键,指向"一"的一端. 比如多个学生对应一个班级,多个用户对应一个级别等等,都是多对一关系. 1."多"端实体加入引用"一"端实体的变量及getter,setter方法. 比如说多个学生对应一个班级,在学生实体类加入:private Grade grade; 2."多"端配置文

hibernate注解方式来处理映射关系

在hibernate中,通常配置对象关系映射关系有两种,一种是基于xml的方式,另一种是基于annotation的注解方式,熟话说,萝卜青菜,可有所爱,每个人都有自己喜欢的配置方式,我在试了这两种方式以后,发现使用annotation的方式可以更简介,所以这里就简单记录下通过annotation来配置各种映射关系,在hibernate4以后已经将annotation的jar包集成进来了,如果使用hibernate3的版本就需要引入annotation的jar包. 一.单对象操作 @Entity

【8.0】注解方式代替映射文件

1.Book类 package cn.siggy.pojo; import java.util.Date; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; //entity表示需要持久化的实体类

Hibernate注解方式开发实体类

Hibernate注解 1.@Entity(name="EntityName") 必须,name为可选,对应数据库中一的个表 2.@Table(name="",catalog="",schema="") 可选,通常和@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息 name:可选,表示表的名称.默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名 catalog:可选,表示Cat

Hibernate 的七种映射关系

关联映射就是将关联关系映射到数据库里,在对象模型中就是一个或多个引用. 一.Hibernate多对一关联映射:就是在"多"的一端加外键,指向"一"的一端. 比如多个学生对应一个班级,多个用户对应一个级别等等,都是多对一关系. 1."多"端实体加入引用"一"端实体的变量及getter,setter方法. 比如说多个学生对应一个班级,在学生实体类加入:private Grade grade; 2."多"端配置文

SSH框架之Hibernate(1)——映射关系

ORM的实现思想就是将关系数据库中表的数据映射成对象,以对象的形式展现,这样开发人员就可以把对数据库的操作转化为对这些对象的操作.Hibernate正是实现了这种思想,达到了方便开发人员以面向对象的思想来实现对数据库的操作. Hibernate在实现ORM功能的时候主要用到的文件有:映射类(*.java).映射文件(*.hbm.xml)和数据库配置文件(*.properties/*.cfg.xml),它们各自的作用如下. 映射类(*.java):它是描述数据库表的结构,表中的字段在类中被描述成属

Hibernate注解版关联映射

在使用注解时,会遇到双向一对多和多对一问题,这里以order与orderitem举例,规定它们的关系是一对多. 在order中: 1 /* 2 * @OneToMany: 指明Order 与OrderItem关联关系为一对多关系 3 * 4 * mappedBy: 定义类之间的双向关系.如果类之间是单向关系,不需要提供定义,如果类和类之间形成双向关系,我们就需要使用这个属性进行定义, 5 * 否则可能引起数据一致性的问题. 6 * 7 * cascade: CascadeType[]类型.该属性