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

文章目录

关联查询
- 1、@OneToOne--实现人与身份证的一对一关系映射
- - a>创建实体类
  - b>创建数据访问层
  - c>创建业务层
- d>创建控制器类
- 2、@OneToMany--实现作者和文章一对多的映射关系
- - a>创建实体类
  - b>创建数据访问层
  - c>创建业务层
  - d>创建控制器类
- 3、@ManyToMany--实现用户和权限多对多的映射关系
- - a>创建实体类
  - b>创建数据访问层
  - c>创建业务层
  - d>创建控制器类

关联查询 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")

@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
			)
	
	@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;
	
	@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{
	
	public Person findByIdCard_id(Integer id);
	
	public List 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{
	
	public IdCard findByPerson_id(Integer id);
	
	public List 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 findAllPerson();
	public List findAllIdCard();
	public IdCard findByPerson_id(Integer id);
	public List findByAddressAndCode(String address, String code);
	public Person findByIdCard_id(Integer id);
	public List 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 idCards = new ArrayList();
		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 persons = new ArrayList();
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		personRepository.saveAll(persons);
	}
	@Override
	public List findAllPerson() {
		return personRepository.findAll();
	}
	@Override
	public List findAllIdCard() {
		return idCardRepository.findAll();
	}
	
	@Override
	public IdCard findByPerson_id(Integer id) {
		return idCardRepository.findByPerson_id(id);
	}
	@Override
	public List findByAddressAndCode(String address, String code) {
		return idCardRepository.findByAddressAndCode(address, code);
	}
	
	@Override
	public Person findByIdCard_id(Integer id) {
		return personRepository.findByIdCard_id(id);
	}
	@Override
	public List 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 idCards = new ArrayList();
		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 persons = new ArrayList();
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		personRepository.saveAll(persons);
	}
	@Override
	public List findAllPerson() {
		return personRepository.findAll();
	}
	@Override
	public List findAllIdCard() {
		return idCardRepository.findAll();
	}
	
	@Override
	public IdCard findByPerson_id(Integer id) {
		return idCardRepository.findByPerson_id(id);
	}
	@Override
	public List findByAddressAndCode(String address, String code) {
		return idCardRepository.findByAddressAndCode(address, code);
	}
	
	@Override
	public Person findByIdCard_id(Integer id) {
		return personRepository.findByIdCard_id(id);
	}
	@Override
	public List 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 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{
	
	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{
	
	public List findByAuthor_id(Integer id);
	
	public List 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 findByAuthor_id(Integer id);
	public List 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 allAuthor = new ArrayList();
		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 allAt = new ArrayList();
		allAt.add(at1);
		allAt.add(at2);
		allAt.add(at3);
		allAt.add(at4);
		articleRepository.saveAll(allAt);
	}
	@Override
	public List findByAuthor_id(Integer id) {
		return articleRepository.findByAuthor_id(id);
	}
	@Override
	public List 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 findByAuthor_id(Integer id) {
		return authorAndArticleService.findByAuthor_id(id);
	}
	@RequestMapping("/findArticleByAuthor_aname")
	public List 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"))
    
    private List 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 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{
    
    public List findByAuthorityList_id(int id);
    
    public List 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{
	
	public List findByUserList_id(int id);
	
	public List findByUserList_Username(String username);
	
	@Query("select a from Authority a inner join a.userList u where u.username = ?1")
	public List 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 findByAuthorityList_id(int id);
	public List findByAuthorityList_name(String name);
	public List findByUserList_id(int id);
	public List findByUserList_Username(String username);
	public List 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 authorityList1 = new ArrayList();
		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 authorityList2 = new ArrayList();
		authorityList2.add(at2);
		authorityList2.add(at3);
		authorityList2.add(at4);
		u2.setAuthorityList(authorityList2);
		userRepository2.save(u2);
	}
	@Override
	public List findByAuthorityList_id(int id) {
		return userRepository2.findByAuthorityList_id(id);
	}
	@Override
	public List findByAuthorityList_name(String name) {
		return userRepository2.findByAuthorityList_name(name);
	}
	@Override
	public List findByUserList_id(int id) {
		return authorityRepository.findByUserList_id(id);
	}
	@Override
	public List findByUserList_Username(String username) {
		return authorityRepository.findByUserList_Username(username);
	}
	@Override
	public List 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 findByAuthorityList_id(int id) {
		return userAndAuthorityService.findByAuthorityList_id(id);
	}
	@RequestMapping("/findByAuthorityList_name")
	public List findByAuthorityList_name(String name) {
		return userAndAuthorityService.findByAuthorityList_name(name);
	}
	@RequestMapping("/findByUserList_id")
	public List findByUserList_id(int id) {
		return userAndAuthorityService.findByUserList_id(id);
	}
	@RequestMapping("/findByUserList_Username")
	public List findByUserList_Username(String username) {
		return userAndAuthorityService.findByUserList_Username(username);
	}
	@RequestMapping("/findByUserListUsername")
	public List findByUserListUsername(String username) {
		return userAndAuthorityService.findByUserListUsername(username);
	}
}

d>创建控制器类

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

Java相关栏目本月热门文章