Spring Data Jpa（多对多）

多对多操作

案例：用戶和角色（多对多关系）

• 用户：
• 角色：

分析步骤

• 1、明确表关系
  • 多对多的关系
• 2、确定表关系（描述 外键 | 中间表）
  • 中间表
• 3、编写实体类，在实体类中描述表关系（包含关系）
  • 用户：包含角色的集合
  • 角色：包含用户的集合
• 4、配置映射关系
  • 使用jpa注解配置一对多映射关系

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rzk</groupId>
    <artifactId>jpa-day3-manytomany</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <spring.version>5.0.2.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>5.1.6</mysql.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--spring beg-->
        <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>

        <!--hibernate beg-->


        <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.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.9.Final</version>
        </dependency>

        <!--c3p0 beg-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>

        <!--log end-->
        <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>
        <!--log end-->

        <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>org.springframework</groupId>
            <artifactId>spring-jcl</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--el beg使用spring data jpa 必须引入-->

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>


        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
    </dependencies>
</project>

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

<!--spring 和 spring data jpa 的配置-->

    <!--1、創建entityManagerFactory 对象交给spring容器管理-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--实体类所在的包-->
        <property name="packagesToScan"  value="com.rzk.pojo"/>
        <!--jpa的供应商适配器-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--jpa的供应商适配器-->
        <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"/>
                <!--是否显示sql-->
                <property name="showSql" value="true"/>
            </bean>
        </property>

        <!--jpa的方言：高级特性-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>

        <!--注入jpa的配置信息
            加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息

            hibernate.hbm2ddl.auto : 自动创建数据库表
                    create  ： 每次都会重新创建数据库表
                    update  ： 有表不会重新创建，没有表会重新创建表
        -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
            </props>
        </property>
    </bean>

    <!--2、创建数据库连接池-->
    <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://127.0.0.1:3306/jap"></property>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    </bean>

    <!--3、整合spring dataJpa-->
    <jpa:repositories base-package="com.rzk.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

    <!--4、配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></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>-->
<!--    -->
<!--    &lt;!&ndash;5.aop&ndash;&gt;-->
<!--    <aop:config>-->
<!--        <aop:pointcut id="pointcut" expression="execution(* com.rzk.server.*.*(..))"/>-->
<!--        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>-->
<!--    </aop:config>-->

    <!--6、配置包扫描-->
    <context:component-scan base-package="com.rzk"></context:component-scan>
</beans>

实体类

需要getset方法

• 1.声明表关系的配置
• @ManyToMany(targetEntity:对方实体类字节码) 多对多
• 2.配置中间表（包含两个外键）
  • @JoinTable
    • name：中间表名称
    • joinColumns：配置当前对象在中间被的外键
      • JoinColumn：{数组}
        • name：当前表的外键的名字（可随便取）
        • referencedColumnName：参照主表（该表）的主键
    • inverseJoinColumns：配置对方对象在中间表的外键

user

@Entity
@Table(name = "sys_user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "user_id")
    private Long userId;
    @Column(name = "user_name")
    private String userName;
    @Column(name = "age")
    private Integer age;
    /**
     * 1、配置用户到角色的多对多关系
     *      配置多对多的映射关系
     *          1.声明表关系的配置
     *              @ManyToMany(targetEntity:对方实体类字节码)   多对多
     *          2.配置中间表（包含两个外键）
     *              @JoinTable
     *                  name：中间表名称
     *                  joinColumns：配置当前对象在中间被的外键
     *                      JoinColumn：{数组}
     *                          name：当前表的外键的名字（可随便取）
     *                          referencedColumnName：参照主表（该表）的主键
     *                  inverseJoinColumns：配置对方对象在中间表的外键
     *
     */
    @ManyToMany(targetEntity = Role.class)
    @JoinTable(name = "sys_user_role",
            // joinColumns,当前对象在中间表中的外键,
            // name="当前表的外键的名字（可随便取）“
            // referencedColumnName=“参照该表的主键”
            joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
            //inverseJoinColumns :对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
    )
    private Set<Role> roles = new HashSet<>();
}

role

@Entity
@Table(name = "sys_role")
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY )
    @Column(name = "role_id")
    private Long roleId;
    @Column(name = "role_name")
    private String roleName;

    @ManyToMany(targetEntity = User.class)
    @JoinTable(name = "sys_user_role",
            // joinColumns,当前对象在中间表中的外键,
            // name="当前表的外键的名字（可随便取）“
            // referencedColumnName=“参照该表的主键”
            joinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")},
            //inverseJoinColumns :对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")}
    )
    private Set<User> users = new HashSet<>();
}

dao层接口

RoleDao

public interface Role extends JpaRepository<Role,Long>, JpaSpecificationExecutor<Role> {
}

UserDao

public interface UserDao extends JpaRepository<User,Long>, JpaSpecificationExecutor<User> {
}

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToMany {

    @Autowired
    private UserDao userDao;

    @Autowired
    private RoleDao roleDao;

    /**
     * 保存一个用户,保存一个角色
     */

    @Test
    @Transactional
    @Rollback(false)
    public void testAdd(){
        User user = new User();
        user.setUserName("lisi");

        Role role = new Role();
        role.setRoleName("student");

        userDao.save(user);
        roleDao.save(role);
    }
}

可以看到表创建成功

看一下表的内容

解决中间表没数据

role.getUsers().add(user);//二选一
user.getRoles().add(role);//二选一

    @Test
    @Transactional
    @Rollback(false)
    public void testAdd(){
        User user = new User();
        user.setUserName("lisi");

        Role role = new Role();
        role.setRoleName("student");

        role.getUsers().add(user);//二选一
        user.getRoles().add(role);//二选一

        userDao.save(user);
        roleDao.save(role);
    }

如果把方法执行两次的话

会报主键异常
1-1

如何解决呢?
需要有一端放弃维护权
多对多放弃维护权 ： 被动的一方放弃维护 mappedBy = ""

在Role实体类上修改

如果applicationContext.xml 设置了create，需要把create改成update

@ManyToMany(mappedBy = "roles") //配置多表关系
private Set users = new HashSet<>();

@Entity
@Table(name = "sys_role")
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY )
    @Column(name = "role_id")
    private Long roleId;
    @Column(name = "role_name")
    private String roleName;

    @ManyToMany(mappedBy = "roles") //配置多表关系
    private Set<User> users = new HashSet<>();

测试 插入两次

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToMany {

    @Autowired
    private UserDao userDao;

    @Autowired
    private RoleDao roleDao;

    /**
     * 保存一个用户,保存一个角色
     *
     *  多对多放弃维护全 ： 被动的一方放弃维护
     */

    @Test
    @Transactional
    @Rollback(false)
    public void testAdd(){
        User user = new User();
        user.setUserName("lisi");

        Role role = new Role();
        role.setRoleName("student");

        //配置用户到角色关系，可以对中间表中的数据进行维护  1-1
        role.getUsers().add(user);//二选一
        //配置用户到角色关系，可以对中间表中的数据进行维护  1-1
        user.getRoles().add(role);//二选一

        userDao.save(user);
        roleDao.save(role);
    }
}

可以看到结果有两条

级联添加

测试级联添加（保存一个用户的同时保存用户的关联角色）

在主体上添加

  @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)

测试

    /**
     * 测试级联添加（保存一个用户的同时保存用户的关联角色）
     */
    @Test
    @Transactional
    @Rollback(false)
    public void testCasCadeAdd(){
        User user = new User();
        user.setUserName("lisiCasCade");

        Role role = new Role();
        role.setRoleName("studentCasCade");

        //配置用户到角色关系，可以对中间表中的数据进行维护  1-1
//        role.getUsers().add(user);//二选一
        //配置用户到角色关系，可以对中间表中的数据进行维护  1-1
        user.getRoles().add(role);//二选一

        userDao.save(user);

    }

联级删除

    /**
     * 删除id 为3的用户，同时删除他的关联对象
     * 测试级联删除
     */
    @Test
    @Transactional
    @Rollback(false)
    public void testCasCadeDel(){
        //查询
        User user = userDao.findOne(3l);
        //删除
        userDao.delete(user);
    }

延迟加载

案例是客户和联系人

• 对象导航查询
  - 默认使用的是延迟加载的形式查询的
  - 调用get方法并不会立即发送查询，而是在使用关联对象的时候才会查询
  - 延迟加载
  修改配置，将延迟加载改为立即加载
  - fetch，需要配置到多表映射关系的注解上
  - EAGER ： 立即加载
  - LAZY ：延迟加载

findOne：本身是立即加载
getOne：本身是延迟加载

findOne : 默认懒加载，sql语句只查询一张表

getOne : 默认懒加载，sql语句只查询一张表

如果我想要立即加载呢？

需要在实体类上加

**fetch = FetchType.EAGER**

 @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL,**fetch = FetchType.EAGER**)

getOne : 加了立即加载后，查询了两张表

findOne : 加了立即加载后，查询了两张表

默认是不开启立即加载的

从多方查询一方数据

联系人是多，客户是一
图里面，从多里面查询一的出来，默认是使用立即加载的

findOne

getOne

开启延迟加载

在多的一方加 fetch = FetchType.LAZY

   @ManyToOne(targetEntity =  Customer.class,**fetch = FetchType.LAZY**)

查询一张表，这样就开启成功

运行

下一步

多表的查询总结

• 对象导航查询
  - 查询一个对象的同时，通过此对象查询他的关联对象
  - 案例：客户和联系人

  - 从一方查询多方
        - 默认：使用延迟加载 ： 
        - 如果一方只有一条数据，而多方是个**集合**有很多条数据，100条数据，1000条数据。如果只想查询一方的数据，不用查询多方，使用立即加载的话会立即查出所有的数据，这时就需要使用延时加载
  - 从多方查询一方
        - 默认：使用立即加载