66、Spring Data JPA 的基本功能--CRUD 和 分页

Spring Data JPA 的基本功能–CRUD 和 分页

★ Spring Data JPA开发

（1）配置数据源。
（2）配置JPA相关属性，这些属性由JpaProperties类负责处理。
     ——上面2步都在application.properties中配置即可。
（3）使用JPA注解定义实体类。
（4）继承CrudRepository或其子接口实现DAO组件，
     如要实现反应式DAO组件，继承ReactiveCrudRepository或其子接口。
     我们只需要开发DAO组件的接口，并不需要提供实现类。

   如果要做分页查询，需要使用Pageable参数，
   但Pageable有个实现类：PageRequest，调用它的of方法即可创建 Pageable对象     
1
2
3
4
5
6
7
8
9
10

代码演示：

1、创建项目，勾选这些jar包

application.properties 配置文件

User实体类

UserDao 接口

UserService 接口

UserServiceImpl 实现类

启动类进行测试：
因为这个项目没有添加web的jar包，所以不算是个web应用。所以直接再启动类这里进行测试

测试

测试新增和修改的功能
没有id，是新增

执行个有id的，且数据库有同样的id存在
执行个有id的，且数据库没有同样的id存在

查询

删除

分页：

完整代码：

application.properties

#配置连接数据源，这些配置由 DataSourceProperties 类负责处理
#SpringBoot 读取到这些配置信息后，会使用 AutoConfiguration 去容器中自动配置 DataSource Bean
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456

#配置 JPA 相关属性，由 JpaProperties 类负责处理
#SpringBoot 读取到这些配置信息后，会使用 AutoConfiguration 去容器中自动配置 EntityManagerFactory Bean
#JPA 底层就是依赖这个 EntityManagerFactory

#自动建表，只能true或者false
#spring.jpa.generate-ddl=true
#这个也是自动建表，不过比spring.jpa.generate-ddl更严谨，作用：如果已有数据表，无需创建，否则创建数据表
spring.jpa.hibernate.ddl-auto=update
#指定操作的数据库
spring.jpa.database=mysql
#是否在执行的时候显示sql语句
spring.jpa.show-sql=true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

User

package cn.ljh.app.domain;


import lombok.Data;

import javax.persistence.*;

//添加这个注解，让这个类变成实体类
@Entity
//指定表名，表明这个实体类映射到user_inf这张表
@Table(name = "user_inf")
@Data
public class User
{
    @Id
    @Column(name = "user_id") // 指定列名
    @GeneratedValue(strategy = GenerationType.IDENTITY)//指定主键的自动增长策略
    private Integer id;
    @Column(name = "user_name")
    private String name;
    //如果不用 @Column 指定列表，name表示列名和属性名一致
    private int age;
    private String password;

    public User()
    {
    }
    public User(String name, int age, String password)
    {
        this.name = name;
        this.age = age;
        this.password = password;
    }
}
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

UserDao

package cn.ljh.app.Dao;

import cn.ljh.app.domain.User;
import org.springframework.data.repository.PagingAndSortingRepository;


//CrudRepository 的第一个泛型参数是被操作的实体类型，第二个参数是实体的主键类型
public interface UserDao extends PagingAndSortingRepository<User,Integer>
{
    //这个接口无需书写任何代码，只要定义一个空的接口，该接口就能完成大量、通用的 CRUD 操作。
}

1
2
3
4
5
6
7
8
9
10
11
12

UserService

package cn.ljh.app.service;


import cn.ljh.app.domain.User;

import java.util.List;

public interface UserService
{
    //根据id获取一个User对象
    User getUserById(Integer id);

    //查询所有用户
    List<User> getAllUsers();

    //根据id删除用户
    void deleteUserById(Integer id);

    //新增和修改
    void  saveOrUpdateUser(User user);

    //分页查询 , pageNo: 要查询哪一页的页数 , pageSize: 每页显示的条数
    List<User> findUserByPage(int pageNo, int pageSize);
}

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

UserServiceImpl

package cn.ljh.app.service.impl;


import cn.ljh.app.Dao.UserDao;
import cn.ljh.app.domain.User;
import cn.ljh.app.service.UserService;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;


@Service
public class UserServiceImpl implements UserService
{
    private UserDao userDao;

    //构造器进行依赖注入
    public UserServiceImpl(UserDao userDao)
    {
        this.userDao = userDao;
    }


    //根据id获取一个User对象
    @Override
    public User getUserById(Integer id)
    {
        //findById 返回 Optional 值，可能为null
        Optional<User> optional = userDao.findById(id);
        //所以需要再get把数据获取出来，就不会出现null的情况
        User user = optional.get();
        return user;
    }

    //查询所有用户
    @Override
    public List<User> getAllUsers()
    {
        List<User> list = new ArrayList<>();
        //findAll 方法返回 Iterable 值，可将它收集到 List 之后再返回
        Iterable<User> users = userDao.findAll();
        //方式1：Lambda表达式
        //users.forEach(user -> list.add(user));
        //方式2：Lambda表达式的简化写法----方法引用
        users.forEach(list::add);
        return list;
    }

    //根据id删除用户
    @Override
    public void deleteUserById(Integer id)
    {
        userDao.deleteById(id);
    }

    //新增和修改
    @Override
    public void saveOrUpdateUser(User user)
    {
        //有id就是更新，没有则是插入
        userDao.save(user);
    }

    //分页查询 , pageNo: 要查询哪一页的页数 , pageSize: 每页显示的条数
    @Override
    public List<User> findUserByPage(int pageNo, int pageSize)
    {
        //分页对象，此处的pageNo是从0开始的，0代表第一页，所以这里的 pageNo 要 -1 。
        Pageable pageable = PageRequest.of(pageNo - 1, pageSize);
        //Page 包含了分页消息
        Page<User> users = userDao.findAll(pageable);
        //当前页数，因为pageNo-1，所以这里需要+1
        int number = users.getNumber()+1;
        System.err.println("总页数：" + users.getTotalPages());
        System.err.println("总条数：" + users.getTotalElements());
        System.err.println("当前第：" + number + " 页");
        System.err.println("当前页有：" + users.getNumberOfElements() + " 条数据");

        List<User> list = new ArrayList<>();
        users.forEach(list::add);
        return list;
    }


}

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

App

package cn.ljh.app;

import cn.ljh.app.domain.User;
import cn.ljh.app.service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.List;

@SpringBootApplication
public class App
{

    public static void main(String[] args)
    {
        ConfigurableApplicationContext ctx = SpringApplication.run(App.class, args);
        //根据类型获取bean
        UserService usBean = ctx.getBean(UserService.class);
//        usBean.saveOrUpdateUser(new User("小红",25,"12345"));
//        usBean.saveOrUpdateUser(new User("小橙",26,"12345"));
//        usBean.saveOrUpdateUser(new User("小黄",27,"12345"));
//        usBean.saveOrUpdateUser(new User("小绿",28,"12345"));
//        usBean.saveOrUpdateUser(new User("小青",29,"12345"));

//        User user = new User("小紫", 31, "1234");
//        user.setId(6);
//        usBean.saveOrUpdateUser(user);

        //根据id查询
//        System.err.println(usBean.getUserById(2));
        //查询所有
//        usBean.getAllUsers().forEach(System.err::println);

//        usBean.deleteUserById(6);
//        usBean.getAllUsers().forEach(System.err::println);

        //pageNo: 要查询哪一页的页数 , pageSize: 每页显示的条数
        //分页查询:查询第2页，每页显示3条记录
        List<User> userByPage = usBean.findUserByPage(3, 2);
        userByPage.forEach(System.err::println);
    }

}

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
41
42
43
44
45

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.ljh</groupId>
    <artifactId>spring_data_jpa</artifactId>
    <version>1.0.0</version>
    <name>spring_data_jpa</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67