SpringData高级应用之多表联合查询完整代码（一对一关系、一对多关系、多对多关系 + 避坑指南）

最新推荐文章于 2023-04-02 13:01:03 发布

熊凯瑞

最新推荐文章于 2023-04-02 13:01:03 发布

阅读量1k

点赞数

分类专栏： SpringData JPA框架文章标签：数据库 mysql java spring boot mybatis

本文链接：https://blog.csdn.net/qq_46106857/article/details/125978786

版权

SpringData JPA框架专栏收录该内容

3 篇文章 0 订阅

订阅专栏

SpringData JPA多表查询

1、基本概念

数据库中多表之间存在着三种关系，多对多，一对多，一对一。

2、步骤

（1）首先确定两张表之间的关系
（2）在实体类中描述两个实体的关系
（3）配置出实体类和数据库表的关系映射

3、一对一关系

3.1 实体类

3.1.1 Article类

package com.example.manytable.domain;

import lombok.Data;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

//表示这是一个实体类
@Entity
//使用注解建立实体类和数据表之间的关系
//@Table建立了实体类和数据表的关系   name指向表名
@Table(name = "article")
@Data
public class Article implements Serializable {
    //标识这是主键字段
    @Id
    //指定主键生成策略，GenerationType.IDENTITY就是对应到mysql中的数据自增策略
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer aid;

    //使用@Column映射类的属性和数据表的字段关系  name指定表中的字段名
    //当类的属性名和数据表的字段名一致时，此注解可以省略
    private String author;

    private Date createTime;

    private String title;


    //声明类间关系
    //声明主动放弃关系维护 mappedBy="当前类在对方类中的属性名"
    //当保存Article的时候，同时保存ArticleData
    @OneToOne(mappedBy = "article", cascade = CascadeType.PERSIST)
    private ArticleData articleData;

    //在类中使用注解再声明表间关系
    //--书写注解
    //--明确谁来维护关系(在多的一方维护关系)
    //----在维护的一方主动声明维护策略，在不维护的一方声明主动放弃

}

3.1.2 ArticleData类

package com.example.manytable.domain;

import lombok.Data;

import javax.persistence.*;

@Entity
@Table(name = "article_data")
@Data
public class ArticleData {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String content;

    //让这个实体维护关系
    /**
     * name                    当前表的外键名
     * referencedColumnName   指向的对方表中的主键名
     */
    @OneToOne
    @JoinColumn(name = "article_id", referencedColumnName = "aid",unique = true)
    private Article article;


}

3.2 测试类

package com.example.manytable;

import com.example.manytable.dao.ArticleDao;
import com.example.manytable.domain.Article;
import com.example.manytable.domain.ArticleData;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@SpringBootTest
class One2OneTest {

    @Autowired
    private ArticleDao articleDao;

    @Test
    public void testSave() {
        //创建文章对象
        Article article = new Article();
        article.setTitle("吃饭倍香");
        article.setAuthor("米老鼠");
        article.setCreateTime(new Date());

        //创建文章内容对象
        ArticleData articleData = new ArticleData();
        articleData.setContent("真是一篇好文章");

        //建立两个对象间的关系
        article.setArticleData(articleData);
        articleData.setArticle(article);

        //保存操作
        articleDao.save(article);

    }
}

4、一对多关系

4.1 实体类

4.1.1 Article类

package com.example.manytable.domain;

import lombok.Data;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

//表示这是一个实体类
@Entity
//使用注解建立实体类和数据表之间的关系
//@Table建立了实体类和数据表的关系   name指向表名
@Table(name = "article")
@Data
public class Article implements Serializable {
    //标识这是主键字段
    @Id
    //指定主键生成策略，GenerationType.IDENTITY就是对应到mysql中的数据自增策略
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer aid;

    //使用@Column映射类的属性和数据表的字段关系  name指定表中的字段名
    //当类的属性名和数据表的字段名一致时，此注解可以省略
    private String author;

    private Date createTime;

    private String title;

    @ManyToMany(mappedBy = "articles")
    private Set<Type> types = new HashSet<>(0);


    @OneToMany(mappedBy = "article", fetch = FetchType.LAZY)
    private Set<Comment> comments = new HashSet<>(0);

    //声明类间关系
    //声明主动放弃关系维护 mappedBy="当前类在对方类中的属性名"
    //当保存Article的时候，同时保存ArticleData
    @OneToOne(mappedBy = "article", cascade = CascadeType.PERSIST)
    private ArticleData articleData;

    //在类中使用注解再声明表间关系
    //--书写注解
    //--明确谁来维护关系(在多的一方维护关系)
    //----在维护的一方主动声明维护策略，在不维护的一方声明主动放弃

}

4.1.2 Comment类

package com.example.manytable.domain;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

import javax.persistence.*;
import java.io.Serializable;

//表示这是一个实体类
@Entity
//使用注解建立实体类和数据表之间的关系
//@Table建立了实体类和数据表的关系   name指向表名
@Table(name = "comment")
@Data
@ToString(exclude = {"article"})
@EqualsAndHashCode(exclude = {"article"})
public class Comment implements Serializable {
    //标识这是主键字段
    @Id
    //指定主键生成策略，GenerationType.IDENTITY就是对应到mysql中的数据自增策略
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer cid;

    //使用@Column映射类的属性和数据表的字段关系  name指定表中的字段名
    //当类的属性名和数据表的字段名一致时，此注解可以省略
    private String comment;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "aid", referencedColumnName = "aid")
    private Article article;

}

4.2 自定义接口

package com.example.manytable.dao;

import com.example.manytable.domain.Comment;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

//自定义接口需要继承JpaRepository<实体类的类型，实体类中的主键的类型>, JpaSpecificationExecutor<实体类的类型>
@Repository
public interface CommentDao extends JpaRepository<Comment, Integer>, JpaSpecificationExecutor<Comment> {

}

4.3 测试类

package com.example.manytable;

import com.example.manytable.dao.ArticleDao;
import com.example.manytable.dao.CommentDao;
import com.example.manytable.domain.Article;
import com.example.manytable.domain.ArticleData;
import com.example.manytable.domain.Comment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

@SpringBootTest
class One2ManyTest {

    @Autowired
    private ArticleDao articleDao;

    @Autowired
    private CommentDao commentDao;

    //保存
    @Test
    public void testSave() {
        //创建文章对象
        Article article = new Article();
        article.setTitle("吃饭");
        article.setAuthor("唐老鸭");
        article.setCreateTime(new Date());

        //创建文章内容对象
        Comment comment1 = new Comment();
        comment1.setComment("真不错");
        Comment comment2 = new Comment();
        comment2.setComment("挺好的");

        //建立两个对象间的关系
        comment1.setArticle(article);
        comment2.setArticle(article);

        Set<Comment> comments = new HashSet<>();
        comments.add(comment1);
        comments.add(comment2);
        article.setComments(comments);

        //保存操作
        articleDao.save(article);
        commentDao.save(comment1);
        commentDao.save(comment2);

    }
}

5、多对多关系

5.1 实体类

5.1.1 Article类

package com.example.manytable.domain;

import lombok.Data;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

//表示这是一个实体类
@Entity
//使用注解建立实体类和数据表之间的关系
//@Table建立了实体类和数据表的关系   name指向表名
@Table(name = "article")
@Data
public class Article implements Serializable {
    //标识这是主键字段
    @Id
    //指定主键生成策略，GenerationType.IDENTITY就是对应到mysql中的数据自增策略
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer aid;

    //使用@Column映射类的属性和数据表的字段关系  name指定表中的字段名
    //当类的属性名和数据表的字段名一致时，此注解可以省略
    private String author;

    private Date createTime;

    private String title;

    @ManyToMany(mappedBy = "articles")
    private Set<Type> types = new HashSet<>(0);


    @OneToMany(mappedBy = "article", fetch = FetchType.LAZY)
    private Set<Comment> comments = new HashSet<>(0);

    //声明类间关系
    //声明主动放弃关系维护 mappedBy="当前类在对方类中的属性名"
    //当保存Article的时候，同时保存ArticleData
    @OneToOne(mappedBy = "article", cascade = CascadeType.PERSIST)
    private ArticleData articleData;

    //在类中使用注解再声明表间关系
    //--书写注解
    //--明确谁来维护关系(在多的一方维护关系)
    //----在维护的一方主动声明维护策略，在不维护的一方声明主动放弃

}

5.1.2 Type类

package com.example.manytable.domain;

import lombok.Data;

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

@Entity
@Table(name = "type")
public class Type {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer tid;

    private String name;

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
            //代表中间表名称
            name = "article_type",
            //中间表的外键对应到当前表的主键名称
            joinColumns = {@JoinColumn(name = "tid", referencedColumnName = "tid")},
            //中间表的外键对应到对方表的主键名称
            inverseJoinColumns = {@JoinColumn(name = "aid", referencedColumnName = "aid")}
    )
    Set<Article> articles = new HashSet<>(0);

    public Integer getTid() {
        return tid;
    }

    public void setTid(Integer tid) {
        this.tid = tid;
    }

    public String getName() {
        return name;
    }

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

    public Set<Article> getArticles() {
        return articles;
    }

    public void setArticles(Set<Article> articles) {
        this.articles = articles;
    }

    @Override
    public String toString() {
        return "Type{" +
                "tid=" + tid +
                ", name='" + name + '\'' +
                ", articles=" + articles +
                '}';
    }
}

5.2 自定义接口

package com.example.manytable.dao;

import com.example.manytable.domain.Type;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

//自定义接口需要继承JpaRepository<实体类的类型，实体类中的主键的类型>, JpaSpecificationExecutor<实体类的类型>
@Repository
public interface TypeDao extends JpaRepository<Type, Integer>, JpaSpecificationExecutor<Type> {

}

5.3 测试类

package com.example.manytable;

import com.example.manytable.dao.ArticleDao;
import com.example.manytable.dao.CommentDao;
import com.example.manytable.dao.TypeDao;
import com.example.manytable.domain.Article;
import com.example.manytable.domain.Comment;
import com.example.manytable.domain.Type;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

@SpringBootTest
class Many2ManyTest {

    @Autowired
    private ArticleDao articleDao;

    @Autowired
    private TypeDao typeDao;

    //保存
    @Test
    public void testSave() {
        //创建文章对象
        Article article1 = new Article();
        article1.setTitle("文章1");
        article1.setAuthor("唐老鸭1");
        article1.setCreateTime(new Date());

        Article article2 = new Article();
        article2.setTitle("文章2");
        article2.setAuthor("唐老鸭2");
        article2.setCreateTime(new Date());

        //创建文章类型对象
        Type type1 = new Type();
        type1.setName("军事");
        Type type2 = new Type();
        type2.setName("民政");

        //建立两个对象间的关系
        Set<Type> types = new HashSet<>();
        types.add(type1);
        types.add(type2);
        article1.setTypes(types);
        article2.setTypes(types);

        Set<Article> articles = new HashSet<>();
        articles.add(article1);
        articles.add(article2);
        type1.setArticles(articles);
        type2.setArticles(articles);


        //保存操作
        articleDao.save(article1);
        articleDao.save(article2);
        typeDao.save(type1);
        typeDao.save(type2);

    }
}

6、注意

6.1 发现的问题

之所以一对一的表，我设计的两个实体类都加了@Data, 是因为不会报出堆栈错误。
其它的一对多和多对多的表，如果两个实体类都加了@Data，就都会爆出堆栈错误。

6.2 解决的办法

解决办法1：其中一个类用@Data注解，另一个类还是用get/set方法及toString方法的自动生成。
解决办法2：其中一个类用@Data注解，另一个类也用@Data注解，但还要用以下注解来规避问题。

@ToString(exclude = {"article"})
@EqualsAndHashCode(exclude= {"article"})

6.3 造成问题的原因

具体的原因，看网上一个大佬说：Java中打印对象实际上是调用对象的toString()方法，如果有对象A和B互相引用，调用A的toString()方法时需要打印B属性，就需要调用对象B的toString()，而对象B的toString()方法中又打印了对象A，就又去调用对象A的toString()，这样对象A和对象B的toString()方法反复调用，属于方法递归过深，导致了stackoverflow的错误。至于为什么会stackoverflow就需要看JVM的内存模型了。当然HashCode和Equals也会造成这样的问题。

熊凯瑞

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringData高级应用之多表联合查询完整代码（一对一关系、一对多关系、多对多关系 + 避坑指南）

数据库中多表之间存在着三种关系，多对多，一对多，一对一。接下来开始展示完整的代码，读懂代码，也可以实现多表查询功能。
复制链接

扫一扫