第一步：#
maven中添加JPA依赖
1
2
3
4
| <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
|
第二步（可选）：#
安装IDEA插件 JPA Buddy，可以自动生成Entity实体类和Repository仓库接口
第三步：#
创建数据表，比如：
1
2
3
4
5
6
7
8
| CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`password` varchar(255) DEFAULT NULL,
`age` int(11) DEFAULT NULL,
`created_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8mb4;
|
第四步：#
创建数据表对应实体类
项目下边创建entity软件包（文件夹）
方法1（推荐）：通过JPA Buddy插件创建，在entity上右键→新建→来自数据库的JPA实体，下边选择对应的数据表和字段，点击确认，就可以自动在entity下边创建对应的实体类了
方法2：手动创建
注解说明：
@Data 注解为 lombok 注解，会自动为该类添加 getter/setter 方法。
@Entity 和 @Table 注解都是 JDK 1.5 以后引入的元数据注解，遵循 JPA 规范中定义的查询语言 JPQL，类似 SQL 语法，适用于 Java 类。
@Entity 表明该类是一个实体类，默认使用 ORM 规则，即类名为数据库表名，类中的字段名为数据库表中的字段名。
@Table 注解是非必选项，它的优先级高于 @Entity 注解，比如说 @Entity(name=“user”) 和 @Table(name=“users”) 同时存在的话，对应的表名为 users。
@Id 表名该字段为主键字段，当声明了 @Entity 注解，@Id 就必须也得声明。
示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| @Data
@Entity
@Table(name = "user")
public class User {
@Id
@Column(name = "id", nullable = false)
private Integer id;
@Column(name = "name", nullable = false, length = 10)
private String name;
@Column(name = "password", nullable = false, length = 10)
private String password;
@Column(name = "age", nullable = false)
private Integer age;
// 省略 getter/setter
}
|
说明：如果数据库中有创建日期，已经设置了CURRENT_TIMESTAMP，则在程序中无需任何操作，实体类也不增加，如果增加了需要注意Data()方法获取的时间必须转化为本地时间
特殊需求说明：
如果想让自增ID拼接前缀生成新的字段，比如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id", nullable = false)
private Integer id;
@Column(name = "code", nullable = false, length = 10)
private String code;
@PrePersist
public void prePersist() {
this.code = "user_" + id;
}
}
|
@GeneratedValue(strategy = GenerationType.IDENTITY) 注解表示该字段为自增ID，@PrePersist 注解表示在保存实体之前执行该方法，将 code 字段的值设置为 user_id，其中 id 为自增ID。
第五步：#
创建仓库接口
创建仓库（Repository），现在项目下边创建repository软件包，然后创建对应表的仓库
方法1（推荐）：通过JPA Buddy插件创建，在repository软件包上右键→新建→新建Spring Data仓库，实体类选择刚才创建好的实体类，名称为表名首字母大写加Repository，父项默认即可，标准API规范可选，软件包默认刚才创建好的repository软件包，然后点击确认
放法2：手动创建
示例：
1
2
3
4
| public interface UserRepository extends JpaRepository<User, Integer> {
//这里可以定义非系统的查询方法，比如
User findByName(String name);
}
|
第六步：#
创建服务类接口
路径：项目/service/表名首字母大写加Service，新建为接口interface，然后创建对应的查询方法，比如：
1
2
3
4
5
6
| public interface UserService {
User findById(Integer id);//查询单个
List<User> findAll();//查询全部
User save(User user);//保存或更新
void delete(Integer id);//删除
}
|
2、创建服务类接口实现类
路径：项目/service/impl/表名首字母大写加ServiceImpl，新建为类class，并implements上边的服务接口，比如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
| @Service //注解为Service
public class UserServiceImpl implements UserService{
@Resource
private UserRepository userRepository;//映射仓库
//重写服务接口的方法，并具体实现
@Override
public User findById(Integer id) {
return userRepository.getById(id);
}
@Override
public List<User> findAll() {
return userRepository.findAll();
}
@Override
public User save(User user) {
/*查重 findByName方法必须现在userRepository中定义*/
Object existUser = userRepository.findByName(user.getName());
if (existUser != null) {
throw new RuntimeException("名称不能重复！");
}
/*生成uid*/
user.setUid(UUID.randomUUID().toString());
/*格式校验，需要用到hutool的Validator方法，比如：
Validator.isMobile(account.getPhone())*/
/*保存*/
return userRepository.save(user);
}
@Override
public void delete(Integer id) {
//系统默认的deleteById方法是硬删除
userRepository.deleteById(id);
//如果想要软删除，则需要在数据表中新建一个表示删除状态的字段
//跟其他字段一样即可，如果想软删除，则直接用更新方法更新该字段即可
}
}
|
@Service 注解用在服务层，和 @Component 注解作用类似（通用注解），Spring Boot 会自动扫描该类注解注解的类，并把它们假如到 Spring 容器中。
@Resource 和 @Autowired 注解都是用来自动装配对象的，可以用在字段上，也可以用在 setter 方法上。@Autowired 是 Spring 提供的注解，@Resource 是 Java 提供的注解，也就是说，如果项目没有使用 Spring 框架而是 JFinal 框架，@Resource 注解也是支持的。另外，@Resource 是 byName 自动装配，@Autowired 是 byType 自动装配，当有两个类型完全一样的对象时，@Autowired 就会出错了。
第七步：#
创建控制器，项目/controller/表名首字母大写加Controller，创建类文件
示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
| //类前注解
@RestController
@RequestMapping("user")
public class UserController {
//类中
@Resource
private UserService userService;//映射接口
//具体接口
@GetMapping("/")
public List<User> findAll() {
return userService.findAll();
}
}
|
第八步：#
启动项目，浏览器访问接口，即可完成数据交互
前端请求： http://localhost:8080/user/，就可以看到全部查询信息
查询参数：#
1
2
3
4
| @GetMapping("/")
public List<User> findAll(@RequestParam("name") String name) {
return userService.findByName(name);
}
|
Repository中@Query注解查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| public interface UserRepository extends JpaRepository<User, Long> {
// User是实体类
@Query("select u from User u where u.emailAddress = ?1")
User findByEmailAddress(String emailAddress);
}
// 或者
public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u where u.emailAddress =:emailAddress")
User findByEmailAddress(@Param("emailAddress") String emailAddress);
}
// 或者使用@NativeQuery注解使用原生查询
public interface UserRepository extends JpaRepository<User, Long> {
@NativeQuery(value = "SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1")
User findByEmailAddress(String emailAddress);
}
// 模糊查询
public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u where u.name like %?1%")
List<User> findByNameLike(String name);
}
// 搜索条件可能为空
// name: 名称,如果为空则查询全部，不为空则模糊查询，不能直接输入%name%程序无法解析，需要使用concat函数拼接
// status: 状态,如果为空则查询全部，不为空则查询指定状态
// 如果某个字段为空，使用is null比=null更加安全
// 如果某个字段名称与系统关键词冲突，使用反引号包裹字段名称，如：`order`
@NativeQuery(value = "select * from user where company=:company and (:name is null or name like concat('%',:name,'%')) and (:status is null or status = :status) and deleted_time is null order by `order` ASC")
List<GoodsCategory> searchQuery(
@Param("company") String company,
@Param("name") String name,
@Param("status") Integer status
);
// 补充说明：
// 如果参数中是@Param("name") String name，则在@Query注解中使用:name
// 如果参数中是String name，则在@Query注解中使用?1
|
简单连表查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| // repository
@NativeQuery(value = "select g.*,c.name as category_name from goods g left join goods_category c on g.category = c.code " +
"where (:name is null or g.name like concat('%',:name,'%')) and (:category is null or c.code=:category) and " +
"g.deleted_time is null order by g.created_time DESC")
List<Map<String, Object>> searchQuery(
@Param("name") String name,
@Param("category") String category,
);
// dto
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor()
public class GoodsResDto {
private String code;
private String name;
private String category;
private String category_name;//连表查询出来的字段
private String unit;
//...
}
// service
// 查询
List<Map<String, Object>> goodsAll = goodsRepository.searchQuery(name, category);
// 转换为dto
List<GoodsResDto> resDto = new ArrayList<>();
for (Map<String, Object> goods : goodsAll) {
GoodsResDto goodsResDto = new GoodsResDto();
goodsResDto.setCode((String) goods.get("code"));
goodsResDto.setName((String) goods.get("name"));
goodsResDto.setCategory((String) goods.get("category"));
goodsResDto.setCategory_name((String) goods.get("category_name"));
goodsResDto.setUnit((String) goods.get("unit"));
//...
resDto.add(goodsResDto);
}
return resDto;
|
Spring Data JPA 基础知识#
1、查询方法命名规则#
| 关键词 | 示例 | JPQL 代码片段 |
|---|
Distinct去重查询，支持多列 | findDistinctByLastnameAndFirstname | select distinct … where x.lastname = ?1 and x.firstname = ?2 |
And | findByLastnameAndFirstname | … where x.lastname = ?1 and x.firstname = ?2 |
Or | findByLastnameOrFirstname | … where x.lastname = ?1 or x.firstname = ?2 |
Is, Equals | findByFirstname,findByFirstnameIs,findByFirstnameEquals | … where x.firstname = ?1 |
Between | findByStartDateBetween | … where x.startDate between ?1 and ?2 |
LessThan | findByAgeLessThan | … where x.age < ?1 |
LessThanEqual | findByAgeLessThanEqual | … where x.age <= ?1 |
GreaterThan | findByAgeGreaterThan | … where x.age > ?1 |
GreaterThanEqual | findByAgeGreaterThanEqual | … where x.age >= ?1 |
After日期更近 | findByStartDateAfter | … where x.startDate > ?1 |
Before日期更远 | findByStartDateBefore | … where x.startDate < ?1 |
IsNull, Null | findByAge(Is)Null | … where x.age is null |
IsNotNull, NotNull | findByAge(Is)NotNull | … where x.age is not null |
Like | findByFirstnameLike | … where x.firstname like ?1 |
NotLike | findByFirstnameNotLike | … where x.firstname not like ?1 |
StartingWith以什么开头 | findByFirstnameStartingWith | … where x.firstname like ?1 (需要配合%使用) |
EndingWith以什么结尾 | findByFirstnameEndingWith | … where x.firstname like ?1 (需要配合%使用) |
Containing包含 | findByFirstnameContaining | … where x.firstname like ?1 (需要配合%使用) |
OrderBy | findByAgeOrderByLastnameDesc | … where x.age = ?1 order by x.lastname desc |
Not | findByLastnameNot | … where x.lastname <> ?1 |
In | findByAgeIn(Collection<Age> ages) | … where x.age in ?1 |
NotIn | findByAgeNotIn(Collection<Age> ages) | … where x.age not in ?1 |
True | findByActiveTrue() | … where x.active = true |
False | findByActiveFalse() | … where x.active = false |
IgnoreCase忽略带大小写 | findByFirstnameIgnoreCase | … where UPPER(x.firstname) = UPPER(?1)讲请求参数和表格参数都转化成大写格式进行对比 |
Like和Containing的区别：
Like和Containing都是用于模糊查询的，但是它们的查询方式不同。
Like是使用%来匹配任意字符的，比如findByFirstnameLike，%可以匹配任意字符，比如%a%可以匹配a、ab、abc、abcd等等。
Containing是使用*来匹配任意字符的，比如findByFirstnameContaining，*可以匹配任意字符，比如*a*可以匹配a、ab、abc、abcd等等。
所以，如果需要精确匹配，可以使用=，如果需要模糊匹配，可以使用Like或者Containing。
2、分页查询#
1
2
3
4
5
6
| @GetMapping("/page")
public Page<User> findAll(@RequestParam(defaultValue = "0") Integer page,
@RequestParam(defaultValue = "10") Integer size) {
Pageable pageable = PageRequest.of(page, size);
return userService.findAll(pageable);
}
|
注意：@RequestParam注解是用来接收请求参数的，defaultValue属性是用来设置默认值的，如果请求参数中没有该参数，则使用默认值。
3、排序查询#
1
2
3
4
5
6
7
8
9
10
| @GetMapping("/sort")
public List<User> findAll(@RequestParam(defaultValue = "id") String sort,
@RequestParam(defaultValue = "asc") String order) {
Sort.Direction direction = Sort.Direction.ASC;
if (order.equals("desc")) {
direction = Sort.Direction.DESC;
}
Sort sort1 = Sort.by(direction, sort);
return userService.findAll(sort1);
}
|
注意：@RequestParam注解是用来接收请求参数的，defaultValue属性是用来设置默认值的，如果请求参数中没有该参数，则使用默认值。
4、自定义查询#
1
2
3
4
5
6
7
8
9
10
| @GetMapping("/custom")
public List<User> findAll(@RequestParam(defaultValue = "id") String sort,
@RequestParam(defaultValue = "asc") String order) {
Sort.Direction direction = Sort.Direction.ASC;
if (order.equals("desc")) {
direction = Sort.Direction.DESC;
}
Sort sort1 = Sort.by(direction, sort);
return userService.findAll(sort1);
}
|
注意：@RequestParam注解是用来接收请求参数的，defaultValue属性是用来设置默认值的，如果请求参数中没有该参数，则使用默认值。
5、删除#
1
2
3
4
| @DeleteMapping("/{id}")
public void delete(@PathVariable Integer id) {
userService.delete(id);
}
|
注意：@PathVariable注解是用来接收路径参数的，id是路径参数的名称，如果请求路径为/user/1，则id的值为1。
6、修改#
1
2
3
4
| @PutMapping("/{id}")
public User update(@PathVariable Integer id, @RequestBody User user) {
return userService.update(id, user);
}
|
注意：@PathVariable注解是用来接收路径参数的，id是路径参数的名称，如果请求路径为/user/1，则id的值为1。@RequestBody注解是用来接收请求体的，user是请求体中的数据，会自动映射到User对象中。
7、添加#
1
2
3
4
| @PostMapping("/")
public User add(@RequestBody User user) {
return userService.add(user);
}
|
注意：@RequestBody注解是用来接收请求体的，user是请求体中的数据，会自动映射到User对象中。
8、查询#
1
2
3
4
| @GetMapping("/{id}")
public User findById(@PathVariable Integer id) {
return userService.findById(id);
}
|
注意：@PathVariable注解是用来接收路径参数的，id是路径参数的名称，如果请求路径为/user/1，则id的值为1。
9、查询所有#
1
2
3
4
| @GetMapping("/")
public List<User> findAll() {
return userService.findAll();
}
|
10、查询总数#
1
2
3
4
| @GetMapping("/count")
public Long count() {
return userService.count();
}
|
11、查询是否存在#
1
2
3
4
| @GetMapping("/exists/{id}")
public Boolean exists(@PathVariable Integer id) {
return userService.exists(id);
}
|
12、查询是否不存在#
1
2
3
4
| @GetMapping("/not-exists/{id}")
public Boolean notExists(@PathVariable Integer id) {
return userService.notExists(id);
}
|
13、查询第一个#
1
2
3
4
| @GetMapping("/first")
public User findFirst() {
return userService.findFirst();
}
|
14、查询最后一个#
1
2
3
4
| @GetMapping("/last")
public User findLast() {
return userService.findLast();
}
|
15、查询前N个#
1
2
3
4
| @GetMapping("/top/{n}")
public List<User> findTop(@PathVariable Integer n) {
return userService.findTop(n);
}
|
16、查询后N个#
1
2
3
4
| @GetMapping("/bottom/{n}")
public List<User> findBottom(@PathVariable Integer n) {
return userService.findBottom(n);
}
|
17、查询前N个并排序#
1
2
3
4
| @GetMapping("/top/{n}/{sort}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort) {
return userService.findTop(n, sort);
}
|
18、查询后N个并排序#
1
2
3
4
| @GetMapping("/bottom/{n}/{sort}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort) {
return userService.findBottom(n, sort);
}
|
19、查询前N个并排序并分页#
1
2
3
4
5
| @GetMapping("/top/{n}/{sort}/{page}/{size}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size) {
return userService.findTop(n, sort, page, size);
}
|
20、查询后N个并排序并分页#
1
2
3
4
5
| @GetMapping("/bottom/{n}/{sort}/{page}/{size}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size) {
return userService.findBottom(n, sort, page, size);
}
|
21、查询前N个并排序并分页并忽略大小写#
1
2
3
4
5
6
| @GetMapping("/top/{n}/{sort}/{page}/{size}/{ignoreCase}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase) {
return userService.findTop(n, sort, page, size, ignoreCase);
}
|
22、查询后N个并排序并分页并忽略大小写#
1
2
3
4
5
6
| @GetMapping("/bottom/{n}/{sort}/{page}/{size}/{ignoreCase}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase) {
return userService.findBottom(n, sort, page, size, ignoreCase);
}
|
23、查询前N个并排序并分页并忽略大小写并忽略空格#
1
2
3
4
5
6
7
| @GetMapping("/top/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace) {
return userService.findTop(n, sort, page, size, ignoreCase, ignoreWhitespace);
}
|
24、查询后N个并排序并分页并忽略大小写并忽略空格#
1
2
3
4
5
6
7
| @GetMapping("/bottom/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace) {
return userService.findBottom(n, sort, page, size, ignoreCase, ignoreWhitespace);
}
|
25、查询前N个并排序并分页并忽略大小写并忽略空格并忽略空值#
1
2
3
4
5
6
7
8
| @GetMapping("/top/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull) {
return userService.findTop(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull);
}
|
26、查询后N个并排序并分页并忽略大小写并忽略空格并忽略空值#
1
2
3
4
5
6
7
8
| @GetMapping("/bottom/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull) {
return userService.findBottom(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull);
}
|
27、查询前N个并排序并分页并忽略大小写并忽略空格并忽略空值并忽略排序#
1
2
3
4
5
6
7
8
9
| @GetMapping("/top/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}/{ignoreSort}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull,
@PathVariable Boolean ignoreSort) {
return userService.findTop(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull, ignoreSort);
}
|
28、查询后N个并排序并分页并忽略大小写并忽略空格并忽略空值并忽略排序#
1
2
3
4
5
6
7
8
9
| @GetMapping("/bottom/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}/{ignoreSort}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull,
@PathVariable Boolean ignoreSort) {
return userService.findBottom(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull, ignoreSort);
}
|
29、查询前N个并排序并分页并忽略大小写并忽略空格并忽略空值并忽略排序并忽略分页#
1
2
3
4
5
6
7
8
9
10
| @GetMapping("/top/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}/{ignoreSort}/{ignorePage}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull,
@PathVariable Boolean ignoreSort,
@PathVariable Boolean ignorePage) {
return userService.findTop(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull, ignoreSort, ignorePage);
}
|
30、查询后N个并排序并分页并忽略大小写并忽略空格并忽略空值并忽略排序并忽略分页#
1
2
3
4
5
6
7
8
9
10
| @GetMapping("/bottom/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}/{ignoreSort}/{ignorePage}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull,
@PathVariable Boolean ignoreSort,
@PathVariable Boolean ignorePage) {
return userService.findBottom(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull, ignoreSort, ignorePage);
}
|
31、查询前N个并排序并分页并忽略大小写并忽略空格并忽略空值并忽略排序并忽略分页并忽略总数#
1
2
3
4
5
6
7
8
9
10
11
| @GetMapping("/top/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}/{ignoreSort}/{ignorePage}/{ignoreCount}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull,
@PathVariable Boolean ignoreSort,
@PathVariable Boolean ignorePage,
@PathVariable Boolean ignoreCount) {
return userService.findTop(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull, ignoreSort, ignorePage, ignoreCount);
}
|
32、查询后N个并排序并分页并忽略大小写并忽略空格并忽略空值并忽略排序并忽略分页并忽略总数#
1
2
3
4
5
6
7
8
9
10
11
12
| @GetMapping("/bottom/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}/{ignoreSort}/{ignorePage}/{ignoreCount}")
public List<User> findBottom(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull,
@PathVariable Boolean ignoreSort,
@PathVariable Boolean ignorePage,
@PathVariable Boolean ignoreCount) {
return userService.findBottom(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull, ignoreSort, ignorePage, ignoreCount);
}
|
33、查询前N个并排序并分页并忽略大小写并忽略空格并忽略空值并忽略排序并忽略分页并忽略总数并忽略是否存在#
1
2
3
4
5
6
7
8
9
10
11
12
| @GetMapping("/top/{n}/{sort}/{page}/{size}/{ignoreCase}/{ignoreWhitespace}/{ignoreNull}/{ignoreSort}/{ignorePage}/{ignoreCount}/{ignoreExists}")
public List<User> findTop(@PathVariable Integer n, @PathVariable String sort,
@PathVariable Integer page, @PathVariable Integer size,
@PathVariable Boolean ignoreCase,
@PathVariable Boolean ignoreWhitespace,
@PathVariable Boolean ignoreNull,
@PathVariable Boolean ignoreSort,
@PathVariable Boolean ignorePage,
@PathVariable Boolean ignoreCount,
@PathVariable Boolean ignoreExists) {
return userService.findTop(n, sort, page, size, ignoreCase, ignoreWhitespace, ignoreNull, ignoreSort, ignorePage, ignoreCount, ignoreExists);
}
|
联表查询#
可以使用OneToOne、OneToMany、ManyToOne、ManyToMany、SelfReference注解来实现联表查询。也可以zhi使用@Query注解来实现联表查询。
1、一对一查询#
1
2
3
4
| public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u join fetch u.address a where a.city =?1")
List<User> findByAddressCity(String city);
}
|
2、一对多查询#
1
2
3
4
| public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u join fetch u.orders o where o.status =?1")
List<User> findByOrdersStatus(String status);
}
|
3、多对多查询#
1
2
3
4
| public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u join fetch u.roles r where r.name =?1")
List<User> findByRolesName(String name);
}
|
4、自关联查询#
1
2
3
4
| public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u join fetch u.spouse s where s.name =?1")
List<User> findBySpouseName(String name);
}
|
5、子查询#
1
2
3
4
| public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u where u.age > (select avg(a.age) from User a)")
List<User> findByAgeGreaterThanAverageAge();
}
|
6、分页查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
Page<User> findByAgeGreaterThan(int age, Pageable pageable);
}
|
7、排序查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByAgeGreaterThan(int age, Sort sort);
}
|
8、投影查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
List<UserProjection> findByAgeGreaterThan(int age);
}
|
9、聚合查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
int countByAgeGreaterThan(int age);
}
|
10、分组查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByAgeGreaterThan(int age, GroupBy groupBy);
}
|
11、条件查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByAgeGreaterThan(int age, Specification<User> specification);
}
|
12、动态查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByAgeGreaterThan(int age, Query query);
}
|
13、批量查询#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
List<User> findAllById(List<Long> ids);
}
|
14、批量更新#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
int updateAgeById(int age, Long id);
}
|
15、批量删除#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
int deleteByIdIn(List<Long> ids);
}
|
16、批量插入#
1
2
3
| public interface UserRepository extends JpaRepository<User, Long> {
List<User> saveAll(List<User> users);
}
|
Spring Data JPA 联表查询：
https://www.doubao.com/thread/w39bf797ac48dc45d