详谈jpa中表的@OneToMany等关联关系

目录
  • 一、@OneToOne关系映射
    • 1、通过外键的方式
    • 2、通过关联表的方式来保存一对一的关系
  • 二、@OneToMany 和 @ManyToOne
  • 三、多对多 @ManyToMany
  • 再次更新
    • One 端
    • Many 端

一、@OneToOne关系映射

JPA使用@OneToOne来标注一对一的关系。

  • 实体 People :用户。
  • 实体 Address:家庭住址。

People 和 Address 是一对一的关系。

这里用两种方式描述JPA的一对一关系。

一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键);

另外一种是通过一张关联表来保存两个实体一对一的关系。

1、通过外键的方式

  • people 表(id,name,sex,birthday,address_id
  • address 表(id,phone,zipcode,address)
People.java

@Entity
public class People {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;//id

    @Column(name = "name", nullable = true, length = 20)
    private String name;//姓名

    @Column(name = "sex", nullable = true, length = 1)
    private String sex;//性别

    @Column(name = "birthday", nullable = true)
    private Timestamp birthday;//出生日期

    @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端,当删除 people,会级联删除 address
    @JoinColumn(name = "address_id", referencedColumnName = "id")//people中的address_id字段参考address表中的id字段
    private Address address;//地址
}

关联的实体的主键一般是用来做外键的。但如果此时不想主键作为外键,则需要设置referencedColumnName属性。当然这里关联实体(Address)的主键 id 是用来做主键,所以这里第20行的 referencedColumnName = "id" 实际可以省略。

Address.java

@Entity
public class Address {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;//id

    @Column(name = "phone", nullable = true, length = 11)
    private String phone;//手机

    @Column(name = "zipcode", nullable = true, length = 6)
    private String zipcode;//邮政编码

    @Column(name = "address", nullable = true, length = 100)
    private String address;//地址

    //如果不需要根据Address级联查询People,可以注释掉
//    @OneToOne(mappedBy = "address", cascade = {CascadeType.MERGE, CascadeType.REFRESH}, optional = false)
//    private People people;
}

2、通过关联表的方式来保存一对一的关系

  • people 表(id,name,sex,birthday)
  • address 表 (id,phone,zipcode,address)
  • people_address (people_idaddress_id)

只需要创建 People 和 Address 两个实体

People.java

@Entity
public class People {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;//id

    @Column(name = "name", nullable = true, length = 20)
    private String name;//姓名

    @Column(name = "sex", nullable = true, length = 1)
    private String sex;//性别

    @Column(name = "birthday", nullable = true)
    private Timestamp birthday;//出生日期

    @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端
    @JoinTable(name = "people_address",
            joinColumns = @JoinColumn(name="people_id"),
            inverseJoinColumns = @JoinColumn(name = "address_id"))//通过关联表保存一对一的关系
    private Address address;//地址
}

Address.java

不变

二、@OneToMany 和 @ManyToOne

  • 实体 Author:作者。
  • 实体 Article:文章。

Author 和 Article 是一对多关系(双向)。那么在JPA中,如何表示一对多的双向关联呢?

JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一端(Author)使用@OneToMany,多端(Article)使用@ManyToOne。

在JPA规范中,一对多的双向关系由多端(Article)来维护。就是说多端(Article)为关系维护端,负责关系的增删改查。一端(Author)则为关系被维护端,不能维护关系。

一端(Author)使用@OneToMany注释的mappedBy="author"属性表明Author是关系被维护端。

多端(Article)使用@ManyToOne和@JoinColumn来注释属性 author,@ManyToOne表明Article是多端,@JoinColumn设置在article表中的关联字段(外键)。

Author.java

@Entity
public class Author {
    @Id // 主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
    private Long id; //id

    @NotEmpty(message = "姓名不能为空")
    @Size(min=2, max=20)
    @Column(nullable = false, length = 20)
    private String name;//姓名

    @OneToMany(mappedBy = "author",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
    //级联保存、更新、删除、刷新;延迟加载。当删除用户,会级联删除该用户的所有文章
    //拥有mappedBy注解的实体类为关系被维护端
     //mappedBy="author"中的author是Article中的author属性
    private List<Article> articleList;//文章列表
}
Article.java

@Entity
public class Article { 

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
    @Column(name = "id", nullable = false)
    private Long id;

    @NotEmpty(message = "标题不能为空")
    @Size(min = 2, max = 50)
    @Column(nullable = false, length = 50) // 映射为字段,值不能为空
    private String title;

    @Lob  // 大对象,映射 MySQL 的 Long Text 类型
    @Basic(fetch = FetchType.LAZY) // 懒加载
    @NotEmpty(message = "内容不能为空")
    @Size(min = 2)
    @Column(nullable = false) // 映射为字段,值不能为空
    private String content;//文章全文内容 

    @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)//可选属性optional=false,表示author不能为空。删除文章,不影响用户
    @JoinColumn(name="author_id")//设置在article表中的关联字段(外键)
    private Author author;//所属作者
}

最终生成的表结构

  • article 表(id,title,conten,author_id)
  • author 表(id,name)

三、多对多 @ManyToMany

  • 实体 User:用户。
  • 实体 Authority:权限。

用户和权限是多对多的关系。一个用户可以有多个权限,一个权限也可以被很多用户拥有。

JPA中使用@ManyToMany来注解多对多的关系,由一个关联表来维护。这个关联表的表名默认是:主表名+下划线+从表名。(主表是指关系维护端对应的表,从表指关系被维护端对应的表)。这个关联表只有两个外键字段,分别指向主表ID和从表ID。字段的名称默认为:主表名+下划线+主表中的主键列名,从表名+下划线+从表中的主键列名。

需要注意的:

1、多对多关系中一般不设置级联保存、级联删除、级联更新等操作。

2、可以随意指定一方为关系维护端,在这个例子中,我指定 User 为关系维护端,所以生成的关联表名称为: user_authority,关联表的字段为:user_id 和 authority_id。

3、多对多关系的绑定由关系维护端来完成,即由 User.setAuthorities(authorities) 来绑定多对多的关系。关系被维护端不能绑定关系,即Game不能绑定关系。

4、多对多关系的解除由关系维护端来完成,即由Player.getGames().remove(game)来解除多对多的关系。关系被维护端不能解除关系,即Game不能解除关系。

5、如果 User 和 Authority 已经绑定了多对多的关系,那么不能直接删除 Authority,需要由 User 解除关系后,才能删除 Authority。但是可以直接删除 User,因为 User 是关系维护端,删除 User 时,会先解除 User 和 Authority 的关系,再删除 Authority。

User.java

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotEmpty(message = "账号不能为空")
    @Size(min=3, max=20)
    @Column(nullable = false, length = 20, unique = true)
    private String username; // 用户账号,用户登录时的唯一标识

    @NotEmpty(message = "密码不能为空")
    @Size(max=100)
    @Column(length = 100)
    private String password; // 登录时密码

    @ManyToMany
    @JoinTable(name = "user_authority",joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "authority_id"))
    //1、关系维护端,负责多对多关系的绑定和解除
    //2、@JoinTable注解的name属性指定关联表的名字,joinColumns指定外键的名字,关联到关系维护端(User)
    //3、inverseJoinColumns指定外键的名字,要关联的关系被维护端(Authority)
    //4、其实可以不使用@JoinTable注解,默认生成的关联表名称为主表表名+下划线+从表表名,
    //即表名为user_authority
    //关联到主表的外键名:主表名+下划线+主表中的主键列名,即user_id
    //关联到从表的外键名:主表中用于关联的属性名+下划线+从表的主键列名,即authority_id
    //主表就是关系维护端对应的表,从表就是关系被维护端对应的表
    private List<Authority> authorityList;
}

注意:如注释中所言,上面的第20-21行的@JoinTable可以省略,默认可以生成

Authority.java

@Entity
public class Authority {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(nullable = false)
    private String name; //权限名

    @ManyToMany(mappedBy = "authorityList")
    private List<User> userList;

}

测试 添加


@SpringBootTest
@RunWith(SpringRunner.class)
public class UserRepositoryTest { 

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private AuthorityRepository authorityRepository;

    @Test
    public void saveAuthority() {
        Authority authority = new Authority();
        authority.setId(1);
        authority.setName("ROLE_ADMIN");
        authorityRepository.save(authority);
    }

    @Test
    public void saveUser() {
        User user = new User();
        user.setUsername("admin");
        user.setPassword("123456");
        Authority authority = authorityRepository.findById(1).get();
        List<Authority> authorityList = new ArrayList<>();
        authorityList.add(authority);
        user.setAuthorList(authorityList);
        userRepository.save(user);
    }
}

先运行 saveAuthority 添加一条权限记录,

然后运行 saveUser 添加一条用户记录,与此同时,user_authority 表中也自动插入了一条记录

测试 删除删除用户


@SpringBootTest
@RunWith(SpringRunner.class)
public class UserRepositoryTest { 

    @Autowired
    private UserRepository userRepository;

    @Test
    public void deleteUser() {
        userRepository.deleteById(1L);
    }
}

user 表中删除一条记录,同时 user_authority 能够级联删除一条记录

再次更新

其中 @OneToMany 和 @ManyToOne 用得最多,这里再补充一下

关于级联,一定要注意,要在关系的维护端,即 One 端。

比如 作者和文章,作者是One,文章是Many;文章和评论,文章是One,评论是Many。

cascade = CascadeType.ALL 只能写在 One 端,只有One端改变Many端,不准Many端改变One端。

特别是删除,因为 ALL 里包括更新,删除。

如果删除一条评论,就把文章删了,那算谁的。所以,在使用的时候要小心。一定要在 One 端使用。

举例

One 端

Many 端

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • SpringData JPA中@OneToMany和@ManyToOne的用法详解

    目录 一. 假设需求场景 二. 代码实现 2.1 级联存储操作 2.2 查询操作和toSting问题 2.3 级联删除 2.4 pom.xml 一. 假设需求场景 在我们开发的过程中,经常出现两个对象存在一对多或多对一的关系.如何在程序在表明这两个对象的关系,以及如何利用这种关系优雅地使用它们. 其实,在javax.persistence包下有这样两个注解--@OneTomany和@ManyToOne,可以为我们所用. 现在,我们假设需要开发一个校园管理系统,管理各大高校的学生.这是一种典型的一

  • SpringBoot JPA 表关联查询实例

    今天给大家介绍一下如何利用JPA实现表关联查询. 今天给大家举一个一对多的关联查询,并且是使用JPA原生的findBy语句实现的. 例子中总共有两个实体类,一个是Floor(商品楼层类),另一个是FloorContent(商品楼层内容表).下面看两张表的源代码: Floor类: package cms.model; import cms.model.base.BaseDomain; import org.hibernate.annotations.GenericGenerator; import

  • Spring Data JPA 实现多表关联查询的示例代码

    多表查询在spring data jpa中有两种实现方式,第一种是利用hibernate的级联查询来实现,第二种是创建一个结果集的接口来接收连表查询后的结果,这里介绍第二种方式. 一.一对一映射 实体 UserInfo :用户. 实体 Address:家庭住址. 这里通过外键的方式(一个实体通过外键关联到另一个实体的主键)来实现一对一关联. 实体类 1.实体类 UserInfo.java package com.johnfnash.learn.domain; import java.io.Ser

  • SpringBoot Data JPA 关联表查询的方法

    SpringBoot Data JPA实现 一对多.多对一关联表查询 开发环境 IDEA 2017.1 Java1.8 SpringBoot 2.0 MySQL 5.X 功能需求 通过关联关系查询商店Store中所有的商品Shop,商店对商品一对多,商品对商店多对一,外键 store_id存在于多的一方.使用数据库的内连接语句. 表结构 tb_shop tb_store 实体类,通过注解实现 1.商店类Store.java package com.gaolei.Entity; import ja

  • 详谈jpa中表的@OneToMany等关联关系

    目录 一.@OneToOne关系映射 1.通过外键的方式 2.通过关联表的方式来保存一对一的关系 二.@OneToMany 和 @ManyToOne 三.多对多 @ManyToMany 再次更新 One 端 Many 端 一.@OneToOne关系映射 JPA使用@OneToOne来标注一对一的关系. 实体 People :用户. 实体 Address:家庭住址. People 和 Address 是一对一的关系. 这里用两种方式描述JPA的一对一关系. 一种是通过外键的方式(一个实体通过外键关

  • jpa实体@ManyToOne @OneToMany无限递归方式

    目录 jpa实体@ManyToOne @OneToMany无限递归 问题描述 解决办法 @OneToMany和@ManyToOne要素 jpa实体@ManyToOne @OneToMany无限递归 问题描述 Cannot call sendError() after the response has been committed 解决办法 在属性上添加注释 @JsonBackReference // data to json 和 JsonIgnore一样 // @JsonManagedRefer

  • 关于jpa中无法删除onetomany中many问题的解决

    目录 jpa 无法删除onetomany中many问题 问题描述 解决思路 小结一下 jpa @OneToMany 删除不了集合数据 jpa 无法删除onetomany中many问题 问题描述 今天在做项目遇到一个问题,建立两个实体order和orderDetail,他们是onetomany关系,当我想要之间删除一个orderDetail时,发现不能删除但是程序也不出错. 实体建立模型如下图: order中: orderDetail中: 解决思路 1.首先我想到了直接删除orderDetail不

  • 基于Jpa中ManyToMany和OneToMany的双向控制

    目录 Jpa ManyToMany和OneToMany的双向控制 1.ManyToMany 2.OneToMany以及ManyToOne JPA中ManyToMany关系问题 解决办法 Jpa ManyToMany和OneToMany的双向控制 下面我们使用权限管理中Role<->Account(用户ManyToMany账号).Role<->Domain(用户OneToMany权限域)的关系来举例. 1.ManyToMany Role表 Account表 在两个表的对应属性上添加J

  • springboot+spring data jpa实现新增及批量新增方式

    目录 springboot+spring data jpa实现新增及批量新增 springdatajpa 新增操作注意 springboot+spring data jpa实现新增及批量新增 spring data jpa (以下简称jpa).这个orm其实和mybatis还是差不多的.但是相对于mybatis来说,省去很多方法,毕竟jpa来说,官方文档给的说法是编写者只需要书写接口.剩下的事就交由jpa来完成.当时,洒家还是不信的.当你用过一次后,你就会发现.真的是这样.只能用两个字来形容,即

  • SpringDataJpa多表操作的实现

    目录 Jpa表关系分析步骤 关联关系的注解 @JoinColumn定义外键关联的字段名称 @OneToOne一对一关联关系 @OrderBy关联查询的时候的排序 @JoinTable关联关系表 @ManyToMany多对多 数据库中的表存在着多种关系,一对一,一对多,多对多 Jpa表关系分析步骤 开发过程中会有很多多表的操作,他们之间有着各种关系,在Jpa这种实现来了orm思想的框架中我们可以通过操作实体类来操作数据库,我们来连接下jap如何配置实体类来实现这种功能 确定表之间的关系 在数据库实

  • 使用JPA双向多对多关联关系@ManyToMany

    目录 JPA双向多对多关联关系@ManyToMany ManyToMany和OneToMany的双向控制 1.ManyToMany 2.OneToMany以及ManyToOne JPA双向多对多关联关系@ManyToMany package com.jpa.helloworld; import java.util.HashSet; import java.util.Set; import javax.persistence.Column; import javax.persistence.Ent

  • Spring Data JPA 注解Entity关联关系使用详解

    目录 1.OneToOne关联关系 1.1 解读OneToOne源码 1.2 mappedBy 注意事项 1.3 CascadeType 用法 1.4 orphanRemoval属性用法 1.5 orphanRemoval 和 CascadeType.REMOVE的区别 2.@JoinColumns & @JoinColumn 3.@ManyToOne & @OneToMany 3.1 Lazy机制 4.ManyToMany 4.1 利用@ManyToOne 和 @OneToMany表达多

  • 解决JPA @OneToMany及懒加载无效的问题

    目录 JPA @OneToMany及懒加载无效 @OneToMany 小结一下吧 实现JPA的懒加载和无外键 例如 转换时使用 JPA @OneToMany及懒加载无效 @OneToOne @ManyToMany使用不做过多解释,重点解决"懒加载无效问题". 示例: @OneToMany teacher 和 student是一对多关系 只需要在studentList上使用@OneToMany注解,对应的参数为 懒加载.级联操作.子表外键 我为了验证懒加载是否生效,在debug模式下发现

随机推荐