Hibernate对应关系（了解）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

布置的任务要用就写一下总结一下

hibernate有以下几种关系

一对一

一对多

多对一

多对多

首先这些对应关系是分单向和双向的单向和双向有什么区别呢？

这个双向单向是面向对象的说法意思就是你更新一个表另外一个表里面关联的数据跟着改变
双向就是这两个表无论哪一个更新另外一个表都更新单向就是只有一个主表更新从表才更新从表更新主表不管

单向：就是父亲管理孩子，父亲知道自己的孩子是谁，孩子并不知道自己的父亲是谁，比如我们user表单向一对多 book表我们在user表里面设置book 的外键关联，当我们查询数据库的时候只能查找用户的书籍有哪些，不能查看某一本书是哪个用户的

双向：查询的时候都可以从一方获取另一方的数据

注解的含义：

@Table(name = " ",catalog=" ", schema=" ")
//name表名，虽然可选，建议写上。catalog在MySql不支持，不必写。schema在MySql中指数据库名。

@Table(uniqueConstraints = {@UniqueConstraint(columnNames="name")})
或
@Column(name = "name",unique = true)
//指定建表时需要建唯一约束的列（使除主键外的列保持唯一约束）

@Embeddable
//表示一个非Entity类嵌入到一个Entity类作为属性而存在。
//使用方法，新建一个类注上该注解即可。在此类同样可使用注解对字段进行约束。

@embedded
//该注解是用来注释属性的，表示该类为嵌入类，同时，该类也得注释@Embeddable注解

@GeneratedValue(strategy=GenerationType)
GenerationType.AUTO //默认，根据底层数据库自动选择
GenerationType.INDENTITY //根据数据库的Identity字段生成
GenerationType.SEQUENCE //根据sequenqe来决定主键的取值
GenerationType.TABLE //使用指定表来决定主键取值，结合TableGenerator使用

@Id //自定义主键生成策略
@GeneratedValue(generator="sid")    //名字
@GenericGenerator(name="sid",strategy="assigned")   //策略

@EmbeddedId
//使用嵌入式主键类实现复合主键
//主键类必须实现Serializable接口，必须有默认的public无参构造方法，
//必须覆盖equals和hashCode()方法，必须注解@Embeddable
//使用时，把主键类对象当做参数传入Table类，对Table类进行保存即可。

@Transient
//表示该属性并非是到数据库表的字段的映射，否则默认注解@Basic

@Column(columnDefinition="TEXT", nullable=true)
//表示该字段为数据库中的TEXT类型，存储长文本

关系映射注解@OneToOne(cascade = {CascadeType.ALL})
CascadeType.PERSIST：级联新增（又称级联保存）：对order对象保存时也对items里的对象也会保存。对应EntityManager的presist方法。
CascadeType.MERGE：级联合并（级联更新）：若items属性修改了那么order对象保存时同时修改items里的对象。对应EntityManager的merge方法 。
CascadeType.REMOVE：级联删除：对order对象删除也对items里的对象也会删除。对应EntityManager的remove方法。
CascadeType.REFRESH：级联刷新：获取order对象里也同时也重新获取最新的items时的对象。对应EntityManager的refresh(object)方法有效。即会重新查询数据库里的最新数据。
CascadeType.ALL：以上四种都是。

hibernate的FetchType注解属性

FetchType.LAZY：懒加载，加载一个实体时，定义懒加载的属性不会马上从数据库中加载，即从数据库读到内存。
FetchType.EAGER：急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。也可以说成表示关联关系的从类在主类加载时同时加载

orphanRemoval=true

在一对多的关系当中，我们通常喜欢使用 CascadeType.ALL 假设现在有 user ，book 表一个用户对应多本书，当我们删除用户的时候通常会删除他所关联的书籍，当我们删除书本时如果不设置orphanRemoval=true 用户也会被删除，设置之后 user 就不会被删除

一对一：

单向：

@Entity
@Table(name="User")
public class User {
    @Id
    @GeneratedValue
    @Column(name="sid")
    private int sid;
 
    @Column(name="name")
    private String name;
 
    @OneToOne(cascade = {CascadeType.ALL})
    @JoinColumn(name = "pid",unique=true)
    //name=定义外键在本表的字段名，若只配置本类，则为单向关联
    //unique=true是指这个字段的值在这张表里不能重复，所有记录值都要唯一，就像主键那样
    private Room room;
    ...
}

双向：

@Entity
@Table(name="Room")
public class Room {
    @Id
    @Column(name="cid")
    private int cid;

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

    @OneToOne(mappedBy="room")//被控方
    //mappedBy同样指定由对方来进行维护关联关系    // 关于mappedBy的解释 参考博客：https://www.cnblogs.com/chiangchou/p/mappedBy.html
    private User user;
    ...

}

一对多：

单向：

//正常建表
@Entity
@Table(name="User")
public class User {
    @Id
    @GeneratedValue
    @Column(name="sid")
    private int sid;
    @Column(name="name")
    private String name;
     ...

}

@Entity
@Table(name="Room")
public class Room {
    @Id
    @GeneratedValue
    @Column(name="cid")
    private int cid;

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

    @OneToMany(cascade={CascadeType.ALL}, fetch=FetchType.LAZY) //一对多为Lazy，多对一为Eager
    @JoinColumn(name="cid") //name=定义外键在本表的字段名
    private Set<User> users;
    ...

}

多对一：

//正常建表
@Entity
@Table(name="Room")
public class Room {
    @Id
    @Column(name="cid")
    private int cid;
    @Column(name="addr")
    private String addr;
    ...
}

@Entity
@Table(name="User")
public class User {
    @Id
    @GeneratedValue
    @Column(name="sid")
    private int sid;

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

    @ManyToOne(cascade={CascadeType.ALL}, fetch=FetchType.EAGER)    //一对多为Lazy，多对一为Eager
    @JoinColumn(name="cid", referencedColumnName="cid") //name=定义外键在本表的字段名 rCN=关联外键对象的哪个字段
    private Room room;
    ...
}

双向（一对多，多对一）：

@Entity
@Table(name="User")
public class User {
    @Id
    @GeneratedValue
    @Column(name="sid")
    private int sid;

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

    @ManyToOne(cascade={CascadeType.ALL}, fetch=FetchType.EAGER)    //一对多为Lazy，多对一为Eager
    @JoinColumn(name="cid") //name=定义外键在本表的字段名
    private Room room;
    ...
}

@Entity
@Table(name="Room")
public class Room {
    @Id
    @GeneratedValue
    @Column(name="cid")
    private int cid;

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

    @OneToMany(cascade={CascadeType.ALL}, fetch=FetchType.LAZY) //一对多为Lazy，多对一为Eager
    @JoinColumn(name="cid") //name=定义外键在本表的字段名
    private Set<User> users;
    ...

}

多对多

多对多需要创建一张中间表

单向

@Entity
@Table(name="t_course")
public class Course
{
    @Id
    @GeneratedValue
    private int id;

    private String name;

    @ManyToMany　　　--->　ManyToMany指定多对多的关联关系
    @JoinTable(name="t_teacher_course",
    joinColumns={@JoinColumn(name="cid")},
    inverseJoinColumns={ @JoinColumn(name = "tid") })　
    /*因为多对多之间会通过一张中间表来维护两表直接的关系，所以通过 JoinTable
    这个注解来声明，我方是Course，所以在对方外键的名称就是 rid，
    inverseJoinColumns也是一个 @JoinColumn类型的数组，
    表示的是对方在我这放中的外键名称，对方是Teacher，所以在我方外键的名称就是 tid*/
    private Set<Teacher> teachers;

     ...

}

双向

@Entity
@Table(name="t_teacher")
public class Teacher
{
    @Id
    @GeneratedValue

    private String name;

    @ManyToMany(mappedBy="teachers")//表示由Course那一方来进行维护
    private Set<Course> courses;
    ...

}