创建一个SpringBoot项目，实现简朴的CRUD功能和分页查询 ...

背景

本博文主要是创建了一个新的SpringBoot项目，实现基本的增删改查，分页查询，带条件的分页查询功能。是方便初学者学习后端项目的一个比力清晰明了的实践代码，读者可根据博文，从本身动手创建一个新的SpringBoot项目，到使用PostMan测试基本请求，完完全全实践一遍，写出本身的代码，或者实现本身想要的功能。因为在这个过程中会碰到许多的题目，从JDK的版本选择到跑通SpringBoot项目，末了到乐成发起一个请求。所以，最好是本身练习一下，最终做到游刃有余。
环境的安装

本次SpringBoot项目主要用到，一是IDEA，二是MYSQL（服务端），三是DBeaver(一个数据库的客户端)，四是PostMan(用于发送HTTP请求)。
建议读者先按照MYSQL包，再按照DBeaver, 调通数据库以后，再开始编写项目。
MYSQL和DBeaver的安装和使用

mysql服务的安装按照以下这个教程装就好了。链接如下：https://blog.csdn.net/Sublime_16/article/details/124227417
必要注意的是，生成临时密码以后，千万要先复制到一个文本文件中，避免在启动服务的时间，终端已经关闭，没有临时密码，无法启动服务；我就是因为临时密码没有生存下来，结果后面又重新去生成这个临时密码。浪费了一些时间。
另外就是，打开终端的时间，使用管理员的身份运行。
DBeaver是一个免费的、通用的数据库管理工具，支持多种数据库系统，包罗 MySQL、PostgreSQL、SQLite、Oracle、SQL Server 等。它提供了图形界面和强大的功能，使用户可以或许连接、管理和操纵差别类型的数据库。安装和使用的链接如下：https://www.cnblogs.com/nigx128/p/Jf4QN.html
必要注意的是，如果出现了这样的报错，

可重新编辑连接，设置驱动属性为true。

另外就是在一开始建立一个数据库的时间，这里不要写具体的名称。数据库连接以后，再界说具体的数据库名，mydatabase

我们本次的建表语句如下：

1. -- mydatabase.student_info definition
3. CREATE TABLE `student_info` (
4.   `id` int NOT NULL AUTO_INCREMENT,
5.   `name` varchar(100) CHARACTER SET utf8mb3 NOT NULL DEFAULT '""',
6.   `address` varchar(100) CHARACTER SET utf8mb3 NOT NULL,
7.   `other` varchar(100) CHARACTER SET utf8mb3 NOT NULL,
8.   `age` int NOT NULL,
9.   PRIMARY KEY (`id`)
10. ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=macce;

复制代码

建好表以后，往表中添加如下示例数据。添加好的表数据如下

创建一个新的SpringBoot项目

1、新建一个project;
这边我们使用maven管理依赖，maven的依赖管理目次可以单独设置一个空目次，本身比力好找到的目次，有时间依赖下载失败，必要从这个目次中删除一些依赖文件；目次的设置可在项目生成以后在IDEA中进行设置。然后jdk的版本有8 就选择8， 没有的话，这里任意选一下，后面编译的时间，可以在IDEA中重新设置。

点击下一步，可以设置SpringBoot的版本。以及要在pom中引入哪些依赖包，方便我们后续写代码的时间调用。我这边简朴选了几个,如果还有要使用的依赖，直接勾选就行，或者项目建好后手动在pom添加也可以。

,
点击create, 并使用new windows打开，就得到一个新的SpringBoot项目。接下来就等候依赖下载乐成，下载乐成以后，maven的目次是这样的。本次项目的pom.xml文件如下：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
5.     <parent>
6.         <groupId>org.springframework.boot</groupId>
7.         <artifactId>spring-boot-starter-parent</artifactId>
8.         <version>2.5.6</version>
9.         <relativePath/>
10.     </parent>
11.     <groupId>com.example</groupId>
12.     <artifactId>demo3</artifactId>
13.     <version>0.0.1-SNAPSHOT</version>
14.     <name>demo3</name>
15.     <description>demo3</description>
16.     <url/>
17.     <licenses>
18.         <license/>
19.     </licenses>
20.     <developers>
21.         <developer/>
22.     </developers>
23.     <scm>
24.         <connection/>
25.         <developerConnection/>
26.         <tag/>
27.         <url/>
28.     </scm>
29.     <properties>
30.         <java.version>8</java.version>
31.     </properties>
32.     <dependencies>
33.         <dependency>
34.             <groupId>org.springframework.boot</groupId>
35.             <artifactId>spring-boot-starter-data-jpa</artifactId>
36.         </dependency>
37.         <dependency>
38.             <groupId>mysql</groupId>
39.             <artifactId>mysql-connector-java</artifactId>
40.         </dependency>
41.         <dependency>
42.             <groupId>org.springframework.boot</groupId>
43.             <artifactId>spring-boot-starter-web</artifactId>
44.         </dependency>
46.         <dependency>
47.             <groupId>org.projectlombok</groupId>
48.             <artifactId>lombok</artifactId>
49.             <optional>true</optional>
50.         </dependency>
52.         <dependency>
53.             <groupId>com.h2database</groupId>
54.             <artifactId>h2</artifactId>
55.             <scope>runtime</scope>
56.         </dependency>
57.         <dependency>
58.             <groupId>org.springframework.boot</groupId>
59.             <artifactId>spring-boot-starter-test</artifactId>
60.             <scope>test</scope>
61.         </dependency>
62.     </dependencies>
63. </project>

复制代码

配置文件 application.yml

配置文件中的数据库的用户名和密码都要和你实际进行数据库连接时配置的一样，url也是如此。
server.port: 8088 是tomcat的端口号。
com.mysql.cj.jdbc.Driver是一个驱动类，是MySQL Connector 驱动程序中的 JDBC 驱动类，用于在 Java 应用程序中建立与 MySQL 数据库的连接。 一旦建立了连接，JDBC 驱动类答应 Java 应用程序执行 SQL 查询、更新和其他数据库操纵。应用程序可以使用 JDBC API 与数据库进行通信，发送和接收数据。JDBC 驱动类还支持变乱管理。Java 应用程序可以使用 JDBC API 开启、提交或回滚变乱，确保数据库操纵的原子性、一致性、隔离性和持久性（ACID 属性）。在发生错误或非常时，驱动类也会生成适当的非常，应用程序可以捕获并处理这些非常。
加载驱动类是建立连接和执行数据库操纵的第一步！
url 指的是数据库连接的 URL，它用于指定要连接的数据库的位置和其他连接参数,localhost指的是当地的主机名，3306是mysql的默认端口号。mydatabase是要连接的数据库的名称。应用程序和数据库通信，起首会通过该url建立连接，不过root和password必要和数据库连接配置中严格一致，否则会连不到数据库。
有关hibernate 的这段配置意味着通过 JPA 和 Hibernate 配置了禁用自动 DDL（Data Definition Language）生成、打印执行的SQL语句到控制台，以及指定了 Hibernate 使用的 MySQL 数据库方言是 MySQL 5 的 InnoDB 存储引擎方言。use_jdbc_metadata_defaults参数当设置为 false 时，Hibernate 将不使用 JDBC 元数据的默认设置。
重点说明一下ddl-auto, 等于none是指Hibernate 不会实验自动创建、更新或删除数据库表结构。

1. server.port: 8088
2. spring:
3.   datasource:
4.     driver-class-name: com.mysql.cj.jdbc.Driver
5.     username: root
6.     password: 123456
7.     url: jdbc:mysql://localhost:3306/mydatabase
8.   jpa:
9.     hibernate:
10.       ddl-auto: none
11.     show-sql: true
12.     properties:
13.       hibernate:
14.         temp:
15.           use_jdbc_metadata_defaults: false
16.         dialect: org.hibernate.dialect.MySQL5InnoDBDialect

复制代码

业务代码

在Web后端应用程序中，Controller主要接收来自用户的请求并根据请求调用适当的业务逻辑（Service层），然后将处理结果返回给用户。
总结的说，Controller的作用是：1、接收请求；2、调用Service层的方法；3、参数解析，对请求头中的参数进行解析；4、返回响应结果。将处理结果封装成适当的响应（如HTML页面、JSON数据等）返回给客户端。我这边为了方便起见，直接调repository中的方法了，后续补充一个Service层。
1、先写一个Controller

1. package com.example.demo3.controller;
3. import com.example.demo3.repository.StudentEntity;
4. import com.example.demo3.repository.StudentRepository;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.data.domain.Page;
7. import org.springframework.data.domain.PageRequest;
8. import org.springframework.data.domain.Pageable;
9. import org.springframework.data.jpa.domain.Specification;
10. import org.springframework.web.bind.annotation.*;
12. import javax.persistence.criteria.CriteriaBuilder;
13. import javax.persistence.criteria.CriteriaQuery;
14. import javax.persistence.criteria.Predicate;
15. import javax.persistence.criteria.Root;
16. import java.util.List;
18. @RestController // 注意，该注解表明是是rest风格的API, 返回值通常是数据对象，Spring 将数据转换为JSON或者XML格式，返回给客户端。
19. // controller返回的是视图名称或者ModelAndView对象。需要配置@ReponseBody使用，即在方法的前面加上这个注解。
20. @RequestMapping("/student")
21. public class StudentController {
23.     @Autowired
24.     StudentRepository repository;
26.     //查, 通过姓名查询
27.     @RequestMapping(value = "/byname", method = {RequestMethod.GET})
28.     //@ResponseBody
29.     public List<StudentEntity> findByName(@RequestParam("name") String name) {
30.         return repository.findByName(name);
31.     }
32.     // 全部返回，线上我们一般都用分页查询，因为数据量比较大嘛。直接返回全部数据的接口用的很少或者几乎不用。
33.     @GetMapping(value = "/all")
34.     public List<StudentEntity> findAlls() {
35.         List<StudentEntity> all = repository.findAll();
36.         return all;
37.     }
39.     // 增
40.     @PostMapping(value = "/add")
41.     private String addOne(@RequestBody StudentEntity student){
42.         repository.save(student);
43.         return "学生" + student.getName() + "添加成功";
44.     }
46.     // 改
47.     @PutMapping(value = "/update")
48.     private String updateOne(@RequestBody StudentEntity student){
49.         repository.save(student);
50.         return "学生" + student.getName() + "修改成功";
51.     }
53.     // 删
54.     @DeleteMapping(value = "/delete")
55.     private String deleteOne(@RequestParam("id") Integer id) {
56.         repository.deleteById(id);
57.         return "学生" + id + "删除成功";
58.     }
60.     // 简单分页查询
61.     @GetMapping("/page")
62.     public Page<StudentEntity> findByPage(@RequestParam(value = "page", defaultValue = "0") int page, @RequestParam(value = "size", defaultValue = "2") Integer size) {
63.         Pageable pageable = PageRequest.of(page, size);
64.         return repository.findAll(pageable);
65.     }
67.     // 带条件复杂分页查询
68.     @GetMapping("/page2")
69.     public Page<StudentEntity> findByPage2(@RequestParam(value = "name") String name, @RequestParam(value = "age") Integer age, @RequestParam(value = "page", defaultValue = "0") int page, @RequestParam(value = "size", defaultValue = "2") Integer size) {
70.         Pageable pageable = PageRequest.of(page, size);
71.         Specification<StudentEntity> specification = prediacte(name, age);
72.         return repository.findAll(specification, pageable);
73.     }
75.     public static Specification<StudentEntity> prediacte(String name, Integer age) {
76.         return (Root<StudentEntity> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) -> {
77.             // 这边简单用name和age查询一下
78.             Predicate namePredicate = criteriaBuilder.equal(root.get("name"), name);
79.             Predicate agePredicate = criteriaBuilder.equal(root.get("age"), age);
80.             return criteriaBuilder.and(namePredicate, agePredicate);
81.         };
82.     }
83. }

复制代码

2、Repository
这个是dao层，主要是执行一些和数据库交互的功能。在和数据库交互的时间，我们要创建一个实体类Entity, 这边我们叫做StudentEntity实体对象，相应的，数据库里面也应该有和这个实体类一一映射的表。数据库中的表名就可以写在注解@Table里。
@Entity注解的作用如下。起首， @Entity的含义是用于标识一个java类作为JPA（java persistence api）实体类, 表示该类将映射到数据库中的表。也就是说，实体类和数据库表的映射关系由该注解的实现，此中的映射关系具体体现在：实体类的属性和数据库表的字段一一对应。
@id注解用于表示某个字段作为表的主键，每个表必须要显式界说一个主键。
@Column 注解是 JPA（Java Persistence API）中用于描述实体属性与数据库表列之间映射关系的注解。通过 @Column 注解，可以指定实体类属性与数据库表中列的映射细节，如列名、数据类型、长度、是否可为空等。即可以更精细地控制实体属性与数据库表列的映射关系。如代码所示，name中指定的列名和表中的对应起来，然后private 属性就可以任意取一个名字了，不过建议还是都对应起来。
StudentEntity

1. package com.example.demo3.repository;
3. import lombok.Data;
5. import javax.persistence.*;
7. @Entity
8. @Table(name = "student_info")
9. @Data
10. public class StudentEntity {
11.     @Id
12.     @Column(name = "id")
13.     @GeneratedValue(strategy = GenerationType.IDENTITY)
14.     private int id;
15.     @Column(name = "name")
16.     private String name;
17.     @Column(name = "age")
18.     private int age;
19.     @Column(name = "address")
20.     private String address;
21.     @Column(name = "other")
22.     private String other;
23. }

复制代码

以下是StudentRepository类，这边界说的几个方法都是直接调用Spring JPA 封装好的方法，可直接调用。如果碰到比力复杂的场景，我们也可以在这里写一个接口，再写接口方法的具体实现。

1. package com.example.demo3.repository;
3. import org.springframework.data.domain.Page;
4. import org.springframework.data.domain.Pageable;
5. import org.springframework.data.jpa.repository.JpaRepository;
6. import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
8. import java.util.List;
10. public interface StudentRepository extends JpaRepository<StudentEntity, Integer>, JpaSpecificationExecutor<StudentEntity> {
12.     List<StudentEntity> findByName(String name);
14.     List<StudentEntity> findAll();
16.     void deleteById(Integer id);
18.     Page<StudentEntity> findAll(Pageable pageable);
19. }

复制代码

测试结果

有两种测试方法，可以在网页端直接输入url发起HTTP请求，由于我们的HTTP请求中要使用对象，所以选择Postman会比力方便。
1、根据name查询

2、增加一个student

3、修改id=xx的学生的信息

4、删除id=xx的学生信息

5、分页查询

1. 我们默认的是取第0页的数据，每页取size个数据。 故"pageSize": 2,"pageNumber": 0。 totalPages指的是总共有多少条数据， "totalPages": 3指的是一共要分多少页。5条数据，每页2个数据，那么就是分3页。"sort"是分页时排序的属性。
2. {
3.     "content": [
4.         {
5.             "id": 1,
6.             "name": "小红",
7.             "age": 18,
8.             "address": "深圳市",
9.             "other": "女；本科毕业，程序员"
10.         },
11.         {
12.             "id": 2,
13.             "name": "小黑",
14.             "age": 29,
15.             "address": "广州市",
16.             "other": "男；本科毕业，程序员"
17.         }
18.     ],
19.     "pageable": {
20.         "sort": {
21.             "empty": true,
22.             "sorted": false,
23.             "unsorted": true
24.         },
25.         "offset": 0,
26.         "pageSize": 2,
27.         "pageNumber": 0,
28.         "paged": true,
29.         "unpaged": false
30.     },
31.     "totalElements": 5,
32.     "last": false,
33.     "totalPages": 3,
34.     "number": 0,
35.     "size": 2,
36.     "sort": {
37.         "empty": true,
38.         "sorted": false,
39.         "unsorted": true
40.     },
41.     "numberOfElements": 2,
42.     "first": true,
43.     "empty": false
44. }

复制代码

6、带条件的分页查询

1. {
2.     "content": [
3.         {
4.             "id": 2,
5.             "name": "小黑",
6.             "age": 29,
7.             "address": "广州市",
8.             "other": "男；本科毕业，程序员"
9.         }
10.     ],
11.     "pageable": {
12.         "sort": {
13.             "empty": true,
14.             "sorted": false,
15.             "unsorted": true
16.         },
17.         "offset": 0,
18.         "pageNumber": 0,
19.         "pageSize": 2,
20.         "unpaged": false,
21.         "paged": true
22.     },
23.     "last": true,
24.     "totalPages": 1,
25.     "totalElements": 1,
26.     "number": 0,
27.     "size": 2,
28.     "sort": {
29.         "empty": true,
30.         "sorted": false,
31.         "unsorted": true
32.     },
33.     "numberOfElements": 1,
34.     "first": true,
35.     "empty": false
36. }

复制代码

总结

后面我会加一个Service层。今天就先写这么多吧。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。