Spring Data JPA之一对一，一对多，多对多关系映射

于 2020-12-28 16:47:41 发布
阅读量603 收藏 4
点赞数 5
文章标签： jpa 面试 mysql sql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youtiantin/article/details/111869709
版权

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

实体 People ：用户。

实体 Address：家庭住址。

People 和 Address 是一对一的关系。

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

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

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

1、通过外键的方式

people 表（id，name，sex，birthday，address_id）

address 表（id，phone，zipcode，address）

People.java

@Entity
@Data
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
@Data
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_id，address_id)

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

People.java

@Entity
@Data
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
@Data
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
@Data
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
@Data
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<Author> authorList;
 
}

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

Authority.java

@Entity
@Data
public class Authority {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
 
    @Column(nullable = false)
    private String name; //权限名
 
    @ManyToMany(mappedBy = "authorList")
    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 能够级联删除一条记录
实体Player：玩家。

实体Game：游戏。

玩家和游戏是多对多的关系。一个玩家可以玩很多的游戏，一个游戏也可以被很多玩家玩。

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

需要注意的：

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

2、可以随意指定一方为关系维护端，在这个例子中，我指定Player为关系维护端，所以生成的关联表名称为： player_game，关联表的字段为：player_id和game_id。

3、多对多关系的绑定由关系维护端来完成，即由Player.setGames(games)来绑定多对多的关系。关系被维护端不能绑定关系，即Game不能绑定关系。

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

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

Player.java如下：

package com.cndatacom.jpa.entity;
 
import java.util.HashSet;
import java.util.Set;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
 
 
/**
 * 玩家
 * @author Luxh
 */
@Entity
@Table(name="player")
public class Player {
     
    @Id
    @GeneratedValue
    private Long id;
     
    /**玩家姓名*/
    @Column(length=32)
    private String name;
     
     
    /**玩家玩的游戏*/
    @ManyToMany
    @JoinTable(name="player_game",joinColumns=@JoinColumn(name="player_id"),
                    inverseJoinColumns=@JoinColumn(name="game_id"))
    //关系维护端，负责多对多关系的绑定和解除
    //@JoinTable注解的name属性指定关联表的名字，joinColumns指定外键的名字，关联到关系维护端(Player)
    //inverseJoinColumns指定外键的名字，要关联的关系被维护端(Game)
    //其实可以不使用@JoinTable注解，默认生成的关联表名称为主表表名+下划线+从表表名，
    //即表名为player_game
    //关联到主表的外键名：主表名+下划线+主表中的主键列名,即player_id
    //关联到从表的外键名：主表中用于关联的属性名+下划线+从表的主键列名,即game_id
    //主表就是关系维护端对应的表，从表就是关系被维护端对应的表
    private Set<Game> games = new HashSet<Game>();
 
 
    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 Set<Game> getGames() {
        return games;
    }
 
 
    public void setGames(Set<Game> games) {
        this.games = games;
    }
     
}

Game.java如下：

package com.cndatacom.jpa.entity;
 
import java.util.HashSet;
import java.util.Set;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
 
 
/**
 * 游戏
 * @author Luxh
 */
 
@Entity
@Table(name="game")
public class Game {
     
    @Id
    @GeneratedValue
    private Long id;
     
    /**游戏名称*/
    @Column(length=32)
    private String name;
     
    /**游戏拥有的玩家*/
    @ManyToMany(mappedBy="games")
    //只需要设置mappedBy="games"表明Game实体是关系被维护端就可以了
    //级联保存、级联删除等之类的属性在多对多关系中是不需要设置
    //不能说删了游戏,把玩家也删掉,玩家还可以玩其他的游戏
    private Set<Player> players = new HashSet<Player>();
 
    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 Set<Player> getPlayers() {
        return players;
    }
 
    public void setPlayers(Set<Player> players) {
        this.players = players;
    }
     
     
}

简单的测试如下：

package com.cndatacom.jpa.test;
 
import java.util.HashSet;
import java.util.Set;
 
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
 
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
 
import com.cndatacom.jpa.entity.Game;
import com.cndatacom.jpa.entity.Player;
 
public class TestManyToMany {
     
EntityManagerFactory emf = null;
     
    @Before
    public void before() {
        //根据在persistence.xml中配置的persistence-unit name 创建EntityManagerFactory
        emf = Persistence.createEntityManagerFactory("myJPA");
    }
     
    @After
    public void after() {
        //关闭EntityManagerFactory
        if(null != emf) {
            emf.close();
        }
    }
     
    /**
     * 创建玩家和游戏
     */
    @Test
    public void testSavePlayerAndGame() {
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        //因为Player和Game之间没有级联保存的关系，所以Playe和Game要分别保存
         
        Player player = new Player();
        player.setName("西门吹雪");
        //保存Player
        em.persist(player);
         
        Game game = new Game();
        game.setName("大菠萝3");
        //保存game
        em.persist(game);
         
        em.getTransaction().commit();
        em.close();
    }
     
    /**
     * 给玩家添加游戏
     */
    @Test
    public void testAddGameToPlayer() {
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        //找出ID为1的玩家
        Player player = em.find(Player.class, 1L);
        //找出ID为1的游戏
        Game game = em.find(Game.class, 1L);
         
        Set<Game> games = new HashSet<Game>();
        games.add(game);
         
        //因为Player是关系的维护端，所以必须由Player来添加关系
        player.setGames(games);
         
        em.getTransaction().commit();
        em.close();
    }
     
    /**
     * 玩家删除游戏
     */
    @Test
    public void testRemoveGameFormPlayer() {
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        //找出ID为1的玩家
        Player player = em.find(Player.class, 1L);
        //找出ID为1的游戏
        Game game = em.find(Game.class, 1L);
         
        //因为Player是关系维护端，所以关系的解除由Player来完成
        player.getGames().remove(game);
        em.getTransaction().commit();
        em.close();
    }
}

生成的关联表结构如下：
在这里插入图片描述

再次更新
其中 @OneToMany 和 @ManyToOne 用得最多，这里再补充一下 关于级联，一定要注意，要在关系的维护端，即 One 端。
在这里插入图片描述

比如 作者和文章，作者是One，文章是Many；文章和评论，文章是One，评论是Many。 cascade = CascadeType.ALL 只能写在 One 端，只有One端改变Many端，不准Many端改变One端。

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

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

一定要在 One 端使用。 举例 One 端

Many 端

在这里插入图片描述

*喏，手打不易，大家动动小手分享转发点赞评论啥的~~~~*
在这里插入图片描述

QAQalone
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值