SpringData JPA的多对多操作

╰+攻爆jí腚メ 2023-07-01 06:27 2阅读 0赞

# 明确表关系 #

> 用户和角色之间的关系是多对多。

多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

# 实体类关系建立以及映射配置 #

## 创建maven工程引入坐标 ##

1、创建一个不使用maven的模块  
2、引入pom坐标

<properties>
            <spring.version>4.2.4.RELEASE</spring.version>
            <hibernate.version>5.0.7.Final</hibernate.version>
            <slf4j.version>1.6.6</slf4j.version>
            <log4j.version>1.2.12</log4j.version>
            <c3p0.version>0.9.1.2</c3p0.version>
            <mysql.version>8.0.15</mysql.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.9</version>
                <scope>test</scope>
            </dependency>
    
            
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.6.8</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            
    
            
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-core</artifactId>
                <version>${hibernate.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-entitymanager</artifactId>
                <version>${hibernate.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-validator</artifactId>
                <version>5.2.1.Final</version>
            </dependency>
            
    
            
            <dependency>
                <groupId>c3p0</groupId>
                <artifactId>c3p0</artifactId>
                <version>${c3p0.version}</version>
            </dependency>
            
    
            
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            
    
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-jpa</artifactId>
                <version>1.9.0.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>javax.el</groupId>
                <artifactId>javax.el-api</artifactId>
                <version>2.2.4</version>
            </dependency>
    
            <dependency>
                <groupId>org.glassfish.web</groupId>
                <artifactId>javax.el</artifactId>
                <version>2.2.4</version>
            </dependency>
            
        </dependencies>

## 创建实体类&建立表关系 ##

1、创建实体类，并建立表关系

*  一个用户可以具有多个角色，所以在用户实体类中应该包含多个角色的信息，代码如下：

/**
     * 用户的数据模型
     */
    @Entity
    @Table(name="sys_user")
    public class SysUser implements Serializable {
        
    	
    	@Id
    	@GeneratedValue(strategy=GenerationType.IDENTITY)
    	@Column(name="user_id")
    	private Long userId;
    	@Column(name="user_code")
    	private String userCode;
    	@Column(name="user_name")
    	private String userName;
    	@Column(name="user_password")
    	private String userPassword;
    	@Column(name="user_state")
    	private String userState;
    	
    	//多对多关系映射
    	@ManyToMany(mappedBy="users")
    	private Set<SysRole> roles = new HashSet<SysRole>(0);
    	
    	public Long getUserId() {
        
    		return userId;
    	}
    	public void setUserId(Long userId) {
        
    		this.userId = userId;
    	}
    	public String getUserCode() {
        
    		return userCode;
    	}
    	public void setUserCode(String userCode) {
        
    		this.userCode = userCode;
    	}
    	public String getUserName() {
        
    		return userName;
    	}
    	public void setUserName(String userName) {
        
    		this.userName = userName;
    	}
    	public String getUserPassword() {
        
    		return userPassword;
    	}
    	public void setUserPassword(String userPassword) {
        
    		this.userPassword = userPassword;
    	}
    	public String getUserState() {
        
    		return userState;
    	}
    	public void setUserState(String userState) {
        
    		this.userState = userState;
    	}
    	public Set<SysRole> getRoles() {
        
    		return roles;
    	}
    	public void setRoles(Set<SysRole> roles) {
        
    		this.roles = roles;
    	}
    	@Override
    	public String toString() {
        
    		return "SysUser [userId=" + userId + ", userCode=" + userCode + ", userName=" + userName + ", userPassword="
    				+ userPassword + ", userState=" + userState + "]";
    	}
    }

*  一个角色可以赋予多个用户，所以在角色实体类中应该包含多个用户的信息，代码如下：

/**
     * 角色的数据模型
     */
    @Entity
    @Table(name="sys_role")
    public class SysRole implements Serializable {
        
    	
    	@Id
    	@GeneratedValue(strategy=GenerationType.IDENTITY)
    	@Column(name="role_id")
    	private Long roleId;
    	@Column(name="role_name")
    	private String roleName;
    	@Column(name="role_memo")
    	private String roleMemo;
    	
    	//多对多关系映射
    	@ManyToMany
    	@JoinTable(name="user_role_rel",//中间表的名称
    			  //中间表user_role_rel字段关联sys_role表的主键字段role_id
    			  joinColumns={
        @JoinColumn(name="role_id",referencedColumnName="role_id")},
    			  //中间表user_role_rel的字段关联sys_user表的主键user_id
    			  inverseJoinColumns={
        @JoinColumn(name="user_id",referencedColumnName="user_id")}
    	)
    	private Set<SysUser> users = new HashSet<SysUser>(0);
    	
    	
    	public Long getRoleId() {
        
    		return roleId;
    	}
    	public void setRoleId(Long roleId) {
        
    		this.roleId = roleId;
    	}
    	public String getRoleName() {
        
    		return roleName;
    	}
    	public void setRoleName(String roleName) {
        
    		this.roleName = roleName;
    	}
    	public String getRoleMemo() {
        
    		return roleMemo;
    	}
    	public void setRoleMemo(String roleMemo) {
        
    		this.roleMemo = roleMemo;
    	}
    	public Set<SysUser> getUsers() {
        
    		return users;
    	}
    	public void setUsers(Set<SysUser> users) {
        
    		this.users = users;
    	}
    	@Override
    	public String toString() {
        
    		return "SysRole [roleId=" + roleId + ", roleName=" + roleName + ", roleMemo=" + roleMemo + "]";
    	}
    }

### 映射的注解说明 ###

#### @ManyToMany ####

>  *  作用：用于映射多对多关系
>  *  属性：
>     
>      *  cascade：配置级联操作。
>      *  fetch：配置是否采用延迟加载。
>  *  targetEntity：配置目标的实体类。映射多对多的时候不用写。

#### @JoinTable ####

>  *  作用：针对中间表的配置
>  *  属性：
>     
>      *  name：配置中间表的名称
>      *  joinColumns：中间表的外键字段关联当前实体类所对应表的主键字段
>      *  inverseJoinColumn：中间表的外键字段关联对方表的主键字段

#### @JoinColumn ####

>  *  作用：用于定义主键字段和外键字段的对应关系。
>  *  属性：
>     
>      *  name：指定外键字段的名称
>      *  referencedColumnName：指定引用主表的主键字段名称
>      *  unique：是否唯一。默认值不唯一
>      *  nullable：是否允许为空。默认值允许。
>      *  insertable：是否允许插入。默认值允许。
>      *  updatable：是否允许更新。默认值允许。
>      *  columnDefinition：列的定义信息。

## dao层 ##

public interface SysUserDao extends JpaRepository<SysUser, Long>, JpaSpecificationExecutor<SysUser> {
        
    }

public interface SysRoleDao extends JpaRepository<SysRole, Long>, JpaSpecificationExecutor<SysRole> {
        
    }

## 编写配置文件：src\\main\\resources\\applicationContext.xml ##

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
           xsi:schemaLocation="
    		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
    		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
    		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
    		http://www.springframework.org/schema/data/jpa
    		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
    
        
    
        
        <bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
            <property name="dataSource" ref="dataSource" />
            
            <property name="packagesToScan" value="com.oceanstar.domain" />
            
            <property name="persistenceProvider">
                <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
            </property>
    
            
            <property name="jpaVendorAdapter">
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                    
                    <property name="generateDdl" value="false" />
                    
                    <property name="database" value="MYSQL" />
                    
                    <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                    
                    <property name="showSql" value="true" />
                </bean>
            </property>
    
            
            <property name="jpaDialect" >
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
            </property>
    
            
            <property name="jpaProperties" >
                <props>
                    <prop key="hibernate.hbm2ddl.auto">create</prop>
                </props>
            </property>
    
        </bean>
    
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="user" value="root"></property>
            <property name="password" value="123456"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC" ></property>
            <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        </bean>
    
        
        <jpa:repositories base-package="com.oceanstar.dao" transaction-manager-ref="transactionManager"
                       entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>
    
        
        <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
            <property name="entityManagerFactory" ref="entityManagerFactoty"></property>
        </bean>
    
        
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="save*" propagation="REQUIRED"/>
                <tx:method name="insert*" propagation="REQUIRED"/>
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="get*" read-only="true"/>
                <tx:method name="find*" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
    
        
        <aop:config>
            <aop:pointcut id="pointcut" expression="execution(* com.oceanstar.service.*.*(..))" />
            <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
        </aop:config>
    
    
        
    
        
        <context:component-scan base-package="com.oceanstar" ></context:component-scan>
    </beans>

# 多对多的操作 #

## 保存 ##

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:applicationContext.xml")
    public class ManyToManyTest {
        
        @Autowired
        private SysUserDao userDao;
    
        @Autowired
        private SysRoleDao roleDao;
        /**
         * 需求：
         * 	保存用户和角色
         * 要求：
         * 	创建2个用户和3个角色
         * 	让1号用户具有1号和2号角色(双向的)
         * 	让2号用户具有2号和3号角色(双向的)
         *  保存用户和角色
         * 问题：
         *  在保存时，会出现主键重复的错误，因为都是要往中间表中保存数据造成的。
         * 解决办法：
         * 	让任意一方放弃维护关联关系的权利：被动的一方放弃
         */
        @Test
        @Transactional
        @Rollback(false)
        public void  testAdd() {
        
            SysUser user1 = new SysUser();
            user1.setUserName("小李1");
    
            SysUser user2 = new SysUser();
            user2.setUserName("小李2");
    
    
            SysRole role1 = new SysRole();
            role1.setRoleName("java程序员1");
            SysRole role2 = new SysRole();
            role2.setRoleName("java程序员2");
            SysRole role3 = new SysRole();
            role3.setRoleName("java程序员3");
    
    
            //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
            user1.getRoles().add(role1);
            //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
            role1.getUsers().add(user1);
    
            //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
            user1.getRoles().add(role2);
            //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
            role2.getUsers().add(user1);
    
            userDao.save(user1);
            roleDao.save(role1);
            userDao.save(user2);
            roleDao.save(role2);
            roleDao.save(role3);
        }
    }

**在多对多（保存）中，如果双向都设置关系，意味着双方都维护中间表，都会往中间表插入数据，中间表的2个字段又作为联合主键，所以报错，主键重复，解决保存失败的问题：只需要在任意一方放弃对中间表的维护权即可，推荐在被动的一方放弃，配置如下：**

//放弃对中间表的维护权，解决保存中主键冲突的问题
    	@ManyToMany(mappedBy="roles")
    	private Set<SysUser> users = new HashSet<SysUser>(0);

## 删除 ##

/**
         * 删除操作
         * 	在多对多的删除时，双向级联删除根本不能配置
         * 禁用
         *	如果配了的话，如果数据之间有相互引用关系，可能会清空所有数据
         */
        @Test
        @Transactional
        @Rollback(false)//设置为不回滚
        public void testDelete() {
        
            userDao.delete(1l);
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200119162840931.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70