spring-boot ，spring-data-jpa 关系映射，实现一对多，一对一，多对多

spring-boot ，spring-data-jpa 关系映射关系，实现一对多，多对多，一对一

仅仅展示代码，不需要太多的其他无用字眼

1：多对多
@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private String reallName;
    @ManyToMany(fetch = FetchType.LAZY)   //多对多
    @JoinTable(					//jointable。维护方加此注释
            name="tyg_user_role",		//name是表名，
//joincolumns需要将此entity中的什么字段添加到表的什么字段，name是存储在多对多关系表中的字段名，referencedColumnName为此外键
            joinColumns={@JoinColumn(name="user_id", referencedColumnName="ID")},
//inverseJoinColumns,name字段是关系entity Role的id以role_id存储在关系表tyg_user_role中
            inverseJoinColumns={@JoinColumn(name="role_id", referencedColumnName="ID")})
    private List<Role> roles;


@Entity
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String roleName;
    private String roleDes;
//多对多不维护的一方属性，只写mappedBy，值和维护方的属性值一致
    @ManyToMany(mappedBy = "roles")
    private List<User> users;

2.一对多
	一方
@Entity//标注为一个实体
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String reallName;
    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
            name="tyg_user_role",
            joinColumns={@JoinColumn(name="user_id", referencedColumnName="ID")},
            inverseJoinColumns={@JoinColumn(name="role_id", referencedColumnName="ID")})
    private List<Role> roles;

//标注一对多，此处的cascadeType值得说明
//PERSIST新增，保存级联操作、MERGE更新级联操作、REFRESH刷新级联操作、REMOVE删除级联操作
    @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH },fetch = FetchType.LAZY)

//多的一方维护的列，foreignKey实际为索引值，并不是外兼值
    @JoinColumn(name = "uId", foreignKey = @ForeignKey(name = "uId", value =ConstraintMode.CONSTRAINT))
    private List<MyOrder> myOrders;
	多方
@Entity
public class MyOrder{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String code;
    private Double total;
    
    @ManyToOne(fetch = FetchType.LAZY,cascade = CascadeType.ALL)
    @JoinColumn(name = "uId",foreignKey = @ForeignKey(name = "uId"))
    private User user;

3、一对一

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String reallName;
    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
            name="tyg_user_role",
            joinColumns={@JoinColumn(name="user_id", referencedColumnName="ID")},
            inverseJoinColumns={@JoinColumn(name="role_id", referencedColumnName="ID")})
    private List<Role> roles;

    @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH },fetch = FetchType.LAZY)
    @JoinColumn(name = "uId", foreignKey = @ForeignKey(name = "uId", value =ConstraintMode.CONSTRAINT))
    private List<MyOrder> myOrders;

//此处比较多的坑，级联操作使用不当，就会报错，当只维护cId的时候，去除级联PERSIST
    @OneToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH }, fetch = FetchType.LAZY)
    @org.hibernate.annotations.ForeignKey(name = "none")
    @JoinColumn(name = "cId", foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT))
    private Customer customer;


@Entity
//@Data
//@AllArgsConstructor
//@NoArgsConstructor
@NamedQuery(name="Customer.findByFirstName",query = "select c from Customer c where c.firstName = ?1")
public class Customer {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
    private String firstName;
    private String lastName;

    //一对一
//此处比较多的坑，级联操作使用不当，就会报错，当只维护cId的时候，去除级联PERSIST，如下
    @OneToOne(cascade = { CascadeType.REFRESH }, fetch = FetchType.LAZY)
    @JoinColumn(name = "uId", foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT))
    private User user;

有问题可以向我提问，可能不会随时回，但是看到的话会回复的。仅仅是初级，写的不好勿喷，请指教！