Springboot一对一和一对多 springdatajpa一对多查询

转载

数码悟透 2024-03-21 10:04:07

文章标签 Springboot一对一和一对多 spring Customer xml 文章分类 架构后端开发

1. Specifications动态查询

1.1JpaSpecificationExecutor 方法列表

T findOne(Specification spec); //查询单个对象
List findAll(Specification spec); //查询列表

//查询全部，分页
//pageable：分页参数
//返回值：分页pageBean（page：是springdatajpa提供的）

Page findAll(Specification spec, Pageable pageable);

//查询列表
//Sort：排序参数

List findAll(Specification spec, Sort sort);
long count(Specification spec);//统计查询

Specification ：查询条件
自定义我们自己的Specification实现类
实现

//root：查询的根对象（查询的任何属性都可以从根对象中获取）
//CriteriaQuery：顶层查询对象，自定义查询方式（了解：一般不用）
//CriteriaBuilder：查询的构造器，封装了很多的查询条件
Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb); //封装查询条件

1.2 查询单个客户过程演示

1.2.1 配置配置文件

<?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">

    <!-- 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.cui.domain"/>
        <!-- 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>

    </bean>

    <!-- 2.配置数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa"/>
    </bean>

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

    <!-- 4.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
     </bean>

    <!-- 5.声明式事务 -->

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

1.2.2 配置实体类

package com.cui.domain;

import javax.persistence.*;

/**
 *
 */

@Entity//声明实体类
@Table(name = "cst_customer")//建立实体类和表的映射关系
public class Customer {

    @Id//声明当前私有属性为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//配置主键的生成策略
    @Column(name = "cust_id")//指定和表中cust_id字段的映射关系
    private  Long custId;

    @Column(name = "cust_address")//指定和表中cust_address字段的映射关系
    private String custAddress;

    @Column(name = "cust_industry")//指定和表中cust_industry字段的映射关系
    private String custIndustry;

    @Column(name = "cust_level")//指定和表中cust_level字段的映射关系
    private String custLevel;

    @Column(name = "cust_name")//指定和表中cust_name字段的映射关系
    private String custName;

    @Column(name = "cust_phone")//指定和表中cust_phone字段的映射关系
    private String custPhone;

    @Column(name = "cust_source")//指定和表中cust_source字段的映射关系
    private String custSource;

    public Long getCustId() {
        return custId;
    }

    public void setCustId(Long custId) {
        this.custId = custId;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custAddress='" + custAddress + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custName='" + custName + '\'' +
                ", custPhone='" + custPhone + '\'' +
                ", custSource='" + custSource + '\'' +
                '}';
    }
}

1.2.3 测试代码

package com.cui.test;

import com.cui.dao.customerDao;
import com.cui.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.persistence.criteria.*;

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


    @Autowired
    private customerDao customerDao;

    /**
     * 根据条件，查询单个对象
     */
    @Test
    public void testSpec(){

        //匿名内部类
        /**
         * 自定义查询条件
         *      1. 实现Specification接口（提供泛型：查询的对象类型）
         *      2.实现toPredicate方法（构造查询条件）
         *      3.需要借助方法参数中的两个参数（
         *           root：获取需要查询的对象属性
         *           CriteriaQuery：构造查询条件的，内部封装了很多查询条件（模糊查询，精准匹配）
         *      ）
         *
         * 案例：根据客户名称查询，查询客户名为传智播客的客户
         *        查询条件
         *           1.查询方式
         *              cb对象
         *           2.比较属性的名称
         *              root对象
         */
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {

                //1.获取比较的属性
                Path<Object> custName = root.get("custName");
                //2.构造查询条件   select * from cst_customer where cust_name = "蠢逼红"
                /**
                 * 第一个参数：需要比较的属性（path对象）
                 * 第二个参数：当前需要比较的取值
                 */
                Predicate pd = criteriaBuilder.equal(custName, "臭傻红");//进行精准的匹配  （比较的属性，比较属性的取值）
                return pd;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);
    }
}

1.3 测试多条件查询

1.3.1 代码实现

/**
     * 多条件查询
     *      案例：根据客户名 （蠢逼红）和客户所属行业（二笔）查询客户信息
     */
    @Test
    public void testSpec1(){

        /**
         * root： 获取属性
         *        客户名
         *        所属行业
         * cb：   构造查询
         *          1.构造客户名的精准匹配查询
         *          2.构造所属行业的精准匹配查询
         *          3.将以上两个查询联系起来
         *
         */
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Path<Object> custName = root.get("custName");//客户名
                Path<Object> custIndustry = root.get("custIndustry");//所属行业
                //1.构造客户姓名的精准匹配查询
                Predicate predicate1 = criteriaBuilder.equal(custName, "蠢逼红");
                //2.构造客户所属行业的精准匹配查询
                Predicate predicate2 = criteriaBuilder.equal(custIndustry, "二笔");
                //将多个查询条件组合到一起，组合（满足条件一且满足条件二，且关系，满足条件一或满足条年二，或关系）
                Predicate p = criteriaBuilder.and(predicate1, predicate2);//以与的形式拼接多个条件
//criteriaBuilder.or();//以获的形式拼接多个查询条件
                return p;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);

    }

1.4 模糊匹配查询

1.4.1 代码实现

* 案例：完成客户名称的模糊匹配，返回客户列表
     *     客户名称以"蠢逼"开头
     *
     * equals :直接得到path对象（属性），然后进行比较即可
     *
     * gt，lt，ge，le，like： 得到path对象，根据path指定比较的参数类型，在去进行比较
     *      指定参数类型：path.as（类型的字节码对象）
     */

    @Test
    public void testSpect3(){

        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //查询属性：客户名
                Path<Object> custName = root.get("custName");
                //查询方式：模糊查询
                Predicate p = criteriaBuilder.like(custName.as(String.class), "蠢逼%");
                return p;
            }
        };
        List<Customer> list = customerDao.findAll(spec);
        for (Customer customer : list){
            System.out.println(customer);
        }
    }

1.4.2 排序

/**
     * 案例：完成客户名称的模糊匹配，返回客户列表
     *     客户名称以"蠢逼"开头
     *
     * equals :直接得到path对象（属性），然后进行比较即可
     *
     * gt，lt，ge，le，like： 得到path对象，根据path指定比较的参数类型，在去进行比较
     *      指定参数类型：path.as（类型的字节码对象）
     */

    @Test
    public void testSpect3(){

        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //查询属性：客户名
                Path<Object> custName = root.get("custName");
                //查询方式：模糊查询
                Predicate p = criteriaBuilder.like(custName.as(String.class), "蠢逼%");
                return p;
            }
        };

       /* List<Customer> list = customerDao.findAll(spec);
        for (Customer customer : list){
            System.out.println(customer);
        }*/

        //添加排序
        // 创建排序对象，需要调用构造方法实例化sort对象
        //第一个参数：排序的顺序（倒叙，正序）
        //   Sort.Direction.Desc:倒叙
        //   Sort.Direction.Asc：升序
        //第二个参数：配许的属性名称
        Sort sort = new Sort(Sort.Direction.DESC,"custId");
        List<Customer> list = customerDao.findAll(spec, sort);
        list.stream().forEach(a-> System.out.println(a));
    }

1.4.3 分页

/**
     * 分页查询
     *
     *    Specification:查询条件
     *    Pageable:分页参数
     *        分页参数：查询的页码，每页查询的条数
     *        findAll（Specification，Pageable），带有条件的分页
     *        findAll(PageAble)：没有条件的分页
     * 返回：Page （springDataJpa）为我们封装好的paageBean对象，数据列表，总条数
     */
    @Test
    public void testSpec4(){
        Specification spec = new Specification() {
            @Override
            public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //查询属性：客户名
                Path<Object> custName = root.get("custName");
                //查询方式：模糊查询
                Predicate p = criteriaBuilder.like(custName.as(String.class), "蠢逼%");
                return p;
            }
        };
        //pageRequest对象是pageAble的接口的实现类
        /**
         * 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
         *           第一个参数：当前的查询页数（从0开始）
         *           第二个参数：每页的查询数量
         */
        Pageable pageable = new PageRequest(0,2);

        Page all = customerDao.findAll(spec, pageable);
        System.out.println(all.getContent());//得到数据集合列表
        System.out.println(all.getTotalElements());//得到总条数
        System.out.println(all.getTotalPages());//得到总页数
    }

2.多表之间的操作和操作多表的步骤

2.1 过程分析

注解分析：

@OneToMany:
   	作用：建立一对多的关系映射
    属性：
    	targetEntityClass：指定多的多方的类的字节码
    	mappedBy：指定从表实体类中引用主表对象的名称。
    	cascade：指定要使用的级联操作
    	fetch：指定是否采用延迟加载
    	orphanRemoval：是否使用孤儿删除

@ManyToOne
    作用：建立多对一的关系
    属性：
    	targetEntityClass：指定一的一方实体类字节码
    	cascade：指定要使用的级联操作
    	fetch：指定是否采用延迟加载
    	optional：关联是否可选。如果设置为false，则必须始终存在非空关系。

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

第一、多表之间的关系和操作多表的操作步骤

表关系
	一对一
	一对多：
		一的一方：主表
		多的一方：从表
		外键：需要再从表上新建一列作为外键，他的取值来源于主表的主键
	多对多：
		中间表：中间表中最少应该由两个字段组成，这两个字段做为外键指向两张表的主键，又组成了联合主键

讲师对学员：一对多关系
		
实体类中的关系
	包含关系：可以通过实体类中的包含关系描述表关系
	继承关系

分析步骤
	1.明确表关系
	2.确定表关系（描述 外键|中间表）
	3.编写实体类，再实体类中描述表关系（包含关系）
	4.配置映射关系

第二完成多表操作

i.一对多操作
	案例：客户和联系人的案例（一对多关系）
		客户：一家公司
		联系人：这家公司的员工
	
		一个客户可以具有多个联系人
		一个联系人从属于一家公司
		
	分析步骤
		1.明确表关系
			一对多关系
		2.确定表关系（描述 外键|中间表）
			主表：客户表
			从表：联系人表
				* 再从表上添加外键
		3.编写实体类，再实体类中描述表关系（包含关系）
			客户：再客户的实体类中包含一个联系人的集合
			联系人：在联系人的实体类中包含一个客户的对象
		4.配置映射关系
			* 使用jpa注解配置一对多映射关系

	级联：
		操作一个对象的同时操作他的关联对象
		
		级联操作：
			1.需要区分操作主体
			2.需要在操作主体的实体类上，添加级联属性（需要添加到多表映射关系的注解上）
			3.cascade（配置级联）
		
		级联添加，
			案例：当我保存一个客户的同时保存联系人
		级联删除
			案例：当我删除一个客户的同时删除此客户的所有联系人
			
ii.多对多操作
	案例：用户和角色（多对多关系）
		用户：
		角色：

	分析步骤
		1.明确表关系
			多对多关系
		2.确定表关系（描述 外键|中间表）
			中间间表
		3.编写实体类，再实体类中描述表关系（包含关系）
			用户：包含角色的集合
			角色：包含用户的集合
		4.配置映射关系
		
iii.多表的查询
	1.对象导航查询
		查询一个对象的同时，通过此对象查询他的关联对象
		
		案例：客户和联系人
		
		从一方查询多方
			* 默认：使用延迟加载（****）
			
		从多方查询一方
			* 默认：使用立即加载

2.2 创建数据库

/*创建客户表*/
CREATE TABLE cst_customer (
  cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
  cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
  cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=94 DEFAULT CHARSET=utf8;

/*创建联系人表*/
CREATE TABLE cst_linkman (
  lkm_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
  lkm_name varchar(16) DEFAULT NULL COMMENT '联系人姓名',
  lkm_gender char(1) DEFAULT NULL COMMENT '联系人性别',
  lkm_phone varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
  lkm_mobile varchar(16) DEFAULT NULL COMMENT '联系人手机',
  lkm_email varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
  lkm_position varchar(16) DEFAULT NULL COMMENT '联系人职位',
  lkm_memo varchar(512) DEFAULT NULL COMMENT '联系人备注',
  lkm_cust_id bigint(32) NOT NULL COMMENT '客户id(外键)',
  PRIMARY KEY (`lkm_id`),
  KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

2.3 配置文件

<?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">

    <!-- 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.cui.domain"/>
        <!-- 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.hbm2dd.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 name="password" value="123456"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa"/>
    </bean>

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

    <!-- 4.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
     </bean>

    <!-- 5.声明式事务 -->

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

2.3 配置实体类

package com.cui.dao;

import com.cui.domain.LinkMan;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

/**
 * @创建人 cxp
 * @创建时间 2019-10-11
 * @描述
 */
public interface LinkManDao extends JpaSpecificationExecutor<LinkMan>,JpaRepository<LinkMan,Long>{

}

测试代码

package com.cui.test;

import com.cui.dao.LinkManDao;
import com.cui.dao.customerDao;
import com.cui.domain.Customer;
import com.cui.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

/**
 * @创建人 cxp
 * @创建时间 2019-10-11
 * @描述
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {

    @Autowired
    private customerDao customerDao;

    @Autowired
    private LinkManDao linkManDao;

    /**
     * 保存一个客户，保存一个联系人
     */
    @Test
    @Transactional //配置事务
    @Rollback(value = false)  //设置不自动回滚
    public void testAdd(){
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("小王");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("老王");

        customer.getLinkMan().add(linkMan);
        customerDao.save(customer);

        linkManDao.save(linkMan);

    }

}

放弃外键维护的操作
/**

放弃外键维护权

mapperBy:对方配置关系的属性名称

2.4 级联操作

删除操作的说明如下：
删除从表数据：可以随时任意删除。

删除主表数据：

 有从表数据

在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表结构上，外键字段有非空约束，默认情况就会报错了。
如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null，没有关系）因为在删除时，它根本不会去更新从表的外键字段了。
如果还想删除，使用级联删除引用

 没有从表数据引用：随便删

在实际开发中，级联删除请慎用！(在一对多的情况下)

级联操作的配置

@OneToMany(mappedBy = “customer”,cascade = CascadeType.ALL)
cascade: 配置级联（可以配置到多表的映射关系的注解上）
* CascadeType. ALL ：所有
* MERGE : 更新
* PERSIST: 保存
* REMOVE : 删除

测试级联添加

/**
     * 级联添加，保存一个客户的同时，保存客户的联系人
     *
     *      需要在操作肢体的实体类上配置cascade属性
     */
    @Test
    @Transactional //配置事务
    @Rollback(value = false)  //设置不自动回滚
    public void testCascadeAdd(){

        Customer customer = new Customer();
        customer.setCustName("小王2");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("老王2");

        customer.getLinkMan().add(linkMan);
        customerDao.save(customer);
    }

测试级联删除

/**
     * 级联删除，保存一个客户的同时，保存客户的联系人
     *
     *      需要在操作肢体的实体类上配置cascade属性
     */
    @Test
    @Transactional //配置事务
    @Rollback(value = false)  //设置不自动回滚
    public  void testCascadeRemove(){
        //1.查询出客户

        Customer customer = customerDao.findOne(19l);
        //2.删除该客户
        customerDao.delete(customer);
    }

3. 完成多表操作

3.1 配置文件

<?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">

    <!-- 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.cui.domain"/>
        <!-- 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.hbm2dd.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 name="password" value="123456"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa"/>
    </bean>

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

    <!-- 4.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
     </bean>

    <!-- 5.声明式事务 -->

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

3.2 配置实体类----User

package com.cui.domain;

import javax.naming.Name;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

/**
 * @创建人 cxp
 * @创建时间 2019-10-11
 * @描述
 */
@Entity
@Table(name = "sys_user")
public class User {

    @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;


    /**
     * 配置用户到角色的多对多的关系
     *      配置多对多的映射关系
     *         1. 声明表关系的配置
     *         @ManyToMany (targetEntity = Role.class) //多对多
     *             targetEntity；代表对方的实体类字节码
     *         2.配置中间表（包含两个外键）
     *            @joinTable
     *               name:中间表的名称
     *               joinColumns:配置当前对象在中间表的外键
     *                 @JOinColumn的数组
     *                    name：外键名
     *                    referencedColumnName：参照的主键
     *                    @joinColumn的数组
     *                      name：外键名
     *                      referencedColumnName：配置对方对象在中间表奥的外键
     *
     */
    @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
    @JoinTable(name = "sys_user_role",
            //joinColumns,当前对象在中间表的外键
            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<>();

    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<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userCode='" + userCode + '\'' +
                ", userName='" + userName + '\'' +
                ", userPassword='" + userPassword + '\'' +
                ", userState='" + userState + '\'' +
                ", roles=" + roles +
                '}';
    }
}

配置实体类 ----Role

package com.cui.domain;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

/**
 * @创建人 cxp
 * @创建时间 2019-10-11
 * @描述
 */

@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;
    @Column(name="role_memo")
    private String roleMemo;

    //配置多对多
    @ManyToMany(targetEntity = User.class,cascade = CascadeType.ALL)
    @JoinTable(name = "sys_user_role",
            //joinColumns,当前对象在中间表的外键
            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<>();//配置多表关系


    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<User> getUsers() {
        return users;
    }

    public void setUsers(Set<User> users) {
        this.users = users;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleMemo='" + roleMemo + '\'' +
                ", users=" + users +
                '}';
    }
}

ps:多对多放弃维护权，被动的一方放弃

/* //配置多对多
 @ManyToMany(targetEntity = User.class,cascade = CascadeType.ALL)
 @JoinTable(name = “sys_user_role”,
 //joinColumns,当前对象在中间表的外键
 joinColumns = {@JoinColumn(name = “sys_role_id”,referencedColumnName = “role_id”)},
 //inverseJoinColumns,对方对象在中间表的外键
 inverseJoinColumns = {@JoinColumn(name = “sys_user_id”,referencedColumnName = “user_id”)}
 )*/

@ManyToMany(mappedBy = “roles”)
将上面的配置改为标注出即可

ps:级联的设置

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

对象导航查询

iii.多表的查询
1.对象导航查询
查询一个对象的同时，通过此对象查询他的关联对象

案例：客户和联系人

从一方查询多方
* 默认：使用延迟加载（****）
从多方查询一方
* 默认：使用立即加载
从一方查询多方

package com.cui.test;

import com.cui.dao.LinkManDao;
import com.cui.dao.customerDao;
import com.cui.domain.Customer;
import com.cui.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.Set;

/**
 * @创建人 cxp
 * @创建时间 2019-10-11
 * @描述
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ObjectQueryTest {

    @Autowired
    private customerDao customerDao;

    @Autowired
    private LinkManDao linkManDao;

    /**
     * 测试对象导航查询（查询一个对象的时候，通过此对象查询所有的关联对象）
     */
    @Test
    @Transactional//解决java代码中的no session问题
    public void testQuery(){

        //查询id为22的客户
        Customer customer = customerDao.getOne(22l);
        //对象导航查询，此客户下的所有联系人
        Set<LinkMan> linkMans = customer.getLinkMan();
        for(LinkMan linkMan : linkMans){
            System.out.println(linkMan);
        }
    }
}

从多方查询一方

/**
     * 测试对象导航查询（查询一个联系人的时候，查询出对应的客户）
     *           * 默认：立即加载
     *         延迟加载：
     */
    @Test
    @Transactional//解决java代码中的no session问题
    public void testQuery2(){

        //查询id为4的联系人
        LinkMan linkMan = linkManDao.findOne(4l);
        Customer customer = linkMan.getCustomer();
        //对象导航查询，此联系人对应的客户
        System.out.println(customer);

    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。