第6章 Spring Boot的数据访问一、Spring Data JPA（3、关联查询）

最新推荐文章于 2022-12-10 16:39:28 发布

ASAYI

最新推荐文章于 2022-12-10 16:39:28 发布

阅读量270

点赞数

分类专栏：我的spring学习之路文章标签： java 数据库 jpa mysql

本文链接：https://blog.csdn.net/weixin_43820675/article/details/113785276

版权

我的spring学习之路专栏收录该内容

10 篇文章 1 订阅

订阅专栏

学习目标：

一、Spring Data JPA（3、关联查询）

学习内容：

在Spring Data JPA中有一对一、一对多、多对多等关系映射。

1．@OneToOne

一对一关系，在现实生活中是十分常见的。比如一个大学生只有一张一卡通，一张一卡通只属于一个大学生。再比如人与身份证的关系也是一对一的关系。

在Spring Data JPA中，可用两种方式描述一对一关系映射。一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键)；一种是通过一张关联表来保存两个实体一对一的关系。下面我们通过外键的方式讲解一对一关系映射。

【例6-2】使用Spring Data JPA实现人与身份证的一对一关系映射。

首先，为【例6-2】创建基于Spring Data JPA的Spring Boot Web应用ch6_2。ch6_2应用的数据库、pom.xml以及application.properties与ch6_1应用基本一样，不再赘述。
其他内容具体实现步骤如下。
1）创建持久化实体类

创建名为com.ch.ch6_2.entity的包，并在该包中创建名为Person和IdCard的持久化实体类。

在这里插入图片描述

Person的具体代码如下：

package com.ch.ch6_2.entity;

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@Entity
@Table(name="person_table")
/**解决No serializer found for class org.hibernate.proxy.pojo.bytebuddy.ByteBuddyInterceptor*/
@JsonIgnoreProperties(value = { "hibernateLazyInitializer"})
public class Person implements Serializable{
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;//自动递增的主键
	private String pname;
	private String psex;
	private int page;
	@OneToOne(
			optional = true, 
			fetch = FetchType.LAZY, 
			targetEntity = IdCard.class, 
			cascade = CascadeType.ALL
			)
	/**
	 *指明Person对应表的id_Card_id列作为外键与IdCard对应表的id列进行关联
	 * unique= true 指明id_Card_id 列的值不可重复
	 */
	@JoinColumn(
			name = "id_Card_id",
			referencedColumnName = "id",
			unique= true
			)
	@JsonIgnore//如果A对象持有B的引用，B对象持有A的引用，这样就形成了循环引用，如果直接使用json转换会报错
	private IdCard idCard;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	public String getPsex() {
		return psex;
	}
	public void setPsex(String psex) {
		this.psex = psex;
	}
	public int getPage() {
		return page;
	}
	public void setPage(int page) {
		this.page = page;
	}
	public IdCard getIdCard() {
		return idCard;
	}
	public void setIdCard(IdCard idCard) {
		this.idCard = idCard;
	}
}

上述实体类Person中，@OneToOne注解有5个属性：targetEntity、cascade、fetch、optional和mappedBy。

targetEntity属性：class类型属性。定义关系类的类型，默认是该成员属性对应的类类型，所有通常不需要提供定义。

cascade属性：CascadeType[ ]类型。该属性定义类和类之间的级联关系。定义的级联关系将被容器视为对当前类对象及其关联类对象采取相同的操作，而且这种关系是递归调用的。cascade的值只能从CascadeType.PERSIST（级联新建）、CascadeType.REMOVE（级联删除）、CascadeType.REFRESH（级联刷新）CascadeType.MERGE（级联更新）中选择一个或多个。还有一个选择是使用CascadeType.ALL：表示选择全部四项。

fetch属性：分为两种。FetchType.LAZY：懒加载，加载一个实体时，定义懒加载的属性不会立即从数据库中加载。FetchType.EAGER：急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。

optional属性：optional=true，表示idCard属性可以为null，也就是允许没有身份证，如未成年人没有身份证。

mappedBy属性：mappedBy标签一定是定义在关系的被维护端，它指向关系的维护端；只有@OneToOne、@OneToMany、@ManyToMany才有mappedBy属性，ManyToOne不存在该属性，拥有mappedBy注解的实体类为关系的被维护端。

IdCard的代码如下：

package com.ch.ch6_2.entity;
import java.io.Serializable;
import java.util.Calendar;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@Entity
@Table(name = "idcard_table")
@JsonIgnoreProperties(value = { "hibernateLazyInitializer"})
public class IdCard implements Serializable{
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;//自动递增的主键
	private String code;
	/**
	 * @Temporal主要是用来指明java.util.Date 或 java.util.Calendar 类型的属性具体
	 * 与数据库（date、time、timestamp）三个类型中的那一个进行映射
	 */
	@Temporal(value = TemporalType.DATE)
	private Calendar birthday;
	private String address;
	/**
	 * optional = false设置person属性值不能为null，也就是身份证必须有对应的主人。
	 * mappedBy = "idCard"与Person类中的idCard属性一致
	 */
	@OneToOne(
			optional = false, 
			fetch = FetchType.LAZY, 
			targetEntity = Person.class, 
			mappedBy = "idCard", 
			cascade = CascadeType.ALL
			)
	private Person person;//对应的人
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getCode() {
		return code;
	}
	public void setCode(String code) {
		this.code = code;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public Calendar getBirthday() {
		return birthday;
	}
	public void setBirthday(Calendar birthday) {
		this.birthday = birthday;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

2）创建数据访问层

在这里插入图片描述
IdCardRepository代码如下：

package com.ch.ch6_2.repository;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import com.ch.ch6_2.entity.IdCard;
public interface IdCardRepository extends JpaRepository<IdCard, Integer>{
	/**
	 * 根据人员ID查询身份信息（关联查询，根据person属性的id）
	 * 相当于JPQL语句：select ic from IdCard ic where ic.person.id = ?1
	 */
	public IdCard findByPerson_id(Integer id);
	/**
	 * 根据地址和身份证号查询身份信息
	 * 相当于JPQL语句：select ic from IdCard ic where ic.address = ?1 and ic.code =?2
	 */
	public List<IdCard> findByAddressAndCode(String address, String code);
}

PersonRepository的代码如下：

package com.ch.ch6_2.repository;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import com.ch.ch6_2.entity.Person;
public interface PersonRepository extends JpaRepository<Person, Integer>{
	/**
	 * 根据身份ID查询人员信息（关联查询，根据idCard属性的id）
	 * 相当于JPQL语句：select p from Person p where p.idCard.id = ?1
	 */
	public Person findByIdCard_id(Integer id);
	/**
	 * 根据人名和性别查询人员信息
	 * 相当于JPQL语句：select p from Person p where p.pname = ?1 and p.psex = ?2
	 */
	public List<Person> findByPnameAndPsex(String pname, String psex);
}

3）创建业务层

在这里插入图片描述
PersonAndIdCardService代码如下：

package com.ch.ch6_2.service;
import java.util.List;
import com.ch.ch6_2.entity.IdCard;
import com.ch.ch6_2.entity.Person;
public interface PersonAndIdCardService {
	public void saveAll();
	public List<Person> findAllPerson();
	public List<IdCard> findAllIdCard();
	public IdCard findByPerson_id(Integer id);
	public List<IdCard> findByAddressAndCode(String address, String code);
	public Person findByIdCard_id(Integer id);
	public List<Person> findByPnameAndPsex(String pname, String psex);
	public IdCard getOneIdCard(Integer id);
	public Person getOnePerson(Integer id);
}

PersonAndIdCardServiceImpl代码如下：

package com.ch.ch6_2.service;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ch.ch6_2.entity.IdCard;
import com.ch.ch6_2.entity.Person;
import com.ch.ch6_2.repository.IdCardRepository;
import com.ch.ch6_2.repository.PersonRepository;
@Service
public class PersonAndIdCardServiceImpl implements PersonAndIdCardService{
	@Autowired
	private IdCardRepository idCardRepository;
	@Autowired
	private PersonRepository personRepository;
	@Override
	public void saveAll() {
		//保存身份证
		IdCard ic1 = new IdCard();
		ic1.setCode("123456789");
		ic1.setAddress("北京");
		Calendar c1 = Calendar.getInstance();
		c1.set(2019, 8, 13);
		ic1.setBirthday(c1);
		IdCard ic2 = new IdCard();
		ic2.setCode("000123456789");
		ic2.setAddress("上海");
		Calendar c2 = Calendar.getInstance();
		c2.set(2019, 8, 14);
		ic2.setBirthday(c2);
		IdCard ic3 = new IdCard();
		ic3.setCode("1111123456789");
		ic3.setAddress("广州");
		Calendar c3 = Calendar.getInstance();
		c3.set(2019, 8, 15);
		ic3.setBirthday(c3);
		List<IdCard> idCards = new ArrayList<IdCard>();
		idCards.add(ic1);
		idCards.add(ic2);
		idCards.add(ic3);
		idCardRepository.saveAll(idCards);
		//保存人员
		Person p1 = new Person();
		p1.setPname("陈恒1");
		p1.setPsex("男");
		p1.setPage(88);
		p1.setIdCard(ic1);
		Person p2 = new Person();
		p2.setPname("陈恒2");
		p2.setPsex("女");
		p2.setPage(99);
		p2.setIdCard(ic2);
		Person p3 = new Person();
		p3.setPname("陈恒3");
		p3.setPsex("女");
		p3.setPage(18);
		p3.setIdCard(ic3);
		List<Person> persons = new ArrayList<Person>();
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		personRepository.saveAll(persons);
	}
	@Override
	public List<Person> findAllPerson() {
		return personRepository.findAll();
	}
	@Override
	public List<IdCard> findAllIdCard() {
		return idCardRepository.findAll();
	}
	/**
	 * 根据人员ID查询身份信息（级联查询）
	 */
	@Override
	public IdCard findByPerson_id(Integer id) {
		return idCardRepository.findByPerson_id(id);
	}
	@Override
	public List<IdCard> findByAddressAndCode(String address, String code) {
		return idCardRepository.findByAddressAndCode(address, code);
	}
	/**
	 * 根据身份ID查询人员信息（级联查询）
	 */
	@Override
	public Person findByIdCard_id(Integer id) {
		return personRepository.findByIdCard_id(id);
	}
	@Override
	public List<Person> findByPnameAndPsex(String pname, String psex) {
		return personRepository.findByPnameAndPsex(pname, psex);
	}
	@Override
	public IdCard getOneIdCard(Integer id) {
		return idCardRepository.getOne(id);
	}
	@Override
	public Person getOnePerson(Integer id) {
		return personRepository.getOne(id);
	}

}

4）创建控制器类

在这里插入图片描述
TestOneToOneController代码如下：

package com.ch.ch6_2.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ch.ch6_2.entity.IdCard;
import com.ch.ch6_2.entity.Person;
import com.ch.ch6_2.service.PersonAndIdCardService;
@RestController
public class TestOneToOneController {
	@Autowired 
	private PersonAndIdCardService personAndIdCardService;
	@RequestMapping("/save")
	public String save() {
		personAndIdCardService.saveAll();
		return "人员和身份保存成功！";
	}
	@RequestMapping("/findAllPerson")
	public List<Person> findAllPerson() {
		return  personAndIdCardService.findAllPerson();
	}
	@RequestMapping("/findAllIdCard")
	public List<IdCard>  findAllIdCard() {
		return personAndIdCardService.findAllIdCard();
	}
	/**
	 * 根据人员ID查询身份信息（级联查询）
	 */
	@RequestMapping("/findByPerson_id")
	public IdCard findByPerson_id(Integer id) {
		return personAndIdCardService.findByPerson_id(id);
	}
	@RequestMapping("/findByAddressAndCode")
	public List<IdCard> findByAddressAndCode(String address, String code){
		return personAndIdCardService.findByAddressAndCode(address, code);
	}
	/**
	 * 根据身份ID查询人员信息（级联查询）
	 */
	@RequestMapping("/findByIdCard_id")
	public Person findByIdCard_id(Integer id) {
		return personAndIdCardService.findByIdCard_id(id);
	}
	@RequestMapping("/findByPnameAndPsex")
	public List<Person> findByPnameAndPsex(String pname, String psex) {
		return personAndIdCardService.findByPnameAndPsex(pname, psex);
	}
	@RequestMapping("/getOneIdCard")
	public IdCard getOneIdCard(Integer id) {
		return personAndIdCardService.getOneIdCard(id);
	}
	@RequestMapping("/getOnePerson")
	public Person getOnePerson(Integer id) {
		return personAndIdCardService.getOnePerson(id);
	}
}

5）运行
在这里插入图片描述

在这里插入图片描述

2．@OneToMany和@ManyToOne

在实际生活中，作者（Author）和文章（Article）是一对多的双向关系。

在Spring Data JPA中，使用@OneToMany和@ManyToOne来表示一对多的双向关联。例如，一端（Author）使用@OneToMany，多端（Article）使用@ManyToOne。
在JPA规范中，一对多的双向关系由多端（如Article）来维护。就是说多端为关系的维护端，负责关系的增删改查。一端则为关系的被维护端，不能维护关系。
一端（Author）使用@OneToMany注解的mappedBy="author"属性表明一端（Author）是关系的被维护端。多端（Article）使用@ManyToOne和@JoinColumn来注解属性author，@ManyToOne表明Article是多端，@JoinColumn设置在article表的关联字段（外键）上。

【例6-3】使用Spring Data JPA实现Author与Article的一对多关系映射。

我们在ch6_2应用中实现【6-3】，具体实现步骤如下。
1）创建持久化实体类

创建名为com.ch.ch6_2.entity的包，并在该包中创建名为Author和Article的持久化实体类。

在这里插入图片描述
Author的具体代码如下：

package com.ch.ch6_2.entity;
import java.io.Serializable;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@Entity
@Table(name = "author_table")
@JsonIgnoreProperties(value = { "hibernateLazyInitializer"})
public class Author implements Serializable{
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	//作者名
	private String aname;
	//文章列表，作者与文章是一对多的关系
    @OneToMany(
    		mappedBy = "author",
    		cascade=CascadeType.ALL,
    		targetEntity = Article.class, 
    		fetch=FetchType.LAZY
    		)
    private List<Article> articleList;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getAname() {
		return aname;
	}
	public void setAname(String aname) {
		this.aname = aname;
	}
	public List<Article> getArticleList() {
		return articleList;
	}
	public void setArticleList(List<Article> articleList) {
		this.articleList = articleList;
	}
}

Article的具体代码如下：

package com.ch.ch6_2.entity;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@Entity
@Table(name = "article_table")
@JsonIgnoreProperties(value = { "hibernateLazyInitializer"})
public class Article  implements Serializable{
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	//标题
	@NotEmpty(message = "标题不能为空")
    @Size(min = 2, max = 50)
    @Column(nullable = false, length = 50) 
    private String title;
	//文章内容
    @Lob  //大对象，映射 为MySQL的Long文本类型
    @Basic(fetch = FetchType.LAZY) 
    @NotEmpty(message = "内容不能为空")
    @Size(min = 2)
    @Column(nullable = false) 
    private String content;
    //所属作者，文章与作者是多对一的关系
    @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)
    //可选属性optional=false,表示author不能为空。删除文章，不影响用户
    @JoinColumn(name="id_author_id")//设置在article表中的关联字段(外键)
    @JsonIgnore
    private Author author;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	public Author getAuthor() {
		return author;
	}
	public void setAuthor(Author author) {
		this.author = author;
	}
}

2）创建数据访问层

在com.ch.ch6_2.repository包中，创建名为AuthorRepository和ArticleRepository的接口。
在这里插入图片描述
AuthorRepository的代码如下：

package com.ch.ch6_2.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

import com.ch.ch6_2.entity.Author;
public interface AuthorRepository extends JpaRepository<Author, Integer>{
	/**
	 * 根据文章标题包含的内容，查询作者（关联查询）
	 * 相当于JPQL语句：select a from Author a  inner join  a.articleList t where t.title like %?1%
	 */
	public Author findByArticleList_titleContaining(String title);
	/**
	 * 根据文章标题包含的内容，查询作者（关联查询）
	 */
	@Query("select a from Author a  inner join  a.articleList t where t.title like %?1%" )
	public Author findAuthorByArticleListtitleContaining(String title);
}

ArticleRepository的代码如下：

package com.ch.ch6_2.repository;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import com.ch.ch6_2.entity.Article;
public interface ArticleRepository extends JpaRepository<Article, Integer>{
	/**
	 * 根据作者id查询文章信息（关联查询，根据author属性的id）
	 * 相当于JPQL语句：select a from Article a where a.author.id = ?1
	 */
	public List<Article> findByAuthor_id(Integer id);
	/**
	 * 根据作者名查询文章信息（关联查询，根据author属性的aname）
	 * 相当于JPQL语句：select a from Article a where a.author.aname = ?1
	 */
	public List<Article> findByAuthor_aname(String aname);
}

3）创建业务层

在com.ch.ch6_2.service包中，创建名为AuthorAndArticleService的接口和接口实现类AuthorAndArticleServiceImpl。

AuthorAndArticleService的代码如下：

package com.ch.ch6_2.service;
import java.util.List;
import com.ch.ch6_2.entity.Article;
import com.ch.ch6_2.entity.Author;
public interface AuthorAndArticleService {
	public void saveAll();
	public List<Article> findByAuthor_id(Integer id);
	public List<Article> findByAuthor_aname(String aname);
	public Author findByArticleList_titleContaining(String title);
	public Author findAuthorByArticleListtitleContaining(String title);
}

AuthorAndArticleServiceImpl的代码如下：

package com.ch.ch6_2.service;
import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ch.ch6_2.entity.Article;
import com.ch.ch6_2.entity.Author;
import com.ch.ch6_2.repository.ArticleRepository;
import com.ch.ch6_2.repository.AuthorRepository;
@Service
public class AuthorAndArticleServiceImpl implements AuthorAndArticleService{
	@Autowired
	private AuthorRepository authorRepository;
	@Autowired
	private ArticleRepository articleRepository;
	@Override
	public void saveAll() {
		//保存作者（先保存一的一端）
		Author a1 = new Author();
		a1.setAname("陈恒1");
		Author a2 = new Author();
		a2.setAname("陈恒2");
		ArrayList<Author> allAuthor = new ArrayList<Author>();
		allAuthor.add(a1);
		allAuthor.add(a2);
		authorRepository.saveAll(allAuthor);
		//保存文章
		Article at1 = new Article();
		at1.setTitle("JPA的一对多111");
		at1.setContent("其实一对多映射关系很常见111。");
		//设置关系
		at1.setAuthor(a1);
		Article at2 = new Article();
		at2.setTitle("JPA的一对多222");
		at2.setContent("其实一对多映射关系很常见222。");
		//设置关系
		at2.setAuthor(a1);//文章2与文章1作者相同
		Article at3 = new Article();
		at3.setTitle("JPA的一对多333");
		at3.setContent("其实一对多映射关系很常见333。");
		//设置关系
		at3.setAuthor(a2);
		Article at4 = new Article();
		at4.setTitle("JPA的一对多444");
		at4.setContent("其实一对多映射关系很常见444。");
		//设置关系
		at4.setAuthor(a2);//文章3与文章4作者相同
		ArrayList<Article> allAt = new ArrayList<Article>();
		allAt.add(at1);
		allAt.add(at2);
		allAt.add(at3);
		allAt.add(at4);
		articleRepository.saveAll(allAt);
	}
	@Override
	public List<Article> findByAuthor_id(Integer id) {
		return articleRepository.findByAuthor_id(id);
	}
	@Override
	public List<Article> findByAuthor_aname(String aname) {
		return articleRepository.findByAuthor_aname(aname);
	}
	@Override
	public Author findByArticleList_titleContaining(String title) {
		return authorRepository.findByArticleList_titleContaining(title);
	}
	@Override
	public Author findAuthorByArticleListtitleContaining(String title) {
		return authorRepository.findAuthorByArticleListtitleContaining(title);
	}
	

}

4）创建控制器类

在com.ch.ch6_2.controller包中，创建名为TestOneToManyController的控制器类。

TestOneToManyController的代码如下：

package com.ch.ch6_2.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ch.ch6_2.entity.Article;
import com.ch.ch6_2.entity.Author;
import com.ch.ch6_2.service.AuthorAndArticleService;
@RestController
public class TestOneToManyController {
	@Autowired 
	private AuthorAndArticleService authorAndArticleService;
	@RequestMapping("/saveOneToMany")
	public String save() {
		authorAndArticleService.saveAll();
		return "作者和文章保存成功！";
	}
	@RequestMapping("/findArticleByAuthor_id")
	public List<Article> findByAuthor_id(Integer id) {
		return authorAndArticleService.findByAuthor_id(id);
	}
	@RequestMapping("/findArticleByAuthor_aname")
	public List<Article> findByAuthor_aname(String aname){
		return authorAndArticleService.findByAuthor_aname(aname);
	}
	@RequestMapping("/findByArticleList_titleContaining")
	public Author findByArticleList_titleContaining(String title) {
		return authorAndArticleService.findByArticleList_titleContaining(title);
	}
	@RequestMapping("/findAuthorByArticleListtitleContaining")
	public Author findAuthorByArticleListtitleContaining(String title) {
		return authorAndArticleService.findAuthorByArticleListtitleContaining(title);
	}
}

5）运行

在这里插入图片描述

3．@ManyToMany

在Spring Data JPA中使用@ManyToMany来注解多对多的映射关系，由一个关联表来维护。关联表的表名默认是：主表名+下划线+从表名（主表是指关系维护端对应的表，从表是指关系被维护端对应的表）。关联表只有两个外键字段，分别指向主表ID和从表ID。字段的名称默认为：主表名+下划线+主表中的主键列名，从表名+下划线+从表中的主键列名。需要注意的是，多对多关系中一般不设置级联保存、级联删除、级联更新等操作。

【例6-4】使用Spring Data JPA实现用户（User）与权限（Authority）的多对多关系映射。

我们在ch6_2应用中实现【6-4】，具体实现步骤如下。
1）创建持久化实体类

创建名为com.ch.ch6_2.entity的包，并在该包中创建名为User和Authority的持久化实体类。

User的具体代码如下：

package com.ch.ch6_2.entity;
import java.io.Serializable;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@Entity
@Table(name = "user")
@JsonIgnoreProperties(value = { "hibernateLazyInitializer"})
public class User implements Serializable{
	private static final long serialVersionUID = 1L;
  	@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String username;
    private String password; 
    @ManyToMany
    @JoinTable(name = "user_authority",joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "authority_id"))
    /**1、关系维护端，负责多对多关系的绑定和解除
    2、@JoinTable注解的name属性指定关联表的名字，joinColumns指定外键的名字，关联到关系维护端（User）
    3、inverseJoinColumns指定外键的名字，要关联的关系被维护端（Authority）
    4、其实可以不使用@JoinTable注解，默认生成的关联表名称为主表表名+下划线+从表表名，
        即表名为user_authority
        关联到主表的外键名：主表名+下划线+主表中的主键列名,即user_id
        关联到从表的外键名：主表中用于关联的属性名+下划线+从表的主键列名,即authority_id
        主表就是关系维护端对应的表，从表就是关系被维护端对应的表
    */
    private List<Authority> authorityList;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public List<Authority> getAuthorityList() {
		return authorityList;
	}
	public void setAuthorityList(List<Authority> authorityList) {
		this.authorityList = authorityList;
	}
}

Authority的具体代码如下：

package com.ch.ch6_2.entity;
import java.io.Serializable;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@Entity
@Table(name = "authority")
@JsonIgnoreProperties(value = { "hibernateLazyInitializer"})
public class Authority implements Serializable{
	private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(nullable = false)
    private String name;
    @ManyToMany(mappedBy = "authorityList")
    @JsonIgnore
    private List<User> userList;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<User> getUserList() {
		return userList;
	}
	public void setUserList(List<User> userList) {
		this.userList = userList;
	}
}

2）创建数据访问层

在com.ch.ch6_2.repository包中，创建名为UserRepository和AuthorityRepository的接口。

UserRepository的代码如下：

package com.ch.ch6_2.repository;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import com.ch.ch6_2.entity.User;
public interface UserRepository extends JpaRepository<User, Integer>{
	/**
	 * 根据权限id查询拥有该权限的用户（关联查询）
	 * 相当于JPQL语句：select u from User u inner join u.authorityList a where a.id = ?1
	 */
	public List<User> findByAuthorityList_id(int id);
	/**
	 * 根据权限名查询拥有该权限的用户（关联查询）
	 * 相当于JPQL语句：select u from User u inner join u.authorityList a where a.name = ?1
	 */
	public List<User> findByAuthorityList_name(String name);
}

AuthorityRepository的代码如下：

package com.ch.ch6_2.repository;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import com.ch.ch6_2.entity.Authority;
public interface AuthorityRepository extends JpaRepository<Authority, Integer>{
	/**
	 * 根据用户id查询用户所拥有的权限（关联查询）
	 * 相当于JPQL语句：select a from Authority a inner join a.userList u where u.id = ?1
	 */
	public List<Authority> findByUserList_id(int id);
	/**
	 * 根据用户名查询用户所拥有的权限（关联查询）
	 * 相当于JPQL语句：select a from Authority a inner join a.userList u where u.username = ?1
	 */
	public List<Authority> findByUserList_Username(String username);
	/**
	 * 根据用户名查询用户所拥有的权限（关联查询）
	 */
	@Query("select a from Authority a inner join a.userList u where u.username = ?1")
	public List<Authority> findByUserListUsername(String username);
}

3）创建业务层

在com.ch.ch6_2.service包中，创建名为UserAndAuthorityService的接口和接口实现类UserAndAuthorityServiceImpl。

UserAndAuthorityService的代码如下：

package com.ch.ch6_2.service;
import java.util.List;
import com.ch.ch6_2.entity.Authority;
import com.ch.ch6_2.entity.User;
public interface UserAndAuthorityService {
	public void saveAll();
	public List<User> findByAuthorityList_id(int id);
	public List<User> findByAuthorityList_name(String name);
	public List<Authority> findByUserList_id(int id);
	public List<Authority> findByUserList_Username(String username);
	public List<Authority> findByUserListUsername(String username);
}

UserAndAuthorityServiceImpl的代码如下：

package com.ch.ch6_2.service;
import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ch.ch6_2.entity.Authority;
import com.ch.ch6_2.entity.User;
import com.ch.ch6_2.repository.AuthorityRepository;
import com.ch.ch6_2.repository.UserRepository;
@Service
public class UserAndAuthorityServiceImpl implements UserAndAuthorityService{
	@Autowired
	private AuthorityRepository authorityRepository;
	@Autowired
	private UserRepository userRepository;
	@Override
	public void saveAll() {
		//添加权限1
		Authority at1 = new Authority();
		at1.setName("增加");
		authorityRepository.save(at1);
		//添加权限2
		Authority at2 = new Authority();
		at2.setName("修改");
		authorityRepository.save(at2);
		//添加权限3
		Authority at3 = new Authority();
		at3.setName("删除");
		authorityRepository.save(at3);
		//添加权限4
		Authority at4 = new Authority();
		at4.setName("查询");
		authorityRepository.save(at4);
		//添加用户1
		User u1 = new User();
		u1.setUsername("陈恒1");
		u1.setPassword("123");
		ArrayList<Authority> authorityList1 = new ArrayList<Authority>();
		authorityList1.add(at1);
		authorityList1.add(at2);
		authorityList1.add(at3);
		u1.setAuthorityList(authorityList1);
		userRepository.save(u1);
		//添加用户2
		User u2 = new User();
		u2.setUsername("陈恒2");
		u2.setPassword("234");
		ArrayList<Authority> authorityList2 = new ArrayList<Authority>();
		authorityList2.add(at2);
		authorityList2.add(at3);
		authorityList2.add(at4);
		u2.setAuthorityList(authorityList2);
		userRepository.save(u2);
	}
	@Override
	public List<User> findByAuthorityList_id(int id) {
		return userRepository.findByAuthorityList_id(id);
	}
	@Override
	public List<User> findByAuthorityList_name(String name) {
		return userRepository.findByAuthorityList_name(name);
	}
	@Override
	public List<Authority> findByUserList_id(int id) {
		return authorityRepository.findByUserList_id(id);
	}
	@Override
	public List<Authority> findByUserList_Username(String username) {
		return authorityRepository.findByUserList_Username(username);
	}
	@Override
	public List<Authority> findByUserListUsername(String username) {
		return authorityRepository.findByUserListUsername(username);
	}
}

4）创建控制器类

在com.ch.ch6_2.controller包中，创建名为TestManyToManyController的控制器类。

TestManyToManyController的代码如下：

package com.ch.ch6_2.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ch.ch6_2.entity.Authority;
import com.ch.ch6_2.entity.User;
import com.ch.ch6_2.service.UserAndAuthorityService;
@RestController
public class TestManyToManyController {
	@Autowired 
	private UserAndAuthorityService userAndAuthorityService;
	@RequestMapping("/saveManyToMany")
	public String save() {
		userAndAuthorityService.saveAll();
		return "权限和用户保存成功！";
	}
	@RequestMapping("/findByAuthorityList_id")
	public List<User> findByAuthorityList_id(int id) {
		return userAndAuthorityService.findByAuthorityList_id(id);
	}
	@RequestMapping("/findByAuthorityList_name")
	public List<User> findByAuthorityList_name(String name) {
		return userAndAuthorityService.findByAuthorityList_name(name);
	}
	@RequestMapping("/findByUserList_id")
	public List<Authority> findByUserList_id(int id) {
		return userAndAuthorityService.findByUserList_id(id);
	}
	@RequestMapping("/findByUserList_Username")
	public List<Authority> findByUserList_Username(String username) {
		return userAndAuthorityService.findByUserList_Username(username);
	}
	@RequestMapping("/findByUserListUsername")
	public List<Authority> findByUserListUsername(String username) {
		return userAndAuthorityService.findByUserListUsername(username);
	}
}

5）运行

在这里插入图片描述

学习时间：

在这里插入图片描述

学习产出：

1、技术笔记 1 遍
2、CSDN 技术博客 1 篇

ASAYI

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
第6章 Spring Boot的数据访问一、Spring Data JPA（3、关联查询）

学习目标：一、Spring Data JPA（3、简单条件查询示例）学习内容：在Spring Data JPA中有一对一、一对多、多对多等关系映射。1．@OneToOne一对一关系，在现实生活中是十分常见的。比如一个大学生只有一张一卡通，一张一卡通只属于一个大学生。再比如人与身份证的关系也是一对一的关系。在Spring Data JPA中，可用两种方式描述一对一关系映射。一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键)；一种是通过一张关联表来保存两个实体一对一的关系。下面我们通过
复制链接

扫一扫