springDataJpa——多表

最新推荐文章于 2022-09-24 10:40:41 发布
最新推荐文章于 2022-09-24 10:40:41 发布
阅读量172 收藏
点赞数
分类专栏： java 文章标签： jpa springDataJpa java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44132240/article/details/103315549
版权

一、环境搭建

springDataJpa的基本环境搭建在上篇已经讲到，这里不再赘述。环境配置具体链接如下springDataJpa环境搭建

二、OneToMany

1、实体类

这里我们以一个父亲与儿子的关系为例描述一对多，创建的实体类如下

1.1、Father类
package com.xsl.entity;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
//@Entity注解声明这个是一个对应表的有实体
@Entity
//@Table创建表，指定表名
@Table(name = "father")
public class Father {
	//@Id主键
    @Id
    // @GeneratedValue主键生成策略，这里使用的mysql所以自增
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    //@Column字段与数据库表列映射
    @Column(name = "fid")
    Long fid;
    @Column(name = "name")
    String name;
//一的一方放弃外键的维护权
//    @OneToMany(targetEntity = Son.class)
//    @JoinColumn(name = "s_fid",referencedColumnName = "fid")
    @OneToMany(mappedBy = "father",cascade = CascadeType.ALL)//mappedBy放弃维护权，cascade：设置级联
    private Set<Son> sons = new HashSet<>();

//以下为构造器、getter、setter、toString方法
    public Set<Son> getSons() {
        return sons;
    }

    public void setSons(Set<Son> sons) {
        this.sons = sons;
    }

    public Father(Long fid ,String name) {
        this.fid = fid;
        this.name = name;
    }

    public Father() {
    }

    public Father(String name) {
        this.name = name;
    }

    public Long getFid() {
        return fid;
    }

    public void setFid(Long fid) {
        this.fid = fid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Father{" +
                "fid=" + fid +
                ", name='" + name + '\'' +
                '}';
    }
}
1.2、Son类
package com.xsl.entity;

import javax.persistence.*;

@Entity
@Table(name = "son")
public class Son {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "sid")
    private Long sid;
    @Column(name = "name")
    private String name;
	//维护关系，targetEntity指对方的字节码
    @ManyToOne(targetEntity = Father.class)
    //referencedColumnName指的是依照的主要列的字段名
    @JoinColumn(name = "s_fid",referencedColumnName = "fid")
    private Father father;

    public Father getFather() {
        return father;
    }

    public void setFather(Father father) {
        this.father = father;
    }

    public Son(Long sid, String name) {
        this.sid = sid;
        this.name = name;
    }

    public Son(String name) {
        this.name = name;
    }

    public Son() {
    }

    public Long getSid() {
        return sid;
    }

    public void setSid(Long sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Son{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                '}';
    }
}
2、DAO层

DAO层定义两个接口，继承JpaRepository<K,T>,JpaSpecificationExecutor<K,T>即可

3、测试
package com.xsl.test;

import com.xsl.dao.FatherDao;
import com.xsl.dao.SonDao;
import com.xsl.entity.Father;
import com.xsl.entity.Son;
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;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ManyTableTest {

    @Autowired
    private FatherDao fatherDao;

    @Autowired
    private SonDao sonDao;

    /**
     * 多表
     */
    @Test
    //多表要添加事务保证connection是同一个
    @Transactional
    //不要自动回滚
    @Rollback(false)
    public void test(){
        Father father = new Father("肖生亮");
        Son son = new Son("肖生亮的儿子");
        son.setFather(father);
        fatherDao.save(father);
        sonDao.save(son);
    }

    /**
     * 级联添加
     */
    @Test
    @Transactional
    @Rollback(false)
    public void testCascadeAdd(){
        Father father = new Father("肖生亮");
        Son son = new Son("肖生亮的儿子");
        son.setFather(father);
        father.getSons().add(son);
        fatherDao.save(father);
    }

    @Test
    @Transactional
    @Rollback(false)
    public void testCascadeDelete(){
        Father one = fatherDao.findOne(5l);
        fatherDao.delete(one);
    }

}

二、ManyToMany

1、实体类

这里我们以一个学生与老师的关系为例描述多对多，创建的实体类如下

1.1、Teacher类
package com.xsl.entity;

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

@Entity
@Table(name="teacher")
public class Teacher {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Column(name = "name")
    private String name;
//放弃维护权
//    @ManyToMany(targetEntity = Student.class)
//多对多其实是增加一个表来维护两实体的关系
//    @JoinTable(
//            name = "sys_tea_stu",joinColumns =
//            //当前表在中间表中的键，两张表各取一个字段作为联合主键
//            {@JoinColumn(name = "sys_tea_id",referencedColumnName = "id")},
//            //对方对象在中间表的键
//            inverseJoinColumns = {@JoinColumn(name = "sys_stu_id",referencedColumnName = "id")}
//    )
    @ManyToMany(mappedBy = "teachers")
    private Set<Student> students = new HashSet<>();

    public Teacher() {
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Teacher(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Teacher(String name) {
        this.name = name;
    }
}
1.2、Student类
package com.xsl.entity;

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

@Entity
@Table(name = "student")
public class Student {
    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "name")
    private String name;

    @ManyToMany(targetEntity = Teacher.class,cascade = CascadeType.ALL)
    @JoinTable(
            name = "sys_tea_stu",joinColumns =
            //当前表在中间表中的外键
            {@JoinColumn(name = "sys_stu_id",referencedColumnName = "id")},
            //对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_tea_id",referencedColumnName = "id")}
            )
    private Set<Teacher> teachers = new HashSet<>();

    public Student() {
    }

    public Set<Teacher> getTeachers() {
        return teachers;
    }

    public void setTeachers(Set<Teacher> teachers) {
        this.teachers = teachers;
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
2、DAO层

DAO层定义两个接口，继承JpaRepository<K,T>,JpaSpecificationExecutor<K,T>即可

3、测试
package com.xsl.test;

import com.xsl.dao.StudentDao;
import com.xsl.dao.TeacherDao;
import com.xsl.entity.Student;
import com.xsl.entity.Teacher;
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;

import java.util.Set;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ManyToManyTest {

    @Autowired
    private StudentDao studentDao;
    @Autowired
    private TeacherDao teacherDao;

    @Test
    @Transactional
    @Rollback(false)
    public void test(){
        Student student = new Student("肖生亮");
        Teacher teacher = new Teacher("钱小红");
        //如果两方都有维护权，两方都添加，会报异常（主键冲突）
        student.getTeachers().add(teacher);
        studentDao.save(student);
    }

    @Test
    @Transactional
    @Rollback(false)
    public void testCascadeDelete(){
        //cascade操作会把级联的两个关系和中间表一起删掉，慎用
        Student one = studentDao.findOne(4l);
        studentDao.delete(one);
    }

    /**
     * 测试对象导航查询
     */
    @Test
    @Transactional
    @Rollback(false)
    public void testSelect(){
        Student one = studentDao.getOne(3l);
        Set<Teacher> teachers = one.getTeachers();
        for (Teacher tea :
                teachers) {
            Set<Student> students = tea.getStudents();
            System.out.println(students);
        }


    }

}
围城_危城
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【原创】纯干货，Spring-data-jpa详解，全方位介绍。
weixin_33955681的博客
02-01 7703
本篇进行Spring-data-jpa的介绍，几乎涵盖该框架的所有方面，在日常的开发当中，基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用，所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门，百度一下，很多入门的介绍。在这篇文章的接下来一篇，会有一个系列来讲解mybatis，这个系列从mybatis的入门开始，到基本使用，和spring整合，和第...
Spring Data JPA之自动创建数据库表demo
11-19
demo为spring boot项目 环境： 目前的程序环境是spring boot项目，JDK8.0，MySQL Connector / J 8.0（8.0版本支持java8及其以上的版本，支持5.6、5.7、8.0版本的mysql数据库，支持4.2版本的jdbc）。 如何使用： 只...
Spring Data JPA 实现多表操作
龙源IT 的博客
12-02 3581
数据库中表与表之间存在着三种关系：多对多、一对多(多对一)和一对一关系。在实际开发中，我们数据库的表与表之间难免会产生联系，在操作表的时候就有可能会涉及到多张表的操作。而在这种实现了ORM思想的框架中（如JPA），可以让我们通过操作实体类就实现对数据库表的操作，实现实体之间的关联关系。
Spring Data JPA多表操作(5)
weixin_39248420的博客
12-01 719
Spring Data JPA多表操作(5) 数据库中多表之间的关系 多对多 一对多 一对一 数据库设计示例 实体示例 客户：指的是一家公司，我们记为A。 联系人：指的是A公司中的员工。 在不考虑兼职的情况下，公司和员工的关系即为一对多。 表设计示例 实体类关系设计 客户（公司）类（一） @Entity//表示当前类是一个实体类 @Table(name="cst_custom...
SpringData JPA 多表关联操作 （四）
qq_50909707的博客
09-24 1283
本章节在案例（二）的基础上进行。
Spring Data JPA多表查询的几种方法
q990609179的博客
11-29 1万+
Spring Data JPA多表查询的几种方法 前言 公司目前在ORM框架上选型只有两个选择 MyBatis-Plus Spring Data JPA 相信很多人会选择MyBatis-Plus（MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生）,主要因为JPA对多表复杂查询很不友好，特别是现在建表...
spring -data-jpa-crud
11-20
demo为spring boot项目 环境： 目前的程序环境是spring boot项目，JDK8.0，MySQL Connector / J 8.0（8.0版本支持java8及其以上的版本，支持5.6...Spring Data JPA 自动提供CRUD的实现，能够部分解放工程师们的工作量。
Spring Data JPA中文文档[1.4.3]
10-18
Spring Data JPA中文文档[1.4.3]，带有书签目录。。。
Spring Data JPA系列4——Spring声明式事务处理与多数据源支持.doc
07-13
Spring Data JPA系列4——Spring声明式事务处理与多数据源支持.doc
zo-spring-boot:从零到一 —— 将一些有趣的技术方案与 Spring Boot 集成（如 Shiro、Spring Data JPA、Spring MVC、Tiles、Thymeleaf、Bootstrap 等）
06-02
zo-spring-bootFrom zero to one with Spring Boot###roadmap权限:Shiro (Done)UI:SB Admin 2(Based of Bootstrap 3) (TODO)数据库:hsqldb (Done)持久化:Spring Data JPA (Done)MVC:Spring MVC (Done)Template ...
Spring Data Jpa 复杂查询总结 (多表关联 以及 自定义分页 )
热门推荐
ZhuPengWei_
05-13 6万+
只是做一个总结所以就不多说废话了 实体类 @Entity @Table(name = &amp;quot;t_hotel&amp;quot;) @Data public class THotel { @Id private int id; private String name; private String address; /** * 城市id */ p...
Spring Jpa多表查询
穿越清华
12-14 3985
Spring Jpa多表查询 1.创建两个Entity,SysUserEntity 和SysUserPointEntity，代码如下 //SysUserEntity @Entity(name = "SysUser") @Table(name = "SysUser") public class SysUserEntity implements Seriali...
Spring JPA的多表查询
lm2574866671的博客
09-01 254
SpringBoot JPA的多表查询 1.关系映射 单项多对一关联 我们以User和Role表为例 修改User实体类,添加Role对象 @ManyToOne注解映射多对一关联,targetEntity属性表示关联实体类型,可以省略 @JoinColumn注解映射的外键字段,如果不指定,则生成一张新表维护两个对象之间的关系 2.创建UserRepository接口 3.编写测试类即可 4.双向一对多关联 ●targetEntity属性表示关联的实体类型 ●feteh 属性表示加载策略，Fetch
Spring data jpa 多表查询（二:多表动态条件查询）
jun522450654的专栏
07-21 8943
上一章说完单表动态条件查询，这章就说下多表关联查询 1、先说一对多关系，就以上一章的A模型和B模型，为例 A 对应 多个 B，而现在需求就是查询A和B关联，并需要传入的动态参数，可能是A模型中的属性，也有可能是B模型中的参数 还是用伪代码来说明，并且用的是Specification来查询（上一章有说明） public Page findA(Pageable pageable
SpringBoot JPA 表关联查询
林老师带你学编程
11-03 5万+
今天给大家介绍一下如何利用JPA实现表关联查询。 今天给大家举一个一对多的关联查询，并且是使用JPA原生的findBy语句实现的。 想学习分布式、微服务、JVM、多线程、架构、java、python的童鞋，千万不要扫码，否则后果自负~ 例子中总共有两个实体类，一个是Floor（商品楼层类），另一个是FloorContent（商品楼层内容表）。下面看两张表的源代码： Floor类： ...
SpringBoot + JPA的自学之路（三）多表连接查询
BigpotR
12-20 1万+
上一节分享了一下JPA的基本操作，但是有时候这些基本操作并不能满足业务的需求，用惯了Mybatis的我觉得多表查询也是挺容易的一件事情，不用修改实体，自己写sql非常的灵活也非常的方便，但是在JPA中要实现多表查询就稍微麻烦一点，需要对实体进行修改，加上一些注解表示与其他实体的关联关系(一对一、一对多、多对一，多对多)，下面我们就通过例子来讲解一下。 现在我们假设有这样的一个需求：查询一个用户列...
Spring Data JPA连接数据库详细步骤
最新发布
04-09
您好！连接数据库需要进行以下几个步骤： 1. 添加相关依赖，包括spring-boot-starter-data-jpa、mysql-connector-java等； 2. 在application.properties文件中配置数据库相关信息，如数据库地址、用户名、密码等； 3. 创建实体类，并使用JPA注解标记相关属性； 4. 创建继承JpaRepository的接口，可以直接使用其中提供的方法进行数据访问。 希望以上信息能够对您有所帮助。如果您有其它问题，也可以随时提出哦！另外，为了解除尴尬，让我们来讲个笑话吧：什么牌子的糖果最爱哭？——黑人牙膏。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值