Spring Boot 整合Spring Data JPA 数据接口开发测试(二)

港控/mmm° 2022-04-16 01:24 192阅读 0赞

## 核心接口代码: ##

### 1.实体类 ###

package com.weichai.SpringDataJpaQuery.entity;
    
    import java.io.Serializable;
    
    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.ManyToOne;
    import javax.persistence.Table;
    
    /**
     * 学生实体类
     * @author lhy
     * @date 2018.11.10
     */
    @Entity
    @Table(name="tb_student")
    public class Student implements Serializable {
    
    	private static final long serialVersionUID = 1L;
    	
    	@Id
    	@GeneratedValue(strategy = GenerationType.IDENTITY)
    	private int id;
    	private String name ;
    	private String address ;
    	private int age ; 
    	private char sex;
    	// 学生与班级是多对一的关系，这里配置的是双向关联
    	@ManyToOne(fetch=FetchType.LAZY,targetEntity=Clazz.class)
    	@JoinColumn(name="clazzId",referencedColumnName="code")
    	private Clazz clazz;
    	public Student() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	public Student(String name, String address, int age, char sex, Clazz clazz) {
    		super();
    		this.name = name;
    		this.address = address;
    		this.age = age;
    		this.sex = sex;
    		this.clazz = clazz;
    	}
    	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 String getAddress() {
    		return address;
    	}
    	public void setAddress(String address) {
    		this.address = address;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public char getSex() {
    		return sex;
    	}
    	public void setSex(char sex) {
    		this.sex = sex;
    	}
    	public Clazz getClazz() {
    		return clazz;
    	}
    	public void setClazz(Clazz clazz) {
    		this.clazz = clazz;
    	}
    	
    	
    }

package com.weichai.SpringDataJpaQuery.entity;
    
    import java.io.Serializable;
    import java.util.HashSet;
    import java.util.Set;
    
    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;
    
    /**
     * 班级实体类
     * @author lhy
     * @date 2018.11.10
     */
    @Entity
    @Table(name="tb_clazz")
    public class Clazz implements Serializable {
    
    	private static final long serialVersionUID = 1L;
    	
    	@Id
    	@GeneratedValue(strategy=GenerationType.IDENTITY)
    	private int code ;
    	private String name ;
    	// 班级与学生是一对多的关联
    	@OneToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="clazz")
    	private Set<Student> students = new HashSet<Student>();
    	public Clazz() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	public Clazz(String name) {
    		super();
    		this.name = name;
    	}
    	public int getCode() {
    		return code;
    	}
    	public void setCode(int code) {
    		this.code = code;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Set<Student> getStudents() {
    		return students;
    	}
    	public void setStudents(Set<Student> students) {
    		this.students = students;
    	}
    	
    }

package com.weichai.SpringDataJpaQuery.pageUtil;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    /**
     * 定义一个对象用于封装一页数据
     * @author lhy
     * @date 2018.11.12
     */
    public class PageData {
    	// 定义一个变量用于存放当前页码
    	private int pageIndex;
    	// 定义一个变量用于保存满足查询条件下用于分页的数据总量
    	private long totalCount;
    	// 定义一个变量用于保存当前条件下总共可以分的总页数
    	private int pageSize;
    	// 定义一个变量用于保存当前页码查询出的数据总量
    	private int pageNum;
    	// 定义一个变量用于保存当前查询出来的学生信息
    	private List<Map<String, Object>> stuDatas = new ArrayList<Map<String,Object>>();
    
    	public int getPageSize() {
    		return pageSize;
    	}
    
    	public void setPageSize(int pageSize) {
    		this.pageSize = pageSize;
    	}
    
    	public int getPageIndex() {
    		return pageIndex;
    	}
    
    	public void setPageIndex(int pageIndex) {
    		this.pageIndex = pageIndex;
    	}
    
    	public long getTotalCount() {
    		return totalCount;
    	}
    
    	public void setTotalCount(long totalCount) {
    		this.totalCount = totalCount;
    	}
    
    	public int getPageNum() {
    		return pageNum;
    	}
    
    	public void setPageNum(int pageNum) {
    		this.pageNum = pageNum;
    	}
    
    	public List<Map<String, Object>> getStuDatas() {
    		return stuDatas;
    	}
    
    	public void setStuDatas(List<Map<String, Object>> stuDatas) {
    		this.stuDatas = stuDatas;
    	}
    }

### 2.数据访问持久层 ###

package com.weichai.SpringDataJpaQuery.dao;
    
    import java.util.List;
    import java.util.Map;
    
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
    import org.springframework.data.jpa.repository.Modifying;
    import org.springframework.data.jpa.repository.Query;
    import org.springframework.data.repository.query.Param;
    
    import com.weichai.SpringDataJpaQuery.entity.Student;
    
    public interface StudentDao extends JpaRepository<Student, Integer>,JpaSpecificationExecutor<Student>{
    
    	//1.关联查询和Query查询
    	/**
    	 * 根据班级名称查询这个班级下所有的学生信息
    	 * 相当于JPQL语句： select s from Student s where s.clazz.name = ?1
    	 * @param clazzName
    	 * @return
    	 */
    	List<Student> findByClazz_name(String clazzName);
    	
    	/**
    	 * @Query写法
    	 * 根据班级名称查询这个班级下所有的学生信息
    	 * ?1此处使用的是参数的位置，代表的是第一个参数
    	 * 此写法与 findByClazz_name方法实现的功能完全一致
    	 * @param clazzName
    	 * @return
    	 */
    //	@Query("select s from Student s where s.clazz.name = ?1")
    //	List<Student> findStudentsByClazzName(String clazzName);
    	
    	/**
    	 * 使用@Query注解的形式，查询某个班级下所有学生的姓名和性别 
    	 * @param clazzName
    	 * @return
    	 */
    	@Query("select new Map(s.name as name , s.sex as sex) "
    			+ "from Student s where s.clazz.name = ?1")
    	List<Map<String, Object>> findNameAndSexByClazzName(String clazzName);
    	
    	/**
    	 *  使用@Query注解的形式，查询某个班级下某种性别的所有学生的姓名
    	 *  上面方法是用的是参数的位置来查询的，Spring Data JPA中还支持用
    	 *  名称来匹配查询使用格式 “:参数名称” 引用
    	 * @param clazzName
    	 * @param sex
    	 * @return
    	 */
    	@Query("select s.name from Student s "
    			+ "where s.clazz.name = :clazzName and s.sex = :sex ")
    	List<String> findNameByClazzNameAndSex(@Param("clazzName")String clazzName , @Param("sex")char sex);
    	
    	/**
    	 *  使用@Query注解的形式，查询某个学生属于哪个班级
    	 * @param stuName
    	 * @return
    	 */
    	@Query("select c.name from Clazz c inner join c.students s "
    			+ "where s.name = ?1 ")
    	String findClazzNameByStuName(String stuName);
    	
    	/**
    	 * 执行更新查询，使用@Query与@Modifying可以执行更新操作
    	 * 例如删除牛魔王这个学生
    	 * @param stuName
    	 */
    	@Modifying
    	@Query("delete from Student s where s.name = ?1")
    	void deleteStuByStuName(String stuName);
    	
    	//2. NamedQuery查询
    	/**
    	 * 查询班级下的所有学生
    	 * @param clazzName
    	 * @return
    	 */
    	List<Student> findStudentsByClazzName(String clazzName);
    	
    	//3.Specification 查询
    	//此处直接继承接口,在服务层中编写代码即可
    }

package com.weichai.SpringDataJpaQuery.dao;
    
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
    
    import com.weichai.SpringDataJpaQuery.entity.Clazz;
    
    public interface ClazzDao extends JpaRepository<Clazz, Integer>,JpaSpecificationExecutor<Clazz> {
    
    }

### 3.数据服务封装层 ###

package com.weichai.SpringDataJpaQuery.service;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import javax.annotation.Resource;
    import javax.persistence.criteria.CriteriaBuilder;
    import javax.persistence.criteria.CriteriaQuery;
    import javax.persistence.criteria.JoinType;
    import javax.persistence.criteria.Path;
    import javax.persistence.criteria.Predicate;
    import javax.persistence.criteria.Root;
    import javax.transaction.Transactional;
    
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.PageRequest;
    import org.springframework.data.domain.Sort;
    import org.springframework.data.jpa.domain.Specification;
    import org.springframework.stereotype.Service;
    import org.springframework.util.StringUtils;
    
    import com.weichai.SpringDataJpaQuery.dao.ClazzDao;
    import com.weichai.SpringDataJpaQuery.dao.StudentDao;
    import com.weichai.SpringDataJpaQuery.entity.Clazz;
    import com.weichai.SpringDataJpaQuery.entity.Student;
    
    @Service
    public class SchoolService {
    
    	// 注入数据访问层接口对象 
    	@Resource
    	private StudentDao studentDao;
    	
    	@Resource
    	private ClazzDao clazzDao;
    	
    	//1.关联查询和Query查询
    	@Transactional
    	public void SaveClazzAll(List<Clazz> clazzs){
    		clazzDao.saveAll(clazzs);
    	}
    	
    	@Transactional
    	public void SaveStudentAll(List<Student> students) {
    		studentDao.saveAll(students);
    	}
    	
    //	public List<Map<String, Object>> getStusByClazzName(String clazzName) {
    //		// 使用"_" 和 @Query查询方式结果一致
    //		List<Student> students = studentDao.findByClazz_name(clazzName);
    //		List<Map<String, Object>>  results = new ArrayList<Map<String,Object>>();
    //		
    //		// 遍历查询出的学生对象，提取姓名，年龄，性别信息
    //		for(Student student:students){
    //			Map<String , Object> stu = new HashMap<String , Object>();
    //			stu.put("name", student.getName());
    //			stu.put("age", student.getAge());
    //			stu.put("sex", student.getSex());
    //			results.add(stu);
    //		}
    //		return results;
    //	}
    	
    	public List<Map<String, Object>> findNameAndSexByClazzName(String clazzName) {
    		return studentDao.findNameAndSexByClazzName(clazzName);
    	}
    	
    	public List<String> findNameByClazzNameAndSex(String clazzName, char sex) {
    		return studentDao.findNameByClazzNameAndSex(clazzName, sex);
    	}
    	
    	public String findClazzNameByStuName(String stuName) {
    		return studentDao.findClazzNameByStuName(stuName);
    	}
    	
    	@Transactional
    	public void deleteStuByStuName(String stuName) {
    		studentDao.deleteStuByStuName(stuName);
    	}
    	
    	//2. NamedQuery查询
    	public List<Map<String, Object>> getStusByClazzName(String clazzName) {
    		// 查询班级下的所有学生
    		List<Student> students = studentDao.findStudentsByClazzName(clazzName);
    		List<Map<String, Object>>  results = new ArrayList<Map<String,Object>>();
    		// 遍历查询出的学生对象，提取姓名，年龄，性别信息
    		for(Student student:students){
    			Map<String , Object> stu = new HashMap<String, Object>();
    			stu.put("name", student.getName());
    			stu.put("age", student.getAge());
    			stu.put("sex", student.getSex());
    			results.add(stu);
    		}
    		return results;
    	}
    	
    	//3.Specification 查询
    	
    	/**
    	 * 根据性别查询学生信息
    	 * @param sex
    	 * @return
    	 */
    	@SuppressWarnings("serial")
    	public List<Map<String, Object>> getStusBySex(final char sex) {
    		List<Student> students = studentDao.findAll(new Specification<Student>() {
    
    			public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    				// TODO Auto-generated method stub
    				// root.get("sex")表示获取sex这个字段名称,equal表示执行equal查询
    				// 相当于 select s from Student s where s.sex = ?1
    				Predicate p1 = cb.equal(root.get("sex"), sex);
    				return p1;
    			}
    		});
    		List<Map<String, Object>>  results = new ArrayList<Map<String,Object>>();
    		// 遍历查询出的学生对象，提取姓名，年龄，性别信息
    		for(Student student:students){
    			Map<String , Object> stu = new HashMap<String, Object>(); 
    			stu.put("name", student.getName());
    			stu.put("age", student.getAge());
    			stu.put("sex", student.getSex());
    			results.add(stu);
    		}
    		return results;
    	}
    	
    	/**
    	 * 动态查询学生信息 ：可以根据学生对象的姓名(模糊匹配)， 地址查询(模糊匹配),性别,班级查询学生信息 
    	 *               如果没有传输参数,默认查询所有的学生信息
    	 * @param student
    	 * @return
    	 */
    	@SuppressWarnings("serial")
    	public List<Map<String, Object>> getStusByDynamic(final Student student) {
    		List<Student> students = studentDao.findAll(new Specification<Student>() {
    			public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    				// 本集合用于封装查询条件
    				List<Predicate> predicates = new ArrayList<Predicate>();
    				if (student != null) {
    					/** 是否传入了姓名来查询 */
    					if (!StringUtils.isEmpty(student.getName())) {
    						predicates.add(cb.like(root.<String> get("name"), "%" + student.getName() + "%"));
    					}
    					/** 是否传入了地址来查询 */
    					if (!StringUtils.isEmpty(student.getAddress())) {
    						predicates.add(cb.like(root.<String> get("address"), "%" + student.getAddress() + "%"));
    					}
    					/** 是否传入了性别来查询 */
    					if (student.getSex() != '\0') {
    						predicates.add(cb.equal(root.<String> get("sex"), student.getSex()));
    					}
    					/** 判断是否传入了班级信息来查询 */
    					if (student.getClazz() != null && !StringUtils.isEmpty(student.getClazz().getName())) {
    						root.join("clazz", JoinType.INNER);
    						Path<String> clazzName = root.get("clazz").get("name");
    						predicates.add(cb.equal(clazzName, student.getClazz().getName()));
    					}
    				}
    				return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
    			}
    		});
    		List<Map<String, Object>> results = new ArrayList<Map<String,Object>>();
    		// 遍历查询出的学生对象，提取姓名，年龄，性别信息
    		for (Student stu : students) {
    			Map<String, Object> stuMap = new HashMap<String, Object>();
    			stuMap.put("name", stu.getName());
    			stuMap.put("age", stu.getAge());
    			stuMap.put("sex", stu.getSex());
    			stuMap.put("address", stu.getAddress());
    			stuMap.put("clazzName", stu.getClazz().getName());
    			results.add(stuMap);
    		}
    		return results;
    	}
    	
    	/**
    	 * 分页查询某个班级的学生信息
    	 * @param clazzName
    	 * @param pageIndex
    	 * @param pageSize
    	 * @return
    	 */
    	@SuppressWarnings("serial")
    	public Page<Student> getStusByPage(final String clazzName , int pageIndex , int pageSize) {
    		// 指定排序参数对象：根据id，进行降序查询
    		Sort sort = new Sort(Sort.Direction.DESC,"id");
    		Page<Student> pages = studentDao.findAll(new Specification<Student>() {
    			public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query,CriteriaBuilder cb) {
    				root.join("clazz",JoinType.INNER);
    				Path<String> cn = root.get("clazz").get("name");
    				Predicate p1 = cb.equal(cn, clazzName);
    				return p1 ;
    			}
    		},PageRequest.of(pageIndex-1, pageSize, sort));
    		return pages;
    	}
    }

### 4.控制层 ###

package com.weichai.SpringDataJpaQuery.controller;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import javax.annotation.Resource;
    import org.springframework.data.domain.Page;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.weichai.SpringDataJpaQuery.entity.Clazz;
    import com.weichai.SpringDataJpaQuery.entity.Student;
    import com.weichai.SpringDataJpaQuery.pageUtil.PageData;
    import com.weichai.SpringDataJpaQuery.service.SchoolService;
    
    @RestController
    @RequestMapping("/student")
    public class StudentController {
    
    	// 注入ShcoolService
    	@Resource
    	private SchoolService schoolService;
    
    	//1.关联查询和Query查询
    	@RequestMapping("/Save")
    	public String Save() {
    		Clazz clazz1 = new Clazz("软件1班");
    		Clazz clazz2 = new Clazz("软件2班");
    		// 保存班级对象数据
    		List<Clazz> clazzs = new ArrayList<Clazz>();
    		clazzs.add(clazz1);
    		clazzs.add(clazz2);
    		schoolService.SaveClazzAll(clazzs);
    
    		Student swk = new Student("孙悟空", "广州", 700, '男', clazz1);
    		Student zzj = new Student("蜘蛛精", "广州", 700, '女', clazz1);
    		Student nmw = new Student("牛魔王", "广州", 500, '男', clazz2);
    
    		List<Student> students = new ArrayList<Student>();
    		students.add(swk);
    		students.add(zzj);
    		students.add(nmw);
    		schoolService.SaveStudentAll(students);
    		return "保存学生对象成功";
    	}
    	
    	/**
    	 * 查询某个班级下所有的学生姓名，年龄，性别
    	 * @param clazzName
    	 * @return
    	 */
    //	@RequestMapping("/getClazzStus")
    //	public List<Map<String, Object>> getClazzStus(String clazzName){
    //		return schoolService.getStusByClazzName(clazzName);
    //	}
    	
    	/**
    	 * 查询某个班级下所有的学生姓名，性别
    	 * @param clazzName
    	 * @return
    	 */
    	@RequestMapping("/findNameAndSexByClazzName")
    	public List<Map<String, Object>> findNameAndSexByClazzName(String clazzName){
    		return schoolService.findNameAndSexByClazzName(clazzName);
    	} 
    	
    	/**
    	 * ，查询某个班级下某种性别的所有学生的姓名
    	 * @param clazzName
    	 * @param sex
    	 * @return
    	 */
    	@RequestMapping("/findNameByClazzNameAndSex")
    	public List<String> findNameByClazzNameAndSex(String clazzName ,Character sex){
    		return schoolService.findNameByClazzNameAndSex(clazzName ,sex);
    	} 
    	
    	/**
    	 * http://localhost:8080/student/findClazzNameByStuName?stuName=孙悟空
    	 * 查询某个学生属于哪个班级
    	 * @param stuName
    	 * @return
    	 */
    	@RequestMapping("/findClazzNameByStuName")
    	public String findClazzNameByStuName(String stuName){
    		return schoolService.findClazzNameByStuName(stuName);
    	} 
    	
    	/**
    	 * http://localhost:8080/student/deleteStuByStuName?stuName=孙悟空
    	 * 删除某个学生对象
    	 * @param stuName
    	 */
    	@RequestMapping("/deleteStuByStuName")
    	public void deleteStuByStuName(String stuName){    //链接的参数必须与定义的参数一致,而不是实体类的参数字段
    		schoolService.deleteStuByStuName(stuName);
    	} 
    	
    	//2. NamedQuery查询
    	/**
    	 * http://localhost:8080/student/getClazzStus?clazzName=软件1班
    	 * @param clazzName
    	 * @return
    	 */
    	@RequestMapping("/getClazzStus")
    	public List<Map<String, Object>> getClazzStus(String clazzName){
    		return schoolService.getStusByClazzName(clazzName);
    	} 
    	
    	//3.Specification 查询
    	/**
    	 * http://localhost:8080/student/getStusBySex?sex=男
    	 * @param sex
    	 * @return
    	 */
    	@RequestMapping("/getStusBySex")
    	public List<Map<String, Object>> getStusBySex(char sex){
    		return schoolService.getStusBySex(sex);
    	} 
    	
    	/**
    	 * http://localhost:8080/student/getStusByDynamic?clazz.name=软件1班&sex=男
    	 * 动态的查询学生信息
    	 * 可以根据学生对象的姓名(模糊匹配)， 地址查询(模糊匹配),性别,班级查询学生信息 
    	 * @param student
    	 * @return
    	 */
    	@RequestMapping("/getStusByDynamic")
    	public List<Map<String, Object>> getStusByDynamic(Student student) {
    		return schoolService.getStusByDynamic(student);
    	} 
    	
    	/**
    	 * http://localhost:8080/student/getStusByPage?clazzName=软件1班&pageIndex=1&pageSize=2
    	 * 分页查询某个班级下的学生信息
    	 * @param clazzName 班级名称
    	 * @param pageIndex 当前页码
    	 * @param pageSize  每页数据条数
    	 * @return
    	 */
    	@RequestMapping("/getStusByPage")
    	public PageData getStusByPage(String clazzName , int pageIndex , int pageSize ) {
    		// 分页查询某个班级的学生信息
    		Page<Student> page = schoolService.getStusByPage(clazzName, pageIndex, pageSize);
    		// 对查询出来的结果数据进行分析
    		List<Student> students = page.getContent();
    		List<Map<String,Object>> stuDatas = new ArrayList<Map<String,Object>>();
    		for(Student stu :students){
    			Map<String , Object> stuMap = new HashMap<String, Object>();
    			stuMap.put("id", stu.getId());
    			stuMap.put("name", stu.getName());
    			stuMap.put("age", stu.getAge());
    			stuMap.put("sex", stu.getSex());
    			stuMap.put("address", stu.getAddress());
    			stuMap.put("clazzName", clazzName);
    			stuDatas.add(stuMap);
    		}
    		// 将分页查询出的结果数据进行分析，然后把数据存入到PageData对象中去保存起来响应给浏览器展示 
    		PageData data = new PageData();
    		data.setStuDatas(stuDatas);
    		data.setPageIndex(page.getNumber()+1);
    		data.setPageSize(page.getTotalPages());
    		data.setTotalCount(page.getTotalElements());
    		data.setPageNum(page.getSize());
    		return data ;
    	}
    }

### 5.项目接口启动类 ###

package com.weichai.SpringDataJpaQuery;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /**
     * @SpringBootApplication指定这是一个 spring boot的应用程序.
     */
    @SpringBootApplication
    public class App 
    {
        public static void main( String[] args )
        {
        	// SpringApplication 用于从main方法启动Spring应用的类。
            SpringApplication.run(App.class, args);
        }
    }

## 同样的,打开浏览器,输入接口访问链接进行测试即可.如 ##

[http://localhost:8080/student/getStusByPage?clazzName=软件1班&pageIndex=2&pageSize=2][http_localhost_8080_student_getStusByPage_clazzName_1_pageIndex_2_pageSize_2]

[http_localhost_8080_student_getStusByPage_clazzName_1_pageIndex_2_pageSize_2]: http://localhost:8080/student/getStusByPage?clazzName=%E8%BD%AF%E4%BB%B61%E7%8F%AD&pageIndex=2&pageSize=2