JPA学习(三)

for belief.

于 2022-08-03 09:15:00 发布

阅读量216

点赞数

分类专栏： JPA 文章标签：学习 java spring boot

本文链接：https://blog.csdn.net/DSAUBDUA/article/details/126133753

版权

JPA 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1. 实现映射常用注解

假设一个用户只有一种角色，用户和角色是onetomany的关系

1.1 one-to-many

用于一对多的关系。

用户类：

@Entity
@Table(name="user")
public class UserEntity implements Serializable{
    
    @Id
    @GenericGenerator(name="generator",strategy="uuid")
    @GeneratedValue(generator="generator")
    @Column(name="id")
    private String id;
    @Column(name="userName")
    private String userName;
    @Column(name="password")
    private String password;
    @Temporal(value=TemporalType.TIMESTAMP)
    private Date createDate;　　......

角色类：

@Entity
@Table(name="role")
public class RoleEntity implements Serializable{

    @Id
    @GenericGenerator(name="generator",strategy="uuid")
    @GeneratedValue(generator="generator")
    @Column(name="id")
    private String id;
    @Column(name="name")
    private String name;
    @OneToMany(fetch=FetchType.LAZY,cascade=CascadeType.PERSIST)
    private Set<UserEntity> user;

那么在项目启动后会自动生成三张表，分别是:

用户表：

角色表：

角色用户表：

@Onetomany 的参数：

mappedBy:用于双向关联时使用，否则会引起数据不一致的问题。

fetch:可取的值有FetchType.EAGER和FetchType.LAZY，前者表示主类被加载时加载，后者表示被访问时才会加载

cascade：CascadeType.PERSIST（级联新建）、CascadeType.REMOVE（级联删除）、CascadeType.REFRESH（级联刷新）、CascadeType.MERGE（级联更新）、CascadeType.ALL（选择全部）

1.2 ManyToOne

用于多对一的关系。

用户实体类：

@Entity
@Table(name="user")
public class UserEntity implements Serializable{
    @Id
    @GenericGenerator(name="generator",strategy="uuid")
    @GeneratedValue(generator="generator")
    @Column(name="id")
    private String id;
    @Column(name="userName")
    private String userName;
    @Column(name="password")
    private String password;
    @Temporal(value=TemporalType.TIMESTAMP)
    private Date createDate;
    @ManyToOne(cascade=CascadeType.ALL,fetch=FetchType.LAZY,optional=true)
    @JoinColumn(name="roleid",nullable=true)
    private RoleEntity role;

运行后会生成两张表：

角色表：

用户表：

@Manytoone的参数：optional 属性是定义该关联类对是否必须存在，值为false时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。值为true 时, 关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null。 optional 属性的默认值是true。

其它属性与onetomany相同。

1.3 JoinColumn

与@Column用法相同，区别是@JoinColumn作用的属性必须是实体类。

1.4 ManyToMany

import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
 
@Entity
public class User {
	private Long id;
	private Department department;
	private Set<Role> roles = new HashSet<Role>();
	private String loginName;
	private String password;
	private String name;
	private String gender;
	private String phoneNumber;
	private String email;
	private String description;
	
	
	@Id
	@GeneratedValue
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	
	@ManyToOne()
	public Department getDepartment() {
		return department;
	}
	public void setDepartment(Department department) {
		this.department = department;
	}
	
	@ManyToMany(cascade=CascadeType.PERSIST,fetch=FetchType.LAZY)
	@JoinTable(name="user_role",
	joinColumns={@JoinColumn(name="user_id")},
	inverseJoinColumns={@JoinColumn(name="role_id")})
	public Set<Role> getRoles() {
		return roles;
	}
	public void setRoles(Set<Role> roles) {
		this.roles = roles;
	}
	public String getLoginName() {
		return loginName;
	}
	public void setLoginName(String loginName) {
		this.loginName = loginName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public String getPhoneNumber() {
		return phoneNumber;
	}
	public void setPhoneNumber(String phoneNumber) {
		this.phoneNumber = phoneNumber;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
	
}

第一个类是Role 岗位类 , 第二个类是User 用户类，每个用户可以有多个岗位，每个岗位包含多个用户。

注意：

个人编程的时候出现的问题就是，刚开始都只加了一个注解@ManytoMany 后来发现操作对User对象添加Role集合的时候，关联表里面的内容没有改。才发现少了配置。

最简单的配置首先需要配置，被依赖方 @ManytoMany(mappedBy=“roles”) ，我在这里定义的是roles，意思是当对User对象设置roles的时候，关联表里面会操作。

@JoinTable(name="user_role",
	joinColumns={@JoinColumn(name="user_id")},
	inverseJoinColumns={@JoinColumn(name="role_id")})

1.5 OneToOne

场景：一个人只养一只宠物。

@Entity
@Table(name = "people")
public class People (){
     @Id  //JPA注释： 主键 
     @GeneratedValue(strategy = GenerationType.AUTO)   //设置 id 为自增长
     private Long id;

     private String name;

     //由于，people 是这个一对一的关系的主控方，所以，在people表中添加了一个 pet 的外键。
     //通过这个外键来维护 people和pet的一对一关系，而不是用第三张码表。这个是通过@JoinColumn注释实现的。
     @OneToOne //JPA注释： 一对一 关系
     @JoinColumn(name="pet_fk" )// 在pepole中，添加一个外键 "pet_fk"
     private Pet pet;

     //省略 get / set  方法...
}

@Entity
@Table(name = "pet")
public class Pet (){
     @Id  
     @GeneratedValue(strategy = GenerationType.AUTO)  
     private Long id;
     private String name;
     //省略 get / set  方法...
     //因为这是一个单向的一对一关系，并且，是从 people 到 pet 的一对一关系。
     //所以，在 pet 中没有与 people 管理的 属性。也就是说，无法通过 pet 找到 people 
}

1.6 mappedBy 属性

1.6.1 简介

mappedBy 单向关系不需要设置该属性，双向关系必须设置，避免双方都建立外键字段数据库中1对多的关系，关联关系总是被多方维护的即外键建在多方，我们在单方对象的@OneToMany（mappedby=” “），把关系的维护交给多方对象的属性去维护关系。

只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；
mappedBy标签一定是定义在the owned side（被拥有方的），他指向theowning side（拥有方）；
关系的拥有方负责关系的维护，在拥有方建立外键。所以用到@JoinColumn；
mappedBy跟JoinColumn/JoinTable总是处于互斥的一方。

1.6.2 例子

这里的维护关联关系，拿多对多来说就是中间表，在不设置cascade的情况下，中间表由负责维护关联关系的一方维护。

假设User和Game两个类，他们之间是多对多的关系。

User:

@ManyToMany（mappedBy="users"）
public List<Game> games;

Game:

@ManyToMany
@JoinTable（name = "t_game_user",
joinColumns = {@JoinColumn（name = "game_id",referencedColumnName="gameId"）},
inverseJoinColumns = {@JoinColumn（name = "user_id",referencedColumnName="id"）}）
public List<User> users;

1.6.3 测试

因为没有配置cascade所以分别给Game,User添加4条数据，然后手动在中间表中添加他们的关联关系;

在程序中分别执行删除User、删除Game

在程序中删除User：

Hibernate: delete from t_user where id=?
Hibernate: delete from t_user where id=?
Hibernate: delete from t_user where id=?
Hibernate: delete from t_user where id=?

删除了User，并没有对中间表产生影响；

在程序中执行删除Game：

Hibernate:delete from t_game_user where game_id=?
Hibernate:delete from t_game_user where game_id=?
Hibernate:delete from t_game_user where game_id=?
Hibernate:delete from t_game_user where game_id=?
Hibernate:delete from t_game where game_id=?
Hibernate:delete from t_game where game_id=?
Hibernate:delete from t_game where game_id=?
Hibernate:delete from t_game where game_id=?

对中间表产生了影响，说明是Game在维护他们之间的关联关系;

1.6.4 Spring-jpa中mappedBy的作用

mappedBy主要用于需要外键（存在于@OneToOne，@OneToMany，@ManyToMany中）的场景下，帮助我们进行外键管理。

使用@JoinColumn存在的问题

在“一对多”的场景下，如果不使用mappedby，则一般是在“一方”和“多方”分别使用@joinColumn注解，帮助我们在“多方”和“一方”进行外键的维护，这样做的好处去掉多出来的一张关系映射表。

但是这会产生一个问题，就是执行的时候因为两方都要维护外键，所以在进行数据的增删时会执行冗余的update语句（update”多方“的外键），这些update语句是没有必要的。

因此，问题的解决就是需要我们只在“多方”来维护外键，为什么不在“一方’维护外键，因为这样”一方“为了维护外键还是会执行多余的update语句。

使用mappedBy

所以，我们需要在@OneToMany上使用mappedBy，值一般设为“多方”Entity类的外键数据成员名（注意不是数据库上的字段名，同时必须去掉@JoinColumn，不然会产生冲突）。这样就将外键的维护权交给“多方”，多方还是要使用@JoinColumn,并将值设为外键字段名，不然系统会自动帮我们设置一个外键字段。

会产生一个问题，就是执行的时候因为两方都要维护外键，所以在进行数据的增删时会执行冗余的update语句（update”多方“的外键），这些update语句是没有必要的。

使用mappedBy