hibernate映射关系

多对一单项关联

例：学生和班级的关系，学生为多方，班级为一方
实现

/**
*学生类，相当于加一个外键
*/
@Data
@Entity
public class Student {
    @Id
    @Column(name = "student_id")
    private Integer studentId;
    @Column(name = "student_name")
    private String studentName;
    @Column(name = "student_age")
    private String studentAge;
//    fetch = FetchType.EAGER急加载
    @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "class_id", referencedColumnName = "class_id")
    private ClassRoom classRoom;
}

/**
*班级类，无需任何配置
*/
@Data
@Entity
public class ClassRoom {
    @Id
    @Column(name = "class_id")
    private Integer classId;
    @Column(name = "class_name")
    private String className;
}

最终实现效果就是相当于在Student表中再添加一个外键，指向class_room表的class_id,而class_room表任然是一个单纯的表

一对多单项关联

还是上边的例子，只不过翻了过来
实现：

@Data
@Entity
@Table(name = "otm_class_room")
public class ClassRoom {
    @Id
    @Column(name = "class_id")
    private Integer classId;
    @Column(name = "class_name")
    private String className;
    @OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.LAZY)
    @JoinColumn(name = "class_id")
    private Set<Student> students; 
} 

@Data
@Entity
@Table(name = "otm_student")
public class Student {
    @Id
    @Column(name = "student_id")
    private Integer studentId;
    @Column(name = "student_name")
    private String studentName;
    @Column(name = "student_age")
    private String studentAge;
}

看起来好像不太一样，其实一对一多对一的实现后的表结构是一样的，只是多对一是有多方控制，一对多是一方控制。也就是一个是可以通过学生添加班级，一个是可以通过班级添加学生。当然如果不设置级联操作的话肯定不能实现

在一对多的时候在班级类中采用了懒加载的方式，这样主要是为了减少资源的消耗

一对多双向关联

其实就是把两个都有的都不用动，没有的加上就ok了

多对多但相关联

举个例子：用户和角色的关系，一个用户可以有n个角色，同样每个个角色对应n个用户。在数据库中实现的时候，我们往往会构建一张用户表，一张角色表，一张关系表。这就用到了在hibernate中的多对多的对应关系
实现：

@Data
@Entity
@Table(name = "sys_user")
public class User {
    @Id
    @GeneratedValue
    @Column(name = "user_id")
    private Integer userId;
    @Column(name = "username")
    private String username;
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinTable(
        name = "sys_user_role",
        joinColumns = {@JoinColumn(name = "user_id")},
        inverseJoinColumns = {@JoinColumn(name = "role_id")}
    )
    private Set<Role> roles;
}

@Data
@Entity
@Table(name = "sys_role")
public class Role {
    @Id
    @Column(name = "role_id")
    private Integer roleId;
    @Column(name = "role_name", unique = true)
    private String roleName;
}

在用户表中设置Role的一个集合这儿，当然这儿也建议使用懒加载模式。在Role类就安安静静的做一个单纯的实体类就可以了。当然反过来使用Role作为主控类也是没有任何问题。
即把User中的Role集合删掉，在Role中添加一个User集合，配置与User中的Role集合类似。

多对多双向关联

多对多单项关联虽然可以解决大部分问题。但是，操作起来还是不太方便，所以我们需要对对多的双向关联

在多对多的实现中我们任然以用户角色关系做示范
双向关联其实，仍然是有一个为主
那么为主的这一方就完全可以照着单项关联的那个抄下来即可。需要注意的是另一方的配置。此时，主的一方已经完成了表的映射，那么，另一方自然不用做这一步了（JoinTable）。在集合中添加ManyToMany注解，并且指明主控端即可。

@Data
@Entity
@Table(name = "sys_user")
public class User {
    @Id
    @GeneratedValue
    @Column(name = "user_id")
    private Integer userId;
    @Column(name = "username")
    private String username;
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "users")
    private Set<Role> roles;
}

@Data
@Entity
@Table(name = "sys_role")
public class Role {
    @Id
    @Column(name = "role_id")
    private Integer roleId;
    @Column(name = "role_name", unique = true)
    private String roleName;
    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinTable(
            name = "user_role",
            joinColumns = {@JoinColumn(name = "role_id")},
            inverseJoinColumns = {@JoinColumn(name = "user_id")}
    )
    private Set<User> users;
}