spring data jpa入门
简述:
Spring Data是Spring的一个子项目, 用于访问数据库
其主要目标是使得数据库的访问变得方便快捷
Spring Data中已经提供了常用的一些接口和实现类, 比如分页、排序、DAO一些常用的操作
从而我们可利用spring data快速构建项目
导入spring data的jar包:
中心仓库去下载
org.springframework.boot
spring-boot-starter-data-jpa
2.0.2.RELEASE
根据不同DB还导一个数据库驱动
mysql
mysql-connector-java
5.1.14
核心接口:
Repository接口是spring data提供的核心接口, 它是一个空接口(标记接口)
package org.springframework.data.repository;
import java.io.Serializable;
public interface Repository {
} 基础的 Repository 只提供了最基本的数据访问功能, 其子接口扩展了其功能
Repository： 顶级接口, 仅仅是一个标识，表示任何继承它的接口都是仓库接口类
CrudRepository： 继承 Repository，实现了一组 CRUD(增删改查) 相关的方法
PagingAndSortingRepository： 继承 CrudRepository，实现了一组 分页排序 相关的方法
JpaRepository： 继承 PagingAndSortingRepository，实现一组 JPA 规范 相关的方法
Repository在commons包中, JpaRepostory在data包r中 , 如下
默认存在的一些方法:
我们定义一个接口MyRespository, 继承了JpaRespository, 则可以直接使用如下的方法
repository为MyRespository的对象
repository.findAll();
repository.findOne(xxx);
repository.save();
repository.delete(xxx);
repository.count();
repository.exists();
...
// 查询所有对象
@RequestMapping("/findAll")
public void findAll() {
List movies = dao.findAll();
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
// 查询某个对象
@RequestMapping("/findOne/{id}")
public void findOne(@PathVariable String id) {
int parseId = Integer.parseInt(id);
Movie movie = dao.findOne(parseId);
if (movie == null) {
return;
}
System.out.println(movie.getDesc());
}
// 删除对象
@RequestMapping("/delete/{id}")
public void delete(@PathVariable String id) {
int parseId = Integer.parseInt(id);
boolean flag = false;
try {
dao.delete(parseId);
flag = true;
} catch (Exception e) {}
if (flag == true) {
System.out.println("删除成功");
} else {
System.out.println("删除失败");
}
}
// count
@RequestMapping("/count")
public void count() {
System.out.println(dao.count());
}
// exists
@RequestMapping("/exists/{id}")
public void exists(@PathVariable String id) {
int parseId = Integer.parseInt(id);
System.out.println(dao.exists(parseId));
}
// save
@RequestMapping("/save") //注意数据表不可使用关键字, 否则会提示sql错误
public void save(String name, String img_url, String year, String artist, String desc) {
Movie entity = new Movie();
entity.setName(name);
entity.setImgUrl(img_url);
entity.setYear(year);
entity.setArtist(artist);
entity.setDesc(desc);
entity.setId(11);
try {
dao.save(entity);
dao.flush();
System.out.println("写入成功");
} catch (Exception e) {
System.out.println("写入失败");
}
} 方法定义规范:
符合规范的方法，可以不用写实现
设计查询方法以find 或 read 或 get开头
设计 条件查询 时，条件用属性名连接, 例如如下查询
先继承JpaRepository, 再写自己的方法(比如这里的 findById, 也可以改为 getById / readById)
我并没有写 这个MovieDao接口的实现, 但是在Controllrt中就可以使用(因为我遵循了JPA规范, 所以不用写实现)
spring关键字查询
就是表明查询的逻辑, 比如getByNameAndYear (根据电影名称和年份查询)
这个and就是关键字
添加如下的一个方法
同样没有实现, 在Controller中也可直接使用
接口中我写的JPA规范方法(全部有效)
public interface MovieDao extends JpaRepository {
// 根据电影的id查询, findById -- 属性名为id
public Movie getById(Integer id);
// 根据电影名称和电影描述查询
public Movie getByNameAndYear(String name, String year);
// Or, 这可能查询出多个结果, 所以需要用集合保存结果
public List findByNameOrYear(String name, String year);
// Between, 从第一个参数到第二个参数之间
public List findByYearBetween(String start, String end);
// LessThan, 小于
public List findByYearLessThan(String data);
// GreaterThan, 大于
public List readByYearGreaterThan(String data);
// After, 字段中大于data的记录(测试时效果与GreaterThan相同, 不知道有什么区别)
public List readByYearAfter(String data);
// Before, 字段中小于data的记录(同上)
public List readByYearBefore(String data);
// IsNull, 说明null表示没有值, 它并不是空值, 空值是: "" (空字符串), 查询时需要注意它们的区别
public List getByYearIsNull();
// IsNotNull
public List getByYearIsNotNull();
// like(模糊查询 like为表达式, 具体由Cotroller中拼接)
public List findByDescLike(String like);
// In, in表示从列表中查询, 参数可以是数组和集合
public List findByYearIn(String[] s);
// 按Desc模糊查询再按Year降序排列 /*这个是比较综合的查询*/
public List findTop3ByDescLikeOrderByYearDesc(String like);
} Controller中我对接口的测试 (只看方法名称就知道代表的意思)
@RestController
public class MovieController {
@Autowired
private MovieDao dao;
@RequestMapping("/getMovieById/{id}")
public void getMovieById(@PathVariable String id) {
int parseId = 0;
try {
parseId = Integer.parseInt(id);
} catch (NumberFormatException e) {
System.err.println("请输入非零正数");
return;
}
/*如果传入的参数正确才查询DB*/
if (parseId > 0) {
Movie movie = dao.getById(parseId);
if (movie != null) {
System.out.println(movie.getName());
} else {
System.out.println("您查询的内容不存在");
}
return;
}
System.out.println("请输入非零正数");
}
@RequestMapping("/findMovieByNameAndYear")
public String getByNameAndYear(String name, String year) {
if (year == null || name == null) {
System.out.println("请输入名称和年份");
return null;
}
Movie movie = dao.getByNameAndYear(name, year);
if (movie != null) {
System.out.println(movie.getDesc());
}
return null;
}
@RequestMapping("/findMovieOrNameAndYear")
public void getByNameOrYear(String name, String year) {
List movies = dao.findByNameOrYear(name, year);
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
@RequestMapping("/findByYearBetween")
// between
public void findByYearBetween(String start , String end) {
if (start == null || end == null) {
return;
}
List movies = dao.findByYearBetween(start, end);
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
@RequestMapping("/findByYearLessThan")
public void findByYearLessThan(String data) {
if (data == null) {
return;
}
List movies = dao.findByYearLessThan(data);
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
@RequestMapping("/readByYearGreaterThan")
public void readByYearGreaterThan(String data) {
if (data == null) {
return;
}
List movies = dao.readByYearGreaterThan(data);
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
@RequestMapping("/readByYearAfter")
// After
public void readByYearAfter(String data) {
if (data == null) {
return;
}
List movies = dao.readByYearAfter(data);
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
@RequestMapping("/getByYearIsNull")
public void getByYearIsNull() {
List movies = dao.getByYearIsNull();
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
@RequestMapping("/getByYearIsNotNull")
public void getByYearIsNotNull() {
List movies = dao.getByYearIsNotNull();
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
@RequestMapping("/findByDescLike")
public void findByDesc(String data) {
String like = "%" + data + "%";
List movies = dao.findByDescLike(like);
System.out.println(movies.size());
}
// 模糊查询排序(JPA规范看: 按Desc查询, 按Year排序)
@RequestMapping("/findTop3ByDescLikeOrderByYearDesc")
public void findTop3ByDescLikeOrderByYearDesc(String data) {
String like = "%" + data + "%";
List movies = dao.findTop3ByDescLikeOrderByYearDesc(like);
for (Movie movie : movies) {
System.out.println(movie.getYear() + ": " + movie.getName());
}
}
@RequestMapping("/findByYearIn")
public void findByYearIn(String a) {
String[] arr = null;
if(a != null) {
arr = a.split(",");
}
if(arr == null) return;
List movies = dao.findByYearIn(arr);
for (Movie movie : movies) {
System.out.println(movie.getName());
}
}
// 查询所有对象
@RequestMapping("/findAll")
public void findAll() {
List movies = dao.findAll();
for (Movie movie : movies) {
System.out.println(movie.getDesc());
}
}
// 查询某个对象
@RequestMapping("/findOne/{id}")
public void findOne(@PathVariable String id) {
int parseId = Integer.parseInt(id);
Movie movie = dao.findOne(parseId);
if (movie == null) {
return;
}
System.out.println(movie.getDesc());
}
// 删除对象
@RequestMapping("/delete/{id}")
public void delete(@PathVariable String id) {
int parseId = Integer.parseInt(id);
boolean flag = false;
try {
dao.delete(parseId);
flag = true;
} catch (Exception e) {}
if (flag == true) {
System.out.println("删除成功");
} else {
System.out.println("删除失败");
}
}
// count
@RequestMapping("/count")
public void count() {
System.out.println(dao.count());
}
// exists
@RequestMapping("/exists/{id}")
public void exists(@PathVariable String id) {
int parseId = Integer.parseInt(id);
System.out.println(dao.exists(parseId));
}
// save
@RequestMapping("/save")
public void save(String name, String img_url, String year, String artist, String desc) {
Movie entity = new Movie();
entity.setName(name);
entity.setImgUrl(img_url);
entity.setYear(year);
entity.setArtist(artist);
entity.setDesc(desc);
try {
dao.save(entity);
System.out.println("写入成功");
} catch (Exception e) {
System.out.println("写入失败");
e.printStackTrace();
}
}
} Example查询
count(), findAll(),exists()的参数都可以使用Example对象(来实现模糊查询)
1.先创建Example
2.再创建ExampleMatcher对象
3.使用count, findAll. exists方法
@RequestMapping("/exampleSelect")
public void exampleCount(String name, String year) {
// 创建对象
Movie movie = new Movie();
movie.setName(name);
movie.setYear(year);
//创建匹配器
ExampleMatcher matcher = ExampleMatcher.matching()
// name, year代表数据表中的字段名(但以实体类中的字段名为准)
.withMatcher("name", GenericPropertyMatchers.contains()) // 包含
.withMatcher("year", GenericPropertyMatchers.endsWith()) // 以结尾
//.withMatcher("实体字段名", 匹配条件); // 还可以继续加匹配
// 要忽略id(不清楚原因)
.withIgnorePaths("id");
//创建实例, 用这个实例movie去匹配数据表中的每条记录 (这个实例对象就相当于一条数据表记录)
Example ex = Example.of(movie, matcher);
long mo = dao.count(ex);
System.out.println(mo);
} JPQL查询
类似HQL语法在方法上使用@Query注解
@Query(value="select * from movie where id = ?1", nativeQuery = true)
public Movie findDefinedId(int id);上面在Query注解中加上了nativeQuery = true, 则这就是原生sql查询
如下的字段名id, movie_name只能是原数据表中的字段名, 不能改为实体类中的属性名
查询单个字段, 返回简单类型
@Query(value="select id, movie_name from movie where id = ?1", nativeQuery = true)
public String findDefinedId(int id); 查询多个字段, 返回数组类型
//原生sql查询
@Query(value="select movie_name, id, artist from movie where id = ?1", nativeQuery = true)
public String[] findDefinedId(int id);查询全部字段可以返回对象
HQL查询也是使用Query注解, 但是不加nativeQuery=true
// HQL查询, 如果查询的是单个字段, 就返回简单类型
// HQL查询, 如果查询的是多个字体, 则返回的是数组
@Query(value="select id, name from Movie where id = ?1")
public String[] findDefinedHqlId(Long id);
// HQL查询, 查询多个字段, 但是想要返回对象, 则应该这样写, 但是要保证实体中有引构造器
@Query(value="select new Movie(id, name) from Movie where id = ?1")
public List findDefinedHqlIdToObject(Long id); 使用HQL查询, 要当作类来使用, 比如这里的Movie必是类, 而不是表名(所以大写)
这里的id, name也是属性名, 而不是表中的字段名
还有这里的参数Long id, 不可使用int型, 因为我的id在实体类中就是定义的long型, 而不是int型
这些千万要注意区别, 否则会出现类型不能转换的异常
多表关联查询, 对于业务复杂的HQL性能很差, 而使用原生sql查询, 效率更佳
但是解析查询的结果比较麻烦一点
接口:
// 多表原生联查, 返回的必须是List控制层:
@RequestMapping("/unionTable")
public void unionTable() {
// 这个集合中的Object对象 本质是对象数组
ListList
[ ['a', 'b','c'], ['1', '2', '3'], ['盗梦空间', '排行9', '2001年' ] ]
另外还有参数点位符等, spring data 的大致内容就是这些