在本教程中，我们将学习如何使用SpringDataJPA（Hibernate as JPA提供者）实现多对多域模型双向Map。
我们使用User和Role实体执行多对多双向Map。
双向关系Map允许您在两个方向上导航关联。
在双向Map中，我们在两个实体（用户和角色）上使用@ManyToMany注解。

多对多双向Map-ER图

多对多关系是使用名为users_roles的第三个表实现的，该表包含用户和角色表的外键。

1.创建Spring Boot项目

SpringBoot提供了一个名为https://start.spring.io的web工具来快速引导应用程序。只需转到https://start.spring.io并生成一个新的spring-boot项目。

在创建Spring引导时使用以下详细信息：
**项目名称：**Spring Data jpa课程
**项目类型：**Maven
**选择依赖项：**Spring Data JPA、MySQL Driver、Lombok
**软件包名称：**net.javaguides.springboot

2.Maven依赖项

这是完整的pom。xml供您参考：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.6.1</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>net.javaguides</groupId>
	<artifactId>spring-data-jpa-course</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring-data-jpa-course</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>11</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

3.配置MySQL数据库

在本例中，让我们使用MySQL数据库存储和检索数据，并使用Hibernate属性创建和删除表。

打开应用程序。属性文件，并向其中添加以下配置：

spring.datasource.url=jdbc:mysql://localhost:3306/demo?useSSL=false
spring.datasource.username=root
spring.datasource.password=Mysql@123
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.ddl-auto = create-drop

确保在运行Spring引导应用程序之前创建一个演示数据库。
此外，根据您机器上的MySQL安装更改MySQL用户名和密码。

4.创建JPA实体

让我们在基本包“net.javaguides.springboot”中创建一个实体包。
在实体包中，创建包含以下内容的User和Role类：

User.java

package com.springdatajpa.springboot.entity;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Getter
@Setter
@Entity
@Table(
        name = "users",
        uniqueConstraints = @UniqueConstraint(
                name = "unique_email",
                columnNames = "email"
        )
)
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    private String firstName;
    private String lastName;
    private String email;
    private String password;
    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinTable(
            name = "users_roles",
            joinColumns = @JoinColumn(
                    name = "user_id", referencedColumnName = "id"
            ),
            inverseJoinColumns = @JoinColumn(
                    name = "role_id", referencedColumnName = "id"
            )
    )
    private Set<Role> roles = new HashSet<>();
}

Role.java

package com.springdatajpa.springboot.entity;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Getter
@Setter
@Entity
@Table(name = "roles")
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    private String name;
    @ManyToMany(cascade = {
            CascadeType.PERSIST,
            CascadeType.MERGE
    }, fetch = FetchType.EAGER,
    mappedBy = "roles")
    private Set<User> users = new HashSet<>();
}

5.创建Spring Data JPA存储库

接下来，让我们创建SpringDataJPA存储库，以从数据库访问User和Role实体。

JpaRepository接口定义了实体上所有CRUD操作的方法，以及名为SimpleJpaReproository的JpaRepocitory的默认实现。
让我们在基本包“net.javaguides.springdatarest”中创建一个存储库包。
在存储库软件包中，创建具有以下内容的UserRepository和RoleRestory界面：

UserRepository.java

package com.springdatajpa.springboot.repository;
import com.springdatajpa.springboot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
}

RoleRepository.java

package com.springdatajpa.springboot.repository;
import com.springdatajpa.springboot.entity.Role;
import org.springframework.data.jpa.repository.JpaRepository;
public interface RoleRepository extends JpaRepository<Role, Long> {
}

型

6.测试多对多双向Map

让我们编写JUnit测试，使用Spring Data JPA测试多对多双向Map：

package com.springdatajpa.springboot.repository;
import com.springdatajpa.springboot.entity.Role;
import com.springdatajpa.springboot.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class ManyToManyBidirectionalTest {
    @Autowired
    private RoleRepository roleRepository;
    @Test
    void saveRole(){
        User user = new User();
        user.setFirstName("ramesh");
        user.setLastName("fadatare");
        user.setEmail("ramesh@gmail.com");
        user.setPassword("secrete");
        User admin = new User();
        admin.setFirstName("admin");
        admin.setLastName("admin");
        admin.setEmail("admin@gmail.com");
        admin.setPassword("admin");
        Role roleAdmin = new Role();
        roleAdmin.setName("ROLE_ADMIN");
        roleAdmin.getUsers().add(user);
        roleAdmin.getUsers().add(admin);
        user.getRoles().add(roleAdmin);
        admin.getRoles().add(roleAdmin);
        roleRepository.save(roleAdmin);
    }
    @Test
    void fetchRole(){
        List<Role> roles = roleRepository.findAll();
        roles.forEach((r) ->{
            System.out.println(r.getName());
            r.getUsers().forEach((u) ->{
                System.out.println(u.getFirstName());
            });
        });
    }
}

保存角色还将保存关联的用户（Cascade.PERSIST）：

@Test
    void saveRole(){
        User user = new User();
        user.setFirstName("ramesh");
        user.setLastName("fadatare");
        user.setEmail("ramesh@gmail.com");
        user.setPassword("secrete");
        User admin = new User();
        admin.setFirstName("admin");
        admin.setLastName("admin");
        admin.setEmail("admin@gmail.com");
        admin.setPassword("admin");
        Role roleAdmin = new Role();
        roleAdmin.setName("ROLE_ADMIN");
        roleAdmin.getUsers().add(user);
        roleAdmin.getUsers().add(admin);
        user.getRoles().add(roleAdmin);
        admin.getRoles().add(roleAdmin);
        roleRepository.save(roleAdmin);
    }

提取角色还将提取其关联用户（提取类型EAGER）：

@Test
    void fetchRole(){
        List<Role> roles = roleRepository.findAll();
        roles.forEach((r) ->{
            System.out.println(r.getName());
            r.getUsers().forEach((u) ->{
                System.out.println(u.getFirstName());
            });
        });
    }

Spring Data JPA多对多双向Map