九、Spring Data JPA--（2）关联查询

关联查询

1、@OneToOne–实现人与身份证的一对一关系映射

a>创建实体类

package com.yzh.jpa.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;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@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;

}

package com.yzh.jpa.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;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@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(value = TemporalType.DATE)
	private Calendar birthday;
	private String address;
	/**
	 * optional = false设置person属性值不能为null，也就是身份证必须有对应的主人。
	 * mappedBy = "idCard"与Person类中的idCard属性一致
	 */
	@OneToOne(
			optional = true,
			fetch = FetchType.LAZY, 
			targetEntity = Person.class, 
			mappedBy = "idCard", //不会建立该数据库字段
			cascade = CascadeType.ALL
			)
	private Person person;//对应的人


}

b>创建数据访问层

package com.yzh.jpa.repository;
import java.util.List;

import com.yzh.jpa.entity.Person;
import org.springframework.data.jpa.repository.JpaRepository;

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);
}

package com.yzh.jpa.repository;
import java.util.List;

import com.yzh.jpa.entity.IdCard;
import org.springframework.data.jpa.repository.JpaRepository;
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);
}

c>创建业务层

package com.yzh.jpa.service;
import java.util.List;
import com.yzh.jpa.entity.IdCard;
import com.yzh.jpa.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);
}

package com.yzh.jpa.service;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

import com.yzh.jpa.entity.IdCard;
import com.yzh.jpa.entity.Person;
import com.yzh.jpa.repository.IdCardRepository;
import com.yzh.jpa.repository.PersonRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

}

d>创建控制器类

package com.yzh.jpa.service;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

import com.yzh.jpa.entity.IdCard;
import com.yzh.jpa.entity.Person;
import com.yzh.jpa.repository.IdCardRepository;
import com.yzh.jpa.repository.PersonRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

}

2、@OneToMany–实现作者和文章一对多的映射关系

a>创建实体类

package com.yzh.jpa.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;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@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",//不会在数据库中建立该字段，返回的json会包含该字段信息
    		cascade=CascadeType.ALL,
    		targetEntity = Article.class, 
    		fetch=FetchType.LAZY
    		)
    private List<Article> articleList;
}

package com.yzh.jpa.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;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@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 = "标题不能为空")//不能为null或者长度为0
    @Size(min = 2, max = 50)//验证对象（Array,Collection,Map,String）长度是否在给定的范围之内
    @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; //会在数据库中建立字段，返回的json不包含这个字段的数据

}

b>创建数据访问层

package com.yzh.jpa.repository;
import com.yzh.jpa.entity.Author;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

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);
}

package com.yzh.jpa.repository;
import java.util.List;
import com.yzh.jpa.entity.Article;
import org.springframework.data.jpa.repository.JpaRepository;

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);
}

c>创建业务层

package com.yzh.jpa.service;
import java.util.List;
import com.yzh.jpa.entity.Article;
import com.yzh.jpa.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);
}

package com.yzh.jpa.service;
import java.util.ArrayList;
import java.util.List;

import com.yzh.jpa.entity.Article;
import com.yzh.jpa.entity.Author;
import com.yzh.jpa.repository.ArticleRepository;
import com.yzh.jpa.repository.AuthorRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

}

d>创建控制器类

package com.yzh.jpa.controller;
import java.util.List;
import com.yzh.jpa.entity.Article;
import com.yzh.jpa.entity.Author;
import com.yzh.jpa.service.AuthorAndArticleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

3、@ManyToMany–实现用户和权限多对多的映射关系

a>创建实体类

package com.yzh.jpa.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;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@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;

}

package com.yzh.jpa.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;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@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;
}

b>创建数据访问层

package com.yzh.jpa.repository;
import java.util.List;

import com.yzh.jpa.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository2 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);
}

package com.yzh.jpa.repository;
import java.util.List;

import com.yzh.jpa.entity.Authority;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

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);
}

c>创建业务层

package com.yzh.jpa.service;
import java.util.List;
import com.yzh.jpa.entity.Authority;
import com.yzh.jpa.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);
}

package com.yzh.jpa.service;
import java.util.ArrayList;
import java.util.List;

import com.yzh.jpa.entity.Authority;
import com.yzh.jpa.entity.User;
import com.yzh.jpa.repository.AuthorityRepository;
import com.yzh.jpa.repository.UserRepository2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserAndAuthorityServiceImpl implements UserAndAuthorityService{
	@Autowired
	private AuthorityRepository authorityRepository;
	@Autowired
	private UserRepository2 userRepository2;
	@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);
		userRepository2.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);
		userRepository2.save(u2);
	}
	@Override
	public List<User> findByAuthorityList_id(int id) {
		return userRepository2.findByAuthorityList_id(id);
	}
	@Override
	public List<User> findByAuthorityList_name(String name) {
		return userRepository2.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);
	}
}

package com.yzh.jpa.controller;
import java.util.List;

import com.yzh.jpa.entity.Authority;
import com.yzh.jpa.entity.User;
import com.yzh.jpa.service.UserAndAuthorityService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@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);
	}
}

d>创建控制器类