07 | @Entity 之间的关联关系注解如何正确使用?

实体与实体之间的关联关系一共分为四种,分别为 OneToOne、OneToMany、ManyToOne 和 ManyToMany;而实体之间的关联关系又分为双向的和单向的。实体之间的关联关系是在 JPA 使用中最容易发生问题的地方,接下来我将一一揭晓并解释。我们先看一下 OneToOne,即一对一的关联关系。

@OneToOne 关联关系

@OneToOne 一般表示对象之间一对一的关联关系,它可以放在 field 上面,也可以放在 get/set 方法上面。其中 JPA 协议有规定,如果是配置双向关联,维护关联关系的是拥有外键的一方,而另一方必须配置 mappedBy;如果是单项关联,直接配置在拥有外键的一方即可。

举个例子:user 表是用户的主信息,user_info 是用户的扩展信息,两者之间是一对一的关系。user_info 表里面有一个 user_id 作为关联关系的外键,如果是单项关联,我们的写法如下:

复制代码

package com.example.jpa.example1;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User {@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private String name;private String email;private String sex;private String address;
}

User 实体里面什么都没变化,不需要添加 @OneToOne 注解。我们只需要在拥有外键的一方配置就可以,所以 UserInfo 的代码如下:

复制代码

package com.example.jpa.example1;
import lombok.*;
import javax.persistence.*;
@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = "user")
public class UserInfo {@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private Integer ages;private String telephone;@OneToOne //维护user的外键关联关系,配置一对一private User user;
}

我们看到,UserInfo 实体对象里面添加了 @OneToOne 注解,这时我们写一个测试用例跑一下看看有什么效果:

复制代码

Hibernate: create table user (id bigint not null, address varchar(255), email varchar(255), name varchar(255), sex varchar(255), primary key (id))
Hibernate: create table user_info (id bigint not null, ages integer, telephone varchar(255), user_id bigint, primary key (id))
Hibernate: alter table user_info add constraint FKn8pl63y4abe7n0ls6topbqjh2 foreign key (user_id) references user

因为我们新建了两个实体,跑任何一个 @SpringDataTest 就会看到上面有三个 sql 在执行,分别创建了两张表,而在 user_info 表上面还创建了一个外键索引。

上面我们说了单项关联关系,那么双向关联应该怎么配置呢?我们保持 UserInfo 不变,在 User 实体对象里面添加这一段代码即可。

复制代码

@OneToOne(mappedBy = "user")
private UserInfo userInfo;

完整的 User 实体对象就会变成如下模样。

复制代码

@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User {@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private String name;private String email;@OneToOne(mappedBy = "user")private UserInfo userInfo;//变化之处private String sex;private String address;
}

我们跑任何一个测试用例,就会看到运行结果是一样的,还是上面三条 sql。那么我们再查看一下 @OneToOne 源码,看看其支持的配置都有哪些。

@interface OneToOne 源码解读

下面我列举了@OneToOne 的源码,并加以解读。通过这些你可以了解 @OneToOne 的用法。

复制代码

public @interface OneToOne {//表示关系目标实体,默认该注解标识的返回值的类型的类。Class targetEntity() default void.class;//cascade 级联操作策略,就是我们常说的级联操作CascadeType[] cascade() default {};//数据获取方式EAGER(立即加载)/LAZY(延迟加载)FetchType fetch() default EAGER;//是否允许为空,默认是可选的,也就表示可以为空;boolean optional() default true;//关联关系被谁维护的一方对象里面的属性名字。 双向关联的时候必填String mappedBy() default "";//当被标识的字段发生删除或者置空操作之后,是否同步到关联关系的一方,即进行通过删除操作,默认flase,注意与CascadeType.REMOVE 级联删除的区别boolean orphanRemoval() default false;
}
mappedBy 注意事项

只有关联关系的维护方才能操作两个实体之间外键的关系。被维护方即使设置了维护方属性进行存储也不会更新外键关联。

mappedBy 不能与 @JoinColumn 或者 @JoinTable 同时使用,因为没有意义,关联关系不在这里面维护。

此外,mappedBy 的值是指另一方的实体里面属性的字段,而不是数据库字段,也不是实体的对象的名字。也就是维护关联关系的一方属性字段名称,或者加了 @JoinColumn / @JoinTable 注解的属性字段名称。如上面的 User 例子 user 里面 mappedBy 的值,就是 UserInfo 里面的 user 字段的名字。

CascadeType用法

在 CascadeType 的用法中,CascadeType 的枚举值只有五个,分别如下:

  1. CascadeType.PERSIST 级联新建
  2. CascadeType.REMOVE 级联删除
  3. CascadeType.REFRESH 级联刷新
  4. CascadeType.MERGE 级联更新
  5. CascadeType.ALL 四项全选

其中,默认是没有级联操作的,关系表不会产生任何影响。此外,JPA 2.0 还新增了 CascadeType.DETACH,即级联实体到 Detach 状态。

了解了枚举值,下面我们来测试一下级联新建和级联删除。

首先,修改 UserInfo 里面的关键代码如下,并在 @OneToOne 上面添加
cascade ={CascadeType.PERSIST,CascadeType.REMOVE},如下:
1.png

其次,我们新增一个测试方法。

复制代码

    @Test@Rollback(false)public void testUserRelationships() throws JsonProcessingException {User user = User.builder().name("jackxx").email("123456@126.com").build();UserInfo userInfo = UserInfo.builder().ages(12).user(user).telephone("12345678").build();//保存userInfo的同上也会保存User信息userInfoRepository.saveAndFlush(userInfo);//删除userInfo,同时也会级联的删除user记录userInfoRepository.delete(userInfo);
}

最后,运行一下看看效果。
1.png
从上面的运行结果可以看到,上面的测试在执行了 insert 的时候,会执行两条 insert 的sql 和两条 delete 的 sql,这就体现出了 CascadeType.PERSIST 和 CascadeType.REMOVE 的作用。

上面讲了级联删除的场景,下面我们再说一下关联关系的删除场景该怎么做。

orphanRemoval 属性用法

orphanRemoval 表示当关联关系被删除的时候,是否应用级联删除,默认 false。什么意思呢?测试一下你就会明白。

首先,还沿用上面的例子,当我们删除 userInfo 的时候,把 User 置空,作如下改动。

复制代码

userInfo.setUser(null);
userInfoRepository.delete(userInfo);

其次,我们再运行测试,看看效果。

复制代码

Hibernate: delete from user_info where id=?

这时候你就会发现,少了一条删除 user 的 sql,说明没有进行级联删除。那我们再把 UserInfo 做一下调整。

复制代码

public class UserInfo {@OneToOne(cascade = {CascadeType.PERSIST},orphanRemoval = true)private User user;....其他没变的代码省了
}

然后,我们把 CascadeType.Remove 删除了,不让它进行级联删除,但是我们把 orphanRemoval 设置成 true,即当关联关系变化的时候级联更新。我们看下完整的测试用例。

复制代码

    @Testpublic void testUserRelationships() throws JsonProcessingException {User user = User.builder().name("jackxx").email("123456@126.com").build();UserInfo userInfo = UserInfo.builder().ages(12).user(user).telephone("12345678").build();userInfoRepository.saveAndFlush(userInfo);userInfo.setAges(13);userInfo.setUser(null);//还是通过这个设置user数据为空userInfoRepository.delete(userInfo);
}

这个时候我们看一下运行结果。
1.png

从中我们可以看到,结果依然是两个 inser 和两个 delete,但是中间多了一个 update。我来解释一下,因为去掉了 CascadeType.REMOVE,这个时候不会进行级联删除了。当我们把 user 对象更新成空的时候,就会执行一条 update 语句把关联关系去掉了。

而为什么又出现了级联删除 user 呢?因为我们修改了集合关联关系,orphanRemoval 设置为 true,所以又执行了级联删除的操作。这一点你可以仔细体会一下 orphanRemoval 和 CascadeType.REMOVE 的区别。

到这里,@OneToOne 关联关系介绍完了,接下来我们看一下日常工作常见的场景,先看场景一:主键和外键都是同一个字段的情况。

主键和外键都是同一个字段

我们假设 user 表是主表,user_info 的主键是 user_id,并且 user_id=user 是表里面的 id,那我们应该怎么写?

继续沿用上面的例子,User 实体不变,我们看看 UserInfo 变成什么样了。

复制代码

public class UserInfo implements Serializable {@Idprivate Long userId;private Integer ages;private String telephone;@MapsId@OneToOne(cascade = {CascadeType.PERSIST},orphanRemoval = true)private User user;
}

这里的做法很简单,我们直接把 userId 设置为主键,在 @OneToOne 上面添加 @MapsId 注解即可。@MapsId 注解的作用是把关联关系实体里面的 ID(默认)值 copy 到 @MapsId 标注的字段上面(这里指的是 user_id 字段)。

接着,上面的测试用例我们跑一下,看一下效果。

复制代码

Hibernate: create table user (id bigint not null, address varchar(255), email varchar(255), name varchar(255), sex varchar(255), primary key (id))
Hibernate: create table user_info (ages integer, telephone varchar(255), user_id bigint not null, primary key (user_id))
Hibernate: alter table user_info add constraint FKn8pl63y4abe7n0ls6topbqjh2 foreign key (user_id) references user

在启动的时候,我们直接创建了 user 表和 user_info 表,其中 user_info 的主键是 user_id,并且通过外键关联到了 user 表的 ID 字段,那么我们同时看一下 inser 的 sql,也发生了变化。

复制代码

Hibernate: insert into user (address, email, name, sex, id) values (?, ?, ?, ?, ?)
Hibernate: insert into user_info (ages, telephone, user_id) values (?, ?, ?)

上面就是我们讲的实战场景一,主键和外键都是同一个字段。接下来我们再说一个场景,就是在查 user_info 的时候,我们只想知道 user_id 的值就行了,不需要查 user 的其他信息,具体我们应该怎么做呢?

@OneToOne 延迟加载,我们只需要 ID 值

在 @OneToOne 延迟加载的情况下,我们假设只想查下 user_id,而不想查看 user 表其他的信息,因为当前用不到,可以有以下几种做法。

第一种做法:还是 User 实体不变,我们改一下 UserInfo 对象,如下所示:

复制代码

package com.example.jpa.example1;
import lombok.*;
import javax.persistence.*;
@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = "user")
public class UserInfo{@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private Integer ages;private String telephone;@MapsId@OneToOne(cascade = {CascadeType.PERSIST},orphanRemoval = true,fetch = FetchType.LAZY)private User user;
}

从上面这段代码中,可以看到做的更改如下:

  • id 字段我们先用原来的
  • @OneToOne 上面我们添加 @MapsId 注解
  • @OneToOne 里面的 fetch = FetchType.LAZY 设置延迟加载

接着,我们改造一下测试类,完整代码如下:

复制代码

@DataJpaTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class UserInfoRepositoryTest {@Autowiredprivate UserInfoRepository userInfoRepository;@BeforeAll@Rollback(false)@Transactionalvoid init() {User user = User.builder().name("jackxx").email("123456@126.com").build();UserInfo userInfo = UserInfo.builder().ages(12).user(user).telephone("12345678").build();userInfoRepository.saveAndFlush(userInfo);}/*** 测试用User关联关系操作** @throws JsonProcessingException*/@Test@Rollback(false)public void testUserRelationships() throws JsonProcessingException {UserInfo userInfo1 = userInfoRepository.getOne(1L);System.out.println(userInfo1);System.out.println(userInfo1.getUser().getId());
}

然后,我们跑一下测试用例,看看测试结果。

复制代码

Hibernate: insert into user (address, email, name, sex, id) values (?, ?, ?, ?, ?)
Hibernate: insert into user (address, email, name, sex, id) values (?, ?, ?, ?, ?)
两条inser照旧,而只有一个select
Hibernate: select userinfo0_.user_id as user_id3_6_0_, userinfo0_.ages as ages1_6_0_, userinfo0_.telephone as telephon2_6_0_ from user_info userinfo0_ where userinfo0_.user_id=?

最后你会发现,打印的结果符合预期。

复制代码

UserInfo(id=1, ages=12, telephone=12345678)
1

接下来介绍第二种做法,这种做法很简单,只要在 UserInfo 对象里面直接去掉 @OneToOne 关联关系,新增下面的字段即可。

复制代码

@Column(name = "user_id")
private Long userId;

第三做法是利用 Hibernate,它给我们提供了一种字节码增强技术,通过编译器改变 class 解决了延迟加载问题。这种方式有点复杂,需要在编译器引入 hibernateEnhance 的相关 jar 包,以及编译器需要改变 class 文件并添加 lazy 代理来解决延迟加载。我不太推荐这种方式,因为太复杂,你知道有这回事就行了。

以上我们掌握了这么多用法,那么最佳实践是什么?双向关联更好还是单向关联更好?根据最近几年的应用,我总结出了一些最佳实践,我们来看一下。

@OneToOne 的最佳实践是什么?

第一,我要说一种 Java 面向对象的设计原则:开闭原则。

即对扩展开放,对修改关闭。如果我们一直使用双向关联,两个实体的对象耦合太严重了。想象一下,随着业务的发展,User 对象可能是原始对象,围绕着 User 可能会扩展出各种关联对象。难道 User 里面每次都要修改,去添加双向关联关系吗?肯定不是,否则时间长了,对象与对象之间的关联关系就是一团乱麻。

所以,我们尽量、甚至不要用双向关联,如果非要用关联关系的话,只用单向关联就够了。双向关联正是 JPA 的强大之处,但同时也是问题最多,最被人诟病之处。所以我们要用它的优点,而不是学会了就一定要使用。

第二,我想说 CascadeType 很强大,但是我也建议保持默认。

即没有级联更新动作,没有级联删除动作。还有 orphanRemoval 也要尽量保持默认 false,不做级联删除。因为这两个功能很强大,但是我个人觉得这违背了面向对象设计原则里面的“职责单一原则”,除非你非常非常熟悉,否则你在用的时候会时常感到惊讶——数据什么时间被更新了?数据被谁删除了?遇到这种问题查起来非常麻烦,因为是框架处理,有的时候并非预期的效果。

一旦生产数据被莫名更新或者删除,那是一件非常糟糕的事情。因为这些级联操作会使你的方法名字没办法命名,而且它不是跟着业务逻辑变化的,而是跟着实体变化的,这就会使方法和对象的职责不单一。

第三,我想告诉你,所有用到关联关系的地方,能用 Lazy 的绝对不要用 EAGER,否则会有 SQL 性能问题,会出现不是预期的 SQL。

以上三点是我总结的避坑指南,有经验的同学这时候会有个疑问:外键约束不是不推荐使用的吗?如果我的外键字段名不是约定的怎么办?别着急,我们再看一下 @JoinColumn 注解和 @JoinColumns 注解。

@JoinCloumns & JoinColumn

这两个注解是集合关系,他们可以同时使用,@JoinColumn 表示单字段,@JoinCloumns 表示多个 @JoinColumn,我们来一一看一下。

我们还是先直接看一下 @JoinColumn 源码,了解下这一注解都有哪些配置项。

复制代码

public @interface JoinColumn {//关键的字段名,默认注解上的字段名,在@OneToOne代表本表的外键字段名字;String name() default "";//与name相反关联对象的字段,默认主键字段String referencedColumnName() default "";//外键字段是否唯一boolean unique() default false;//外键字段是否允许为空boolean nullable() default true;//是否跟随一起新增boolean insertable() default true;//是否跟随一起更新boolean updatable() default true;//JPA2.1新增,外键策略ForeignKey foreignKey() default @ForeignKey(PROVIDER_DEFAULT);
}

其次,我们看一下 @ForeignKey(PROVIDER_DEFAULT) 里面枚举值有几个。

复制代码

public enum ConstraintMode {//创建外键约束CONSTRAINT,//不创建外键约束NO_CONSTRAINT,//采用默认行为PROVIDER_DEFAULT
}

然后,我们看看这个注解的语法,就可以解答我们上面的两个问题。修改一下 UserInfo,如下所示:

复制代码

public class UserInfo{@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private Integer ages;private String telephone;@OneToOne(cascade = {CascadeType.PERSIST},orphanRemoval = true,fetch = FetchType.LAZY)@JoinColumn(foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT),name = "my_user_id")private User user;
...其他不变}

可以看到,我们在其中指定了字段的名字:my_user_id,并且指定 NO_CONSTRAINT 不生成外键。而测试用例不变,我们看下运行结果。

复制代码

Hibernate: create table user (id bigint not null, address varchar(255), email varchar(255), name varchar(255), sex varchar(255), primary key (id))
Hibernate: create table user_info (id bigint not null, ages integer, telephone varchar(255), my_user_id bigint, primary key (id))

这时我们看到 user_info 表里面新增了一个字段 my_user_id,insert 的时候也能正确 inser my_user_id 的值等于 user.id。

复制代码

Hibernate: insert into user_info (ages, telephone, my_user_id, id) values (?, ?, ?, ?)

而 @JoinColumns 是 JoinColumns 的复数形式,就是通过两个字段进行的外键关联,这个不常用,我们看一个 demo 了解一下就好。

复制代码

@Entity
public class CompanyOffice {@ManyToOne(fetch = FetchType.LAZY)@JoinColumns({@JoinColumn(name="ADDR_ID", referencedColumnName="ID"),@JoinColumn(name="ADDR_ZIP", referencedColumnName="ZIP")})private Address address;
}

上面的实例中,CompanyOffice 通过 ADDR_ID 和 ADDR_ZIP 两个字段对应一条 address 信息,解释了一下@JoinColumns的用法。

如果你了解了 @OneToOne 的详细用法,后面要讲的几个注解就很好理解了,因为他们有点类似,那么我们接下来看看 @ManyToOne 和 @OneToMany 的用法。

@ManyToOne& @OneToMany

@ManyToOne 代表多对一的关联关系,而 @OneToMany 代表一对多,一般两个成对使用表示双向关联关系。而 JPA 协议中也是明确规定:维护关联关系的是拥有外键的一方,而另一方必须配置 mappedBy。看下面的代码。

复制代码

public @interface ManyToOne {Class targetEntity() default void.class;CascadeType[] cascade() default {};FetchType fetch() default EAGER;boolean optional() default true;
}public @interface OneToMany {Class targetEntity() default void.class;//cascade 级联操作策略:(CascadeType.PERSIST、CascadeType.REMOVE、CascadeType.REFRESH、CascadeType.MERGE、CascadeType.ALL)
如果不填,默认关系表不会产生任何影响。CascadeType[] cascade() default {};
//数据获取方式EAGER(立即加载)/LAZY(延迟加载)FetchType fetch() default LAZY;//关系被谁维护,单项的。注意:只有关系维护方才能操作两者的关系。String mappedBy() default "";
//是否级联删除。和CascadeType.REMOVE的效果一样。两种配置了一个就会自动级联删除boolean orphanRemoval() default false;
}

我们看到上面的字段和 @OneToOne 里面的基本一样,用法是一样的,不过需要注意以下几点:

  1. @ManyToOne 一定是维护外键关系的一方,所以没有 mappedBy 字段;
  2. @ManyToOne 删除的时候一定不能把 One 的一方删除了,所以也没有 orphanRemoval 的选项;
  3. @ManyToOne 的 Lazy 效果和 @OneToOne 的一样,所以和上面的用法基本一致;
  4. @OneToMany 的 Lazy 是有效果的。

我们看个例子,假设 User 有多个地址 Address,我们看看实体应该如何建立。

复制代码

@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private String name;private String email;private String sex;@OneToMany(mappedBy = "user",fetch = FetchType.LAZY)private List<UserAddress> address;
}

上述代码我们可以看到,@OneToMany 双向关联并且采用 LAZY 的机制;这时我们新建一个 UserAddress 实体维护关联关系如下:

复制代码

@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = "user")
public class UserAddress {@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private String address;@ManyToOne(cascade = CascadeType.ALL)private User user;
}

再新建一个测试用例,完整代码如下:

复制代码

package com.example.jpa.example1;
import com.fasterxml.jackson.core.JsonProcessingException;
import org.assertj.core.util.Lists;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.annotation.Rollback;
import javax.transaction.Transactional;
@DataJpaTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class UserAddressRepositoryTest {@Autowiredprivate UserAddressRepository userAddressRepository;@Autowiredprivate UserRepository userRepository;/*** 负责添加数据*/@BeforeAll@Rollback(false)@Transactionalvoid init() {User user = User.builder().name("jackxx").email("123456@126.com").build();UserAddress userAddress = UserAddress.builder().address("shanghai1").user(user).build();UserAddress userAddress2 = UserAddress.builder().address("shanghai2").user(user).build();userAddressRepository.saveAll(Lists.newArrayList(userAddress,userAddress2));}/*** 测试用User关联关系操作* @throws JsonProcessingException*/@Test@Rollback(false)public void testUserRelationships() throws JsonProcessingException {User user = userRepository.getOne(2L);System.out.println(user.getName());System.out.println(user.getAddress());}
}

然后,我们看一下运行结果。

复制代码

Hibernate: create table user (id bigint not null, email varchar(255), name varchar(255), sex varchar(255), primary key (id))
Hibernate: create table user_address (id bigint not null, address varchar(255), user_id bigint, primary key (id))
Hibernate: alter table user_address add constraint FKk2ox3w9jm7yd6v1m5f68xibry foreign key (user_id) references user

接着我们创建两张表,并且创建外键。

复制代码

Hibernate: insert into user (email, name, sex, id) values (?, ?, ?, ?)
Hibernate: insert into user_address (address, user_id, id) values (?, ?, ?)
Hibernate: insert into user_address (address, user_id, id) values (?, ?, ?)

这时我们得到了符合预期的三条 inser 语句,可以看到 lazy 起作用了,说明了只有用到 address 的时候才会取重新加载 SQL。

1.png

综上,@ManyToOne 的 lazy 机制和用法,与 @OneToOne 的一样,我们就不过多介绍了。而 @ManyToOne 和 @OneToMany 的最佳实践,与 @OneToOne 的完全一样,也是尽量避免双向关联,一切级联更新和 orphanRemoval 都保持默认规则,并且 fetch 采用 lazy 延迟加载。

以上就是关于 @ManyToOne 和 @OneToMan 的讲解,实际开发过程中可以详细体会一下上面老师讲的用法。接下来我们介绍一下 @ManyToMany 多对多关联关系的用法。

@ManyToMany

@ManyToMany 代表多对多的关联关系,这种关联关系任何一方都可以维护关联关系。我们还是先看个例子感受一下。

我们假设 user 表和 room 表是多对多的关系,看看两个实体怎么写。

复制代码

package com.example.jpa.example1;
import lombok.*;
import javax.persistence.*;
import java.io.Serializable;
import java.util.List;
@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User{@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;private String name;@ManyToMany(mappedBy = "users")private List<Room> rooms;
}

接着,我们让 Room 维护关联关系。

复制代码

package com.example.jpa.example1;
import lombok.*;
import javax.persistence.*;
import java.util.List;
@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = "users")
public class Room {@Id@GeneratedValue(strategy = GenerationType.AUTO)private Long id;private String title;@ManyToManyprivate List<User> users;
}

然后,我们跑一下测试用例,可以看到如下结果:

复制代码

Hibernate: create table room (id bigint not null, title varchar(255), primary key (id))
Hibernate: create table room_users (rooms_id bigint not null, users_id bigint not null)
Hibernate: create table user (id bigint not null, email varchar(255), name varchar(255), sex varchar(255), primary key (id))
Hibernate: alter table room_users add constraint FKld9phr4qt71ve3gnen43qxxb8 foreign key (users_id) references user
Hibernate: alter table room_users add constraint FKtjvf84yquud59juxileusukvk foreign key (rooms_id) references room

从结果上我们看到 JPA 帮我们创建的三张表中,room_users 表维护了 user 和 room 的多对多关联关系。其实这个情况还告诉我们一个道理:当用到 @ManyToMany 的时候一定是三张表,不要想着建两张表,两张表肯定是违背表的设计原则的。

那么我们看下 @ManyToMany 的语法。

复制代码

public @interface ManyToMany {Class targetEntity() default void.class;CascadeType[] cascade() default {};FetchType fetch() default LAZY;String mappedBy() default "";
}

源码里面字段就这么多,基本和上面雷同,我就不多介绍了。这个时候有的同学可能会问,我们怎么去掉外键索引?怎么改中间表的表名?怎么指定外键字段的名字呢?我们继续引入另外一个注解——@JoinTable。

我先看一下例子,修改一下 Room 里面的内容。

复制代码

@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = "users")
public class Room {@Id@GeneratedValue(strategy = GenerationType.AUTO)private Long id;private String title;@ManyToMany@JoinTable(name = "user_room_ref",joinColumns = @JoinColumn(name = "room_id_x"),inverseJoinColumns = @JoinColumn(name = "user_id_x"))private List<User> users;
}

接着,我们在 Room 里面添加了 @JoinTable 注解,看一下 junit 的运行结果。

复制代码

Hibernate: create table room (id bigint not null, title varchar(255), primary key (id))
Hibernate: create table user (id bigint not null, email varchar(255), name varchar(255), sex varchar(255), primary key (id))
Hibernate: create table user_room_ref (room_id_x bigint not null, user_id_x bigint not null)
Hibernate: alter table user_room_ref add constraint FKoxolr1eyfiu69o45jdb6xdule foreign key (user_id_x) references user
Hibernate: alter table user_room_ref add constraint FK2sl9rtuxo9w130d83e19f3dd9 foreign key (room_id_x) references room

到这里可以看到,我们创建了一张中间表,并且添加了两个在预想之内的外键关系。

复制代码

public @interface JoinTable {//中间关联关系表明String name() default "";//表的catalogString catalog() default "";//表的schemaString schema() default "";//维护关联关系一方的外键字段的名字JoinColumn[] joinColumns() default {};//另一方的表外键字段JoinColumn[] inverseJoinColumns() default {};//指定维护关联关系一方的外键创建规则ForeignKey foreignKey() default @ForeignKey(PROVIDER_DEFAULT);//指定另一方的外键创建规则ForeignKey inverseForeignKey() default @Forei gnKey(PROVIDER_DEFAULT);
}

那么通过上面的介绍,你知道了 @ManyToMany 的用法,然而实际开发者对 @ManyToMany 用得比较少,一般我们会用成对的 @ManyToOne 和 @OneToMany 代替,因为我们的中间表可能还有一些约定的公共字段,如 ID、update_time、create_time等其他字段。

利用 @ManyToOne 和 @OneToMany 表达多对多的关联关系

我们修改一下上面的 Demo,来看一下通过 @ManyToOne 和 @OneToMany 如何表达多对多的关联关系。

我们新建一张表 user_room_relation 来存储双方的关联关系和额外字段,实体如下:

复制代码

package com.example.jpa.example1;
import lombok.*;
import javax.persistence.*;
import java.util.Date;
@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserRoomRelation {@Id@GeneratedValue(strategy = GenerationType.AUTO)private Long id;private Date createTime,udpateTime;@ManyToOneprivate Room room;@ManyToOneprivate User user;
}

而 User 变化如下:

复制代码

public class User implements Serializable {@Id@GeneratedValue(strategy= GenerationType.AUTO)private Long id;@OneToMany(mappedBy = "user")private List<UserRoomRelation> userRoomRelations;
....}Room 变化如下:
public class Room {@Id@GeneratedValue(strategy = GenerationType.AUTO)private Long id;@OneToMany(mappedBy = "room")private List<UserRoomRelation> userRoomRelations;
...}

到这里我们再看一下 JUnit 运行结果。

复制代码

Hibernate: create table user_room_relation (id bigint not null, create_time timestamp, udpate_time timestamp, room_id bigint, user_id bigint, primary key (id))
Hibernate: create table room (id bigint not null, title varchar(255), primary key (id))
Hibernate: create table user (id bigint not null, email varchar(255), name varchar(255), sex varchar(255), primary key (id))

可以看到,上面我们依然创建了三张表,唯一不同的是 user_room_relation 里面多了很多字段,而外键索引也是如约创建,如下所示:

复制代码

Hibernate: alter table user_room_relation add constraint FKaesy2rg60vtaxxv73urprbuwb foreign key (room_id) references room
Hibernate: alter table user_room_relation add constraint FK45gha85x63026r8q8hs03uhwm foreign key (user_id) references user

好了,跑一下测试是不是就很容易理解了。下面我总结了关于 @ManyToMany 的最佳实践和你分享。

@ManyToMany 的最佳实践
  1. 上面我们介绍的 @OneToMany 的最佳实践同样适用,我为了说明方便,采用的是双向关联,而实际生产一般是在中间表对象里面做单向关联,这样会让实体之间的关联关系简单很多。
  2. 与 @OneToMany 一样的道理,不要用级联删除和 orphanRemoval=true。
  3. FetchType 采用默认方式:fetch = FetchType.LAZY 的方式。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/158750.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

用 Three.js 创建一个酷炫且真实的地球

接下来我会分步骤讲解&#xff0c;在线示例在数字孪生平台。 先添加一个球体 我们用threejs中的SphereGeometry来创建球体&#xff0c;给他贴一张地球纹理。 let earthGeo new THREE.SphereGeometry(10, 64, 64) let earthMat new THREE.MeshStandardMaterial({map: albed…

【汇编语言学习笔记】一、基础知识

引言 汇编语言是直接在硬件之上工作的编程语言&#xff0c;首先要了解硬件系统的结构&#xff0c;才能有效的应用汇编语言对其编程。 1.1机器语言 机器语言是机器指令的集合。 机器指令展开来讲就是一台机器可以正确执行的命令。 1.2汇编语言 汇编语言的主体是汇编指令。 …

【云计算】相关解决方案介绍

文章目录 1.1 云服务环境 Eucalyptus1.1.1 介绍1.1.2 开源协议及语言1.1.3 官方网站 1.2 开源云计算平台 abiCloud1.2.1 开源协议及语言1.2.2 官方网站 1.3 分布式文件系统 Hadoop1.3.1 开源协议及语言1.3.2 官方网站 1.4 JBoss云计算项目集 StormGrind1.4.1 开源协议及语言1.4…

uniapp打包配置

安卓&#xff1a; 首先不管是什么打包都需要证书&#xff0c;安卓的证书一般都是公司提供或者自己去申请。然后把包名等下图框住的信息填上&#xff0c;点击打包即可。 ios&#xff1a;ios需要使用mac到苹果开发者平台去申请证书&#xff0c;流程可以参考下边的链接 参考链接…

解决git在window11操作很慢,占用很大cpu的问题

【git在window11操作很慢&#xff0c;占用很大cpu&#xff0c;最后也执行失败】 在谷歌输入&#xff1a;git very slow in window 11。通过下面链接终于找到了解决方案&#xff1a; https://www.reddit.com/r/vscode/comments/sulebx/slow_git_in_wsl_after_updating_to_window…

【Java基础知识】

文章目录 前言1. 添加环境变量的方法2.JDK JRE JVM3.main方法4.注释5.标识符6.数据类型与变量6.1字节&#xff1a;6.2变量6.3找最大值和最小值范围整型变量浮点型变量字符型变量布尔型变量 前言 最近焦虑迷茫&#xff0c;学习过程中遇到了困难&#xff0c;所以想重新复习一遍S…

【C++】适配器模式 - - stack/queue/deque

目录 一、适配器模式 1.1迭代器模式 1.2适配器模式 二、stack 2.1stack 的介绍和使用 2.2stack的模拟实现 三、queue 3.1queue的介绍和使用 3.2queue的模拟实现 四、deque&#xff08;不满足先进先出&#xff0c;和队列无关&#xff09; 4.1deque的原理介绍 4.2dequ…

在线兴趣教学类线上学习APP应用开发部署程序组建研发团队需要准备什么?

哈哈哈&#xff0c;同学们&#xff0c;我又来了&#xff0c;这个问题最近问的人有点多&#xff0c;但是说实话我也不知道&#xff0c;但是我还是总结了一下&#xff0c;毕竟我懂点代码的皮毛&#xff0c;同时我检索内容的时候&#xff0c;都是一些没有很新鲜的文案&#xff0c;…

大数据笔记-大数据处理流程

大家对大数据处理流程大体上认识差不多&#xff0c;具体做起来可能细节各不相同&#xff0c;一幅简单的大数据处理流程图如下&#xff1a; 1&#xff09;数据采集&#xff1a;数据采集是大数据处理的第一步。 数据采集面对的数据来源是多种多样的&#xff0c;包括各种传感器、社…

极简c++(4)类的静态成员

静态数据成员 ::是作用域操作符&#xff01; #include<iostream> using namespace std;class Point{private:int x,y;public:point(int x 0,int y 0):x(x),y(y){}~point();int getX(){return x;}int getY(){return x;} }假设需要统计点的个数&#xff0c;考虑添加一个…

计算机网络 | 网络层

计算机网络 | 网络层 计算机网络 | 网络层功能概述SDN&#xff08;Software-Defined Networking&#xff09;路由算法与路由协议IPv4IPv4 分组IPv4 分组的格式IPv4 数据报分片 参考视频&#xff1a;王道计算机考研 计算机网络 参考书&#xff1a;《2022年计算机网络考研复习指…

【VSCode】Windows环境下,VSCode 搭建 cmake 编译环境(VSCode 插件配置)

目录 一、下载编译器 1、下载 Windows GCC 2、选择编译器路径 二、下载插件 三、配置 cmake generator 四、编译工程 一、下载编译器 1、下载 Windows GCC 这里是在Windows环境下&#xff0c;所以下载的是 Windows 环境使用的 gcc 编译器。 下载地址: MinGW-w64 - for…

【mfc/VS2022】计图实验:绘图工具设计知识笔记

绘制曲线&#xff08;贝塞尔曲线&#xff09;&#xff1a; 转自&#xff1a;CDC 类 | Microsoft Learn 绘制一条或多条贝塞尔曲线。 BOOL PolyBezier(const POINT* lpPoints,int nCount);参数 lpPoints 指向包含曲线端点和控制点的 POINT 数据结构数组。 nCount 指定 lpPo…

伦敦金的交易时间究竟多长?

接触过伦敦金交易的投资者&#xff0c;应该都知道自己根本不用担心市场上没有交易的机会&#xff0c;因为它全天的交易时间长达20多个小时&#xff0c;也就是在每一个正常的交易日&#xff0c;除去交易平台中途短暂的系统维护时间&#xff0c;投资者几乎全天都可以做盘。 伦敦金…

mssql还原数据库失败

标题: Microsoft SQL Server Management Studio ------------------------------ 服务器 "192.168.31.132" 的 附加数据库 失败。 (Microsoft.SqlServer.Smo) 有关帮助信息&#xff0c;请单击: https://go.microsoft.com/fwlink?ProdNameMicrosoftSQLServer&…

第四篇Android--TextView使用详解

TextView是View体系中的一员&#xff0c;继承自View&#xff0c;用于在界面中展示文字。 基本用法&#xff1a; <TextViewandroid:id"id/textview"android:layout_width"wrap_content"android:layout_height"wrap_content"android:padding&q…

VScode运行C/C++

VScode运行C/C VScode的安装这里不讲 一、mingw64的下载 二、VS code打开文件夹与创建C文件 ----------------这一步给萌新看&#xff0c;有C和VScode的基础可跳过---------------- 1.创建一个文件夹 2.vscode打开刚刚创建的文件夹 3.新建文件&#xff0c;在输入文件名1.c后…

一种更具破坏力的DDoS放大攻击新模式

近日&#xff0c;内容分发网络&#xff08;CDN&#xff09;运营商Akamai表示&#xff0c;一种使网站快速瘫痪的DDoS放大攻击新方法正在被不法分子所利用。这种方法是通过控制数量巨大的中间设备&#xff08;middlebox&#xff0c;主要是指配置不当的服务器&#xff09;&#xf…

Git 回退代码的两种方法对比

Git 回退代码版本 在项目的开发中&#xff0c;有时候还是会出现&#xff0c;一些误提交了一些代码&#xff0c;这时候就会想撤回提交的代码&#xff0c;在Git中有两种方法可以使用&#xff0c;现在通过对比方法比较这两种方法的区别&#xff0c;分别适用于哪些情况&#xff1f…

软件架构设计(业务架构、应用架构、数据架构、技术架构)

一、架构相关概念 1、系统 系统&#xff1a;由一群有关联的个体组成&#xff0c;根据某种规则运作&#xff0c;能完成个别原件不能独立完成的工作的群体。大的系统可以嵌套小系统&#xff0c;被嵌套的小系统往往称为大系统的子系统。 2、模块 模块是从逻辑上将系统分解&#…