Spring Data JPA 进阶（自定义查询，原生 SQL 查询）

自定义查询语句(JPQL)

使用@Query 自定义查询

//	根据学生姓名查询学生记录 Student是实体类的名称
	@Query("select s from Student s where s.name=?1")
	List<Student> getStudentName(String name);

在controller中调用

/**
	 * 根据学生姓名查询学生记录 http://localhost:8080/getStuName?name=张三
	 * 
	 * @param student * @return
	 */
	@RequestMapping("/getStuName")
	public Object getStudentName(String name) {
		List<Student> student=repository.getStudentName(name);
		return student;
	}

@Query 与 @Modifying 的联合使用

@Transactional 开启事务
@Modifying 识别执行更新操作
@Query() SQL语句
三个主注解缺一不可

//	通过学生id修改学生姓名 三个主注解缺一不可
	@Transactional//开启事务
	@Modifying//识别执行更新操作
	@Query("update Student s set s.name=?1 where s.id=?2")
	int updateStuById(String name, int id);

controller调用

/**
	 * 通过学生id修改学生姓名 http://localhost:8080/updateStuById?name=张3&id=1
	 * 
	 * @param student * @return
	 */
	@RequestMapping("/updateStuById")
	public Object updateStuById(String name,int id) {
		int student=repository.updateStuById(name,id);
		return student;
	}

索引参数与命名参数

1. 索引参数如下例代码所示，索引值从 1 开始，查询中 ”?X” 个数需要与方法定义的参数个数相一致，并且顺序也要一致：

@Transactional
@Modifying
@Query("update Student s set s.studentName=?1 where s.studentId=?2")
int setFixedStudentNameFor(String studentName,int studentId);

2)命名参数（推荐使用这种方式） 可以定义好参数名，赋值时采用@Param(“参数名”)，而不用管顺序。
3) 在 StudentRepository 里添加如下代码，实现姓名的模糊查询：

@Query("select s from Student s where s.studentName like %:studentName% ")
List<Student> queryByname(@Param(value = "studentName") String studentName);

在 controller 里面进行调用，代码如下：

/***
* http://localhost:8080/queryByname?name=刘
* @param name * @return
*/
@RequestMapping("/queryByname")
public Object queryByname(String name) {
List<Student> student = repository.queryByname(name);
return student;
}

原生 SQL 查询

nativeQuery=true 开启原生SQL

//利用原生的 SQL 进行查询操作
@Query(value = "select s.* from studenttb s where s.student_name=?1", nativeQuery = true)
public List<Student> findStudentByName(String name);

//利用原生的 SQL 进行删除操作
@Query(value = "delete from studenttb where student_id=?1 ", nativeQuery = true)
@Modifying
@Transactional
public int deleteStudentById(int uid);

//利用原生的 SQL 进行修改操作
@Query(value = "update studenttb set student_name=?1 where student_id=?2 ", nativeQuery = true)
@Modifying
@Transactional
public int updateStudentName(String name,int id);

//利用原生的 SQL 进行插入操作
@Query(value = "insert into studenttb(student_name,student_age) value(?1,?2)", nativeQuery = true)
@Modifying
@Transactional
public int insertStudent(String name,int age);

//利用原生的 SQL 实现姓名的模糊查询
@Query(value=" SELECT * FROM studenttb WHERE STUDENT_NAME LIKE %:name% ",nativeQuery=true)
List<Student> queryBynameSQL(@Param(value = "name") String name);

controller调用

//原生 sql 的调用
/***
*查询学生
* http://localhost:8080/findStudentByName?name=刘一
* @param name * @return
*/
@RequestMapping("/findStudentByName")
public Object findStuByName(String name) {
List<Student> student = repository.findStudentByName(name);
return student;
}

/***
*删除学生
* http://localhost:8080/deleteStudentById?id=刘
* @param name * @return
*/
@RequestMapping("/deleteStudentById")
public Object deleteStudentById(int id) {
int i = repository.deleteStudentById(id);
Map<String,Object> map=new HashMap<String,Object>();
if(i>0) {
map.put("success", true);
}else {
map.put("success", false);
}
return map;
}

/***
* 修改学生名字
*http://localhost:8080/updateStudentName?name=Tom&id=1
* @param name * @return
*/
@RequestMapping("/updateStudentName")
public Object updateStudentName(String name,int id) {
int i = repository.updateStudentName(name,id);
Map<String,Object> map=new HashMap<String,Object>();
if(i>0) {
map.put("success", true);
}else {
map.put("success", false);
}
return map;
}

/***
*添加学生信息
* http://localhost:8080/insertStudent?name=xiao&age=18
129
* @param name * @return
*/
@RequestMapping("/insertStudent")
public Object insertStudent(String name,int age) {
int i = repository.insertStudent(name,age);
Map<String,Object> map=new HashMap<String,Object>();
if(i>0) {
map.put("success", true);
}else {
map.put("success", false);
}
return map;
}

/***
* 模糊查询
* http://localhost:8080/queryBynameSQL?name=刘
* @param name * @return
*/
@RequestMapping("/queryBynameSQL")
public Object queryBynameSQL(String name) {
List<Student> student= repository.queryBynameSQL(name);
return student;
}

JAP 动态 SQL 查询

JpaSpecificationExecutor 接口中的所有功能

1. T findOne(Specification spec);// 查询单个对象
2. List findAll(Specification spec);//查询列表
3. Page findAll(Specification spec, Pageable pageable); //分页查询列表，pageable：分页参数。
4. List findAll(Specification spec, Sort sort); //排序查询列表，Sort：排序参数
5. long count(Specification spec);//统计查询

在上面的所有方法中，都有 Specification 对象，它是查询条件对象，需要自定义自己的 Specification 实现类，需要实现如下的方法：
Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb);

controller 实现多条件查询

/**
	 * 多条件分页查询分页查询 http://localhost:8080/page/limit
	 * 
	 * @param student * @return
	 */
	@RequestMapping("/page/limit")
	public Object getPageLimit() {
		Integer limit=10;
		Integer index=1;
		String name="张3";
		PageRequest page=PageRequest.of(index-1, limit);
		Specification<Student> spec=new Specification<Student>() {

			@Override
			public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
				// TODO Auto-generated method stub
				Predicate pc=criteriaBuilder.conjunction();
				List<Expression<Boolean>> es=pc.getExpressions();
				es.add(criteriaBuilder.like(root.get("name"), "%"+name+"%"));
				return pc;
			}
		};
		return repository.findAll(spec, page);
	}

StudentRepository接口需要继承的

//接口 StudentRepository，并继承 JpaRepository 接口	JpaSpecificationExecutor接口
public interface StudentRepository extends JpaRepository<Student, Integer>,JpaSpecificationExecutor<Student>