• SpringBoot-基础篇复习(全)

    本文包含SpringBoot基础篇的所有知识点，大家一起来学习吧，开启一段新的旅程，加油吧。springboot是由Picotal团队提供的全新框架，用来简化spring的搭建和开发过程的配置，因为spring的配置比较繁琐，故引入了springboot。

    目录

    一、springboot入门案例

    1.1、入门案例之IDEA联网版

    1.2、入门案例解析-parent

     1.3、入门案例解析-starter

     1.4、引导类

    1.5、内嵌Tomcat

     二、REST风格补充

    2.1、REST风格简介

     2.2、Restful风格入门案例

    2.3、Restful快速开发

     三、配置修改

    3.1、属性配置方式

    3.2、文件配置格式及优先级

    3.3、yaml基本语法规则

     3.4、yaml读取单一属性数据

    3.5、读取yaml全部属性数据

    3.6、读取yaml引用类型数据

    四、SpringBoot整合第三方技术

    4.1、整合junit

    4.2、整合MyBatis

    4.3、整合MyBatis-Plus

    4.4、整合Druid

    五、基于SpringBoot的SSMP案例整合

    5.1、案例实现方案分析

     5.2、模块创建

    5.3、快速创建实体类

    5.4、数据层快速开发

    5.5、分页查询

    5.6、数据层的按条件查询

    5.7、业务层的开发(crud)

    5.8、业务层的开发(基于MyBatis-Plus构建)

    5.9、表现层标准开发

    5.10、前后端协议联调

    一、springboot入门案例

    1.1、入门案例之IDEA联网版

    直接创建一个控制器，响应浏览器的请求，并在控制台打印，如下：

    1. import org.springframework.web.bind.annotation.GetMapping;
    2. import org.springframework.web.bind.annotation.RequestMapping;
    3. import org.springframework.web.bind.annotation.RestController;
    4.  
    5. @RestController
    6. @RequestMapping("/books")
    7. public class BookController {
    8.  
    9.     @GetMapping
    10.     public String getById(){
    11.         System.out.println("Springboot is running ...");
    12.         return "springboot is running ..." ;
    13.     }
    14. }

    启动Application：

    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3.  
    4. @SpringBootApplication
    5. public class DemoApplication {
    6.  
    7. 	public static void main(String[] args) {
    8. 		SpringApplication.run(DemoApplication.class, args);
    9. 	}
    10.  
    11. }
    12.

    1.2、入门案例解析-parent

    使用parent可以更好地管理依赖，快速引入依赖，防止 依赖冲突等。

     1.3、入门案例解析-starter

    使用starter一般可以包含多个多个依赖坐标，可以简化配置。

     1.4、引导类

    springboot的引导类是boot工程的执行入口，运行main方法就可以启动程序。springboot运行后初始化spring容器，扫描类所在的包和加载bean。

    1.5、内嵌Tomcat

    内嵌Tomcat，将Tomcat容器以对象的形式在SpringBoot容器中运行，如果不想用这个服务器，可以用exclusion排除掉，再添加新的服务器即可。

     二、REST风格补充

    2.1、REST风格简介

    REST全称是表现形式状态转换，其实就是设置访问资源的描述形式。

     REST风格是隐藏资源的访问行为的，一般的使用如下动作行为区分对资源做了何种操作。

     2.2、Restful风格入门案例

    请求就是隐藏了访问路径的具体动作，使用method指定访问动作即可。

     对于又请求参数的，需要设置路劲参数，具体如下：

    三种接收参数传递的注解，@PathVariable一般用于接收单个路径参数，@RequetBody一般用于接收封装好的json数据，最后一种用于接收非json数据，用的较少。

    使用Restful进行增删改查的代码如下：

    1. import com.domain.User;
    2. import org.springframework.stereotype.Controller;
    3. import org.springframework.web.bind.annotation.*;
    4.  
    5. @Controller
    6. public class UserController {
    7.     //保存用户信息
    8.     @RequestMapping(value = "/users",method = RequestMethod.POST)
    9.     @ResponseBody
    10.     public String save(){
    11.         System.out.println("user save ...");
    12.         return "{'module':'user save'}" ;
    13.     }
    14.     //删除指定id的用户信息
    15.     @RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
    16.     @ResponseBody
    17.     public String delete(@PathVariable Integer id){
    18.         System.out.println("user delete ...");
    19.         return "{'module':'user delete'}" ;
    20.     }
    21.     //添加用户数据
    22.     @RequestMapping(value = "/users", method = RequestMethod.PUT)
    23.     @ResponseBody
    24.     public String update(@RequestBody User user){
    25.         System.out.println("user update ...");
    26.         return "{'module':'user update'}" ;
    27.     }
    28.     //查询指定id的用户
    29.     @RequestMapping(value = "/users/{id}", method = RequestMethod.GET)
    30.     @ResponseBody
    31.     public String getById(@PathVariable Integer id){
    32.         System.out.println("user getById ...");
    33.         return "{'module':'user getById'}" ;
    34.     }
    35.     //查询所有用户的信息
    36.     @RequestMapping(value = "/users", method = RequestMethod.GET)
    37.     @ResponseBody
    38.     public String getAll(){
    39.         System.out.println("user getAll");
    40.         return "{'module':'user getAll'}" ;
    41.     }
    42.     
    43. }

    2.3、Restful快速开发

    两个注解，如下，是两个注解的组合。

    两外是请求映射注解的四个，如下：

    简化后的增删改查如下：

    1.  
    2. import com.domain.User;
    3. import org.springframework.web.bind.annotation.*;
    4.  
    5.  
    6. @RequestMapping("/users")
    7. @RestController //该注解是Controller和ResponseBody注解的组合
    8. public class UserController {
    9.     //保存用户信息
    10.     //@RequestMapping(method = RequestMethod.POST)
    11.     @PostMapping
    12.     public String save(){
    13.         System.out.println("user save ...");
    14.         return "{'module':'user save'}" ;
    15.     }
    16.     //删除指定id的用户信息
    17.     //@RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    18.     @DeleteMapping("/{id}")
    19.     public String delete(@PathVariable Integer id){
    20.         System.out.println("user delete ...");
    21.         return "{'module':'user delete'}" ;
    22.     }
    23.     //添加用户数据
    24.     //@RequestMapping( method = RequestMethod.PUT)
    25.     @PutMapping
    26.     public String update(@RequestBody User user){
    27.         System.out.println("user update ...");
    28.         return "{'module':'user update'}" ;
    29.     }
    30.     //查询指定id的用户
    31.     //@RequestMapping(value = "/{id}", method = RequestMethod.GET)
    32.     @GetMapping("/{id}")
    33.     public String getById(@PathVariable Integer id){
    34.         System.out.println("user getById ...");
    35.         return "{'module':'user getById'}" ;
    36.     }
    37.     //查询所有用户的信息
    38.    // @RequestMapping(method = RequestMethod.GET)
    39.     @GetMapping
    40.     public String getAll(){
    41.         System.out.println("user getAll");
    42.         return "{'module':'user getAll'}" ;
    43.     }
    44.  
    45. }

     三、配置修改

    3.1、属性配置方式

    直接在application.properties中修改就可以，比如修改服务器端口号，如下：

    1. #修改服务器端口号
    2. server.port=80

    3.2、文件配置格式及优先级

    springboot中有三种文件配置格式，三种都可以用，优先级properties>yml>yaml

    3.3、yaml基本语法规则

    就是简单的层级关系，注意冒号后面与数据之间需要一个空格即可。

    另外，在yaml中表示数组，可以使用减号作为开始，也可以直接用中括号，如下：

     3.4、yaml读取单一属性数据

    就是使用@Value进行读取单个数据，里面用$符号，遇到数组用中括号读取即可。

     演示代码如下：

    1. server:
    2.   port: 8080
    3.  
    4. lesson:
    5.   springboot
    6.  
    7. subject:
    8.   s1: English
    9.   s2: math
    10.  
    11. hobby:
    12.   - running
    13.   - basketball
    14.   - volleyball
    15.   - reading
    16.  
    17. movies: ['西红柿首富','你好李焕英']
    1. import org.springframework.beans.factory.annotation.Value;
    2. import org.springframework.web.bind.annotation.GetMapping;
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5.  
    6.  
    7. @RestController
    8. @RequestMapping("/books")
    9. public class BookController {
    10.     @Value("${lesson}")
    11.     private String lessonName ;
    12.  
    13.     @Value("${hobby[2]}")
    14.     private String hobby ;
    15.  
    16.     @Value("${subject.s2}")
    17.     private String subject ;
    18.  
    19.     @Value("${movies[1]}")
    20.     private String movies ;
    21.  
    22.  
    23.     @GetMapping("/print")
    24.     public String print(){
    25.         System.out.println(lessonName);
    26.         System.out.println(hobby);
    27.         System.out.println(subject);
    28.         System.out.println(movies);
    29.         return "success ！！！" ;
    30.     }
    31. }

    3.5、读取yaml全部属性数据

    使用Enviroment对象封装全部配置信息，使用@Autowired注解自动装配数据到Enviroment对象中。

    1. import org.springframework.beans.factory.annotation.Autowired;
    2. import org.springframework.core.env.Environment;
    3. import org.springframework.web.bind.annotation.GetMapping;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. @RestController
    8. @RequestMapping("/books")
    9. public class BookController {
    10.  
    11.  
    12.     //封装全部数据到Enviroment对象中
    13.     @Autowired
    14.     private Environment environment ;
    15.  
    16.     @GetMapping("/print")
    17.     public String print(){
    18.         System.out.println(environment.getProperty("lesson"));
    19.         System.out.println(environment.getProperty("hobby[1]"));
    20.         return "success ！！！" ;
    21.     }
    22. }

    3.6、读取yaml引用类型数据

    使用注解绑定配置信息到封装类，另外需要将封装类定义为bean，然后将bean注入。

     yaml文件的配置如下：

    1. datasource:
    2.   driver: com.mysql.jdbc.Driver
    3.   username: root
    4.   password: 123456

    将配置信息封装到类中，再将类变成bean，交给Spring管理。

    1.  
    2. import org.springframework.boot.context.properties.ConfigurationProperties;
    3. import org.springframework.stereotype.Component;
    4.  
    5. @Component //将该类变成bean，可以进行依赖注入
    6. @ConfigurationProperties(prefix = "datasource")  //绑定yaml文件中的datasource配置到该类中
    7. public class MyDataSource {
    8.     private String driver ;
    9.     private String username ;
    10.     private String password ;
    11.  
    12.     public String getDriver() {
    13.         return driver;
    14.     }
    15.  
    16.     public void setDriver(String driver) {
    17.         this.driver = driver;
    18.     }
    19.  
    20.     public String getUsername() {
    21.         return username;
    22.     }
    23.  
    24.     public void setUsername(String username) {
    25.         this.username = username;
    26.     }
    27.  
    28.     public String getPassword() {
    29.         return password;
    30.     }
    31.  
    32.     public void setPassword(String password) {
    33.         this.password = password;
    34.     }
    35.  
    36.     @Override
    37.     public String toString() {
    38.         return "MyDataSource{" +
    39.                 "driver='" + driver + '\'' +
    40.                 ", username='" + username + '\'' +
    41.                 ", password='" + password + '\'' +
    42.                 '}';
    43.     }
    44. }

    四、SpringBoot整合第三方技术

    4.1、整合junit

    springboot整合junit主要包含下面三个步骤，具体如下，其实第一步都是自动生成的。

     创建接口和实现类，并进行测试。

    1. public interface BookDao {
    2.     public void save() ;
    3. }
    4.  
    1. import org.springframework.stereotype.Repository;
    2.  
    3. @Repository
    4. public class BookImpl implements BookDao {
    5.  
    6.     @Override
    7.     public void save() {
    8.         System.out.println("save ...");
    9.     }
    10. }

    注入测试对象，调用测方法。

    1. import com.dao.BookDao;
    2. import org.junit.jupiter.api.Test;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.boot.test.context.SpringBootTest;
    5.  
    6. @SpringBootTest
    7. class DemoApplicationTests {
    8.  
    9. 	//注入要测试的对象
    10. 	@Autowired
    11. 	private BookDao bookDao ;
    12.  
    13. 	@Test
    14. 	void contextLoads() {
    15. 		//执行测试对象相应的方法
    16. 		bookDao.save();
    17. 	}
    18.  
    19. }

    注：若测试类如果存在于引导类的包或者子包中无需指定引导类。

    测试类不存在于引导类的包或者子包中需要使用classes属性执行引导类。

    4.2、整合MyBatis

    创建mybatis所需环境，在application.yml文件配置数据源，用于连接数据库。

    1. spring:
    2.   datasource:
    3.     driver-class-name: com.mysql.cj.jdbc.Driver
    4.     url: jdbc:mysql://localhost:3306/test
    5.     username: root
    6.     password: 123456

    创建一个Goods实体类，如下：

    1. public class Goods {
    2.     private Integer id ;
    3.     private String name ;
    4.     private Integer count ;
    5.     private Double price ;
    6.  
    7.     public Integer getId() {
    8.         return id;
    9.     }
    10.  
    11.     public void setId(Integer id) {
    12.         this.id = id;
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23.     public Integer getCount() {
    24.         return count;
    25.     }
    26.  
    27.     public void setCount(Integer count) {
    28.         this.count = count;
    29.     }
    30.  
    31.     public Double getPrice() {
    32.         return price;
    33.     }
    34.  
    35.     public void setPrice(Double price) {
    36.         this.price = price;
    37.     }
    38.  
    39.     @Override
    40.     public String toString() {
    41.         return "Goods{" +
    42.                 "id=" + id +
    43.                 ", name='" + name + '\'' +
    44.                 ", count=" + count +
    45.                 ", price=" + price +
    46.                 '}';
    47.     }
    48. }

    写个接口，添加Mapper注解映射，并标记为Bean对象。

    1. import com.mybatis02.domain.Goods;
    2. import org.apache.ibatis.annotations.Mapper;
    3. import org.apache.ibatis.annotations.Select;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. import java.util.List;
    7.  
    8. @Repository
    9. @Mapper
    10. public interface BookDao {
    11.     @Select("select * from product")
    12.     public List getAll() ;
    13. }

    在测试类中中注入bean，调用方法完成测试。

    1. import com.mybatis02.dao.BookDao;
    2. import com.mybatis02.dao.BookDaoImpl;
    3. import org.junit.jupiter.api.Test;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.test.context.SpringBootTest;
    6.  
    7. @SpringBootTest
    8. class Mybatis02ApplicationTests {
    9.  
    10. 	@Autowired
    11. 	private BookDao bookDao ;
    12.  
    13. 	@Test
    14. 	void contextLoads() {
    15. 		System.out.println(bookDao.getAll());
    16. 	}
    17.  
    18. }

    4.3、整合MyBatis-Plus

    创建mybatis-Plus所需环境，在application.yml文件中进行配置数据源。

    1. spring:
    2.   datasource:
    3.     driver-class-name: com.mysql.cj.jdbc.Driver
    4.     url: jdbc:mysql://localhost:3306/test
    5.     username: root
    6.     password: 123456

    创建实体类，如下：

    1.  
    2. public class Product {
    3.     private Integer id ;
    4.     private String name ;
    5.     private Integer count ;
    6.     private Double price ;
    7.  
    8.     public Integer getId() {
    9.         return id;
    10.     }
    11.  
    12.     public void setId(Integer id) {
    13.         this.id = id;
    14.     }
    15.  
    16.     public String getName() {
    17.         return name;
    18.     }
    19.  
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23.  
    24.     public Integer getCount() {
    25.         return count;
    26.     }
    27.  
    28.     public void setCount(Integer count) {
    29.         this.count = count;
    30.     }
    31.  
    32.     public Double getPrice() {
    33.         return price;
    34.     }
    35.  
    36.     public void setPrice(Double price) {
    37.         this.price = price;
    38.     }
    39.  
    40.     @Override
    41.     public String toString() {
    42.         return "Goods{" +
    43.                 "id=" + id +
    44.                 ", name='" + name + '\'' +
    45.                 ", count=" + count +
    46.                 ", price=" + price +
    47.                 '}';
    48.     }
    49. }

    定义数据层的接口和映射配置，直接继承BaseMapper类，就可以直接使用增删改查方法

    1.  
    2. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    3. import com.mybatisplus.domain.Product;
    4. import org.apache.ibatis.annotations.Mapper;
    5. import org.springframework.stereotype.Repository;
    6.  
    7. @Mapper
    8. @Repository
    9. public interface BookDao extends BaseMapper {
    10.  
    11. }

    将bean注入，完成测试。

    1.  
    2. import com.mybatisplus.dao.BookDao;
    3. import org.junit.jupiter.api.Test;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.test.context.SpringBootTest;
    6.  
    7. @SpringBootTest
    8. class MybatisplusApplicationTests {
    9.  
    10.     @Autowired
    11.     private BookDao bookDao ;
    12.  
    13.     @Test
    14.     void contextLoads() {
    15.         System.out.println(bookDao.selectById(1));
    16.     }
    17.  
    18. }

    4.4、整合Druid

    导入Druid对应的starter坐标，配置数据源，写个接口完成增删改查，最后测试。

    先导入druid的坐标，直接从该网站复制过来，放到pom.xml文件中。

    1. "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.0modelVersion>
    5. 	<parent>
    6. 		<groupId>org.springframework.bootgroupId>
    7. 		<artifactId>spring-boot-starter-parentartifactId>
    8. 		<version>2.7.5version>
    9. 		<relativePath/> 
    10. 	parent>
    11. 	<groupId>com.druidgroupId>
    12. 	<artifactId>demoartifactId>
    13. 	<version>0.0.1-SNAPSHOTversion>
    14. 	<name>druidname>
    15. 	<description>Demo project for Spring Bootdescription>
    16. 	<properties>
    17. 		<java.version>1.8java.version>
    18. 	properties>
    19. 	<dependencies>
    20. 		<dependency>
    21. 			<groupId>org.mybatis.spring.bootgroupId>
    22. 			<artifactId>mybatis-spring-boot-starterartifactId>
    23. 			<version>2.2.2version>
    24. 		dependency>
    25. 		
    26. 		<dependency>
    27. 			<groupId>com.alibabagroupId>
    28. 			<artifactId>druid-spring-boot-starterartifactId>
    29. 			<version>1.2.14version>
    30. 		dependency>
    31.  
    32.  
    33. 		<dependency>
    34. 			<groupId>com.mysqlgroupId>
    35. 			<artifactId>mysql-connector-jartifactId>
    36. 			<scope>runtimescope>
    37. 		dependency>
    38. 		<dependency>
    39. 			<groupId>org.springframework.bootgroupId>
    40. 			<artifactId>spring-boot-starter-testartifactId>
    41. 			<scope>testscope>
    42. 		dependency>
    43. 	dependencies>
    44.  
    45. 	<build>
    46. 		<plugins>
    47. 			<plugin>
    48. 				<groupId>org.springframework.bootgroupId>
    49. 				<artifactId>spring-boot-maven-pluginartifactId>
    50. 			plugin>
    51. 		plugins>
    52. 	build>
    53.  
    54. project>

    配置数据源，如下：

    1. spring:
    2.   datasource:
    3.     druid:
    4.       driver-class-name: com.mysql.cj.jdbc.Driver
    5.       url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC
    6.       username: root
    7.       password: 123456
    8.

    写个接口完成查找功能，然后测试即可。

    1. import com.druid.domain.Goods;
    2. import org.apache.ibatis.annotations.Mapper;
    3. import org.apache.ibatis.annotations.Select;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. import java.util.List;
    7.  
    8. @Repository
    9. @Mapper
    10. public interface BookDao {
    11.     @Select("select * from product")
    12.     public List getAll() ;
    13. }
    1.  
    2. import com.druid.dao.BookDao;
    3. import org.junit.jupiter.api.Test;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.test.context.SpringBootTest;
    6.  
    7. @SpringBootTest
    8. class DruidApplicationTests {
    9.  
    10. 	@Autowired
    11. 	private BookDao bookDao ;
    12.  
    13. 	@Test
    14. 	void contextLoads() {
    15. 		System.out.println(bookDao.getAll()) ;
    16. 	}
    17.  
    18. }

    五、基于SpringBoot的SSMP案例整合

    5.1、案例实现方案分析

     5.2、模块创建

    主要包含以下三步，在第1步是在创建springboot项目的时候导入相应的坐标，然后修改配置文件，我们不使用.properties的配置文件，我们使用.yml配置文件，同时我们修改端口号为80.

    5.3、快速创建实体类

    使用lombok可以简化开发，在pom.xml中加入lombok依赖，使用@Data注解就可以了，里面自动封装了setter和getter方法等，但是没有构造方法，如果需要还要自己写。

    1.  
    2. import lombok.Data;
    3.  
    4. @Data
    5. public class Product {
    6.     private Integer id ;
    7.     private String name ;
    8.     private Integer count ;
    9.     private Double price ;
    10.  
    11.     public Product() {
    12.     }
    13.  
    14.     public Product(Integer id, String name, Integer count, Double price) {
    15.         this.id = id;
    16.         this.name = name;
    17.         this.count = count;
    18.         this.price = price;
    19.     }
    20. }

    5.4、数据层快速开发

    首先导入mybatis-plus和druid坐标依赖，配置数据源，开发dao接口(直接继承BaseMapper)，最后在测试类进行测试增删改查的api。

    1）配置依赖坐标。

    1. "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.0modelVersion>
    5. 	<parent>
    6. 		<groupId>org.springframework.bootgroupId>
    7. 		<artifactId>spring-boot-starter-parentartifactId>
    8. 		<version>2.7.5version>
    9. 		<relativePath/> 
    10. 	parent>
    11. 	<groupId>com.itemsgroupId>
    12. 	<artifactId>itemartifactId>
    13. 	<version>0.0.1-SNAPSHOTversion>
    14. 	<name>itemname>
    15. 	<description>Demo project for Spring Bootdescription>
    16. 	<properties>
    17. 		<java.version>1.8java.version>
    18. 	properties>
    19. 	<dependencies>
    20. 		<dependency>
    21. 			<groupId>org.springframework.bootgroupId>
    22. 			<artifactId>spring-boot-starter-webartifactId>
    23. 		dependency>
    24. 		
    25. 		<dependency>
    26. 			<groupId>com.baomidougroupId>
    27. 			<artifactId>mybatis-plus-boot-starterartifactId>
    28. 			<version>3.5.2version>
    29. 		dependency>
    30.  
    31. 		
    32. 		<dependency>
    33. 			<groupId>com.alibabagroupId>
    34. 			<artifactId>druid-spring-boot-starterartifactId>
    35. 			<version>1.2.14version>
    36. 		dependency>
    37.  
    38. 		
    39. 		<dependency>
    40. 			<groupId>org.projectlombokgroupId>
    41. 			<artifactId>lombokartifactId>
    42. 		dependency>
    43.  
    44.  
    45.  
    46.  
    47. 		<dependency>
    48. 			<groupId>com.mysqlgroupId>
    49. 			<artifactId>mysql-connector-jartifactId>
    50. 			<scope>runtimescope>
    51. 		dependency>
    52. 		<dependency>
    53. 			<groupId>org.springframework.bootgroupId>
    54. 			<artifactId>spring-boot-starter-testartifactId>
    55. 			<scope>testscope>
    56. 		dependency>
    57. 	dependencies>
    58.  
    59. 	<build>
    60. 		<plugins>
    61. 			<plugin>
    62. 				<groupId>org.springframework.bootgroupId>
    63. 				<artifactId>spring-boot-maven-pluginartifactId>
    64. 			plugin>
    65. 		plugins>
    66. 	build>
    67.  
    68. project>

    2）配置数据源。

    1.  
    2. server:
    3.   port: 80
    4.  
    5. spring:
    6.   datasource:
    7.     druid:
    8.       driver-class-name: com.mysql.cj.jdbc.Driver
    9.       url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC
    10.       username: root
    11.       password: 123456
    12.  
    13.  
    14. #设置id默认自动递增
    15. mybatis-plus:
    16.   global-config:
    17.     db-config:
    18.       id-type: auto

    3）开发Dao接口

    1. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    2. import com.items.domain.Product;
    3. import org.apache.ibatis.annotations.Mapper;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. @Mapper
    7. @Repository
    8. public interface ProductDao extends BaseMapper {
    9.  
    10. }

    4）编写测试类，对Dao接口的增删改查方法进行测试。

    1.  
    2. import com.items.domain.Product;
    3. import org.junit.jupiter.api.Test;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.test.context.SpringBootTest;
    6.  
    7. @SpringBootTest
    8. class DaoApplicationTests {
    9.  
    10. 	@Autowired
    11. 	private ProductDao productDao ;
    12.  
    13. 	@Test
    14. 	void testGetById() { //按照id查询
    15. 		System.out.println(productDao.selectById(2)) ;
    16. 	}
    17.  
    18. 	@Test
    19. 	void testGetAll() { //查询所有
    20. 		System.out.println(productDao.selectList(null)) ;
    21. 	}
    22.  
    23. 	@Test
    24. 	void testSave(){ //添加
    25. 		//如果setter和getter方法不能用，需要在设置->插件中下载lombok的差件，重启IDE就可以劣
    26. 		Product product = new Product() ;
    27. 		product.setName("测试案例1");
    28. 		product.setCount(1234);
    29. 		product.setPrice(1234.0);
    30. 		productDao.insert(product) ;
    31. 	}
    32.  
    33. 	@Test
    34. 	void testUpdate(){ //修改
    35. 		Product product = new Product() ;
    36. 		product.setId(1);
    37. 		product.setName("修改id=1的案例");
    38. 		product.setCount(10000);
    39. 		product.setPrice(12000.00);
    40. 		productDao.updateById(product) ;
    41. 	}
    42.  
    43. 	@Test
    44. 	void testDelete(){ //删除指定数据行
    45. 		productDao.deleteById(11) ;
    46. 	}
    47.  
    48. }

    5.5、分页查询

    使用Ipage封装分页数据，分页操作依赖MyBatis-Plus的拦截器实现。

    设置拦截器，内部是动态拼接SQL语句。

    1. import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
    2. import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5.  
    6. @Configuration
    7. public class MPConfig {
    8.  
    9.     @Bean //将拦截器交给Spring管理
    10.     public MybatisPlusInterceptor mybatisPlusInterceptor(){
    11.         MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor() ;
    12.         mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
    13.         return mybatisPlusInterceptor ;
    14.     }
    15. }

    使用Ipage封装分页数据，并进行查询，如下：

    1.  
    2. 	@Test
    3. 	void testGetPage(){ //分页查询
    4. 		IPage page = new Page(1,5) ;
    5. 		productDao.selectPage(page,null) ;
    6. 	}

    5.6、数据层的按条件查询

    可以使用Querywrapper和LambdaQuerywrapper完成条件查询，所有查询封装成方法调用。

    1.  
    2. 	@Test
    3. 	void testGetBy1(){ //按条件查询方式1
    4. 		String name = "洗衣机" ;
    5. 		QueryWrapper queryWrapper = new QueryWrapper<>() ;
    6. 		queryWrapper.like(name!=null,"name","洗衣机") ;
    7. 		productDao.selectList(queryWrapper) ;
    8. 	}
    9. 	@Test
    10. 	void testGetBy2(){ //按条件查询方式2
    11. 		String name = "洗衣机" ;
    12. 		LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>() ;
    13. 		queryWrapper.like(name!=null,Product::getName,name) ;
    14. 		productDao.selectList(queryWrapper) ;
    15. 	}

    5.7、业务层的开发(crud)

    首先写业务层的接口，如下：

    1. import com.baomidou.mybatisplus.core.metadata.IPage;
    2. import com.items.domain.Product;
    3.  
    4. import java.util.List;
    5.  
    6. public interface ProductService {
    7.     Boolean save(Product product) ;
    8.     Boolean update(Product product) ;
    9.     Boolean delete(Integer id) ;
    10.     Product getById(Integer id) ;
    11.     List getAll() ;
    12.     IPage getPage(Integer currentPage, Integer pageSize) ;
    13. }

    将bean注入，根据接口，写具体的实现类，如下：

    1. import com.baomidou.mybatisplus.core.metadata.IPage;
    2. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    3. import com.items.dao.ProductDao;
    4. import com.items.domain.Product;
    5. import com.items.service.ProductService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.util.List;
    10.  
    11. @Service
    12. public class ProductServiceImpl implements ProductService {
    13.  
    14.     @Autowired
    15.     private ProductDao productDao ;
    16.  
    17.     @Override
    18.     public Boolean save(Product product) {
    19.         return productDao.insert(product) > 0 ;
    20.     }
    21.  
    22.     @Override
    23.     public Boolean update(Product product) {
    24.         return productDao.updateById(product) > 0 ;
    25.     }
    26.  
    27.     @Override
    28.     public Boolean delete(Integer id) {
    29.         return productDao.deleteById(id) > 0 ;
    30.     }
    31.  
    32.     @Override
    33.     public Product getById(Integer id) {
    34.         return productDao.selectById(id) ;
    35.     }
    36.  
    37.     @Override
    38.     public List getAll() {
    39.         return productDao.selectList(null) ;
    40.     }
    41.  
    42.     @Override
    43.     public IPage getPage(Integer currentPage, Integer pageSize) {
    44.         IPage page = new Page(currentPage,pageSize) ;
    45.         productDao.selectPage(page,null) ;
    46.         return page;
    47.     }
    48. }

    最后，编写测试类完成业务层的测试，如下：

    1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    3. import com.baomidou.mybatisplus.core.metadata.IPage;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    5. import com.items.dao.ProductDao;
    6. import com.items.domain.Product;
    7. import org.junit.jupiter.api.Test;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.boot.test.context.SpringBootTest;
    10.  
    11. @SpringBootTest
    12. class ServiceApplicationTests {
    13.  
    14. 	@Autowired
    15. 	private ProductService productService ;
    16.  
    17. 	@Test
    18. 	void testGetById() { //按照id查询
    19. 		System.out.println(productService.getById(1)) ;
    20. 	}
    21.  
    22. 	@Test
    23. 	void testGetAll() { //查询所有
    24. 		System.out.println(productService.getAll()) ;
    25. 	}
    26.  
    27. 	@Test
    28. 	void testSave(){ //添加
    29. 		//如果setter和getter方法不能用，需要在设置->插件中下载lombok的差件，重启IDE就可以劣
    30. 		Product product = new Product() ;
    31. 		product.setName("测试案例1");
    32. 		product.setCount(1234);
    33. 		product.setPrice(1234.0);
    34. 		productService.save(product) ;
    35. 	}
    36.  
    37. 	@Test
    38. 	void testUpdate(){ //修改
    39. 		Product product = new Product() ;
    40. 		product.setId(1);
    41. 		product.setName("修改id=1的案例");
    42. 		product.setCount(10000);
    43. 		product.setPrice(12000.00);
    44. 		productService.update(product) ;
    45. 	}
    46.  
    47. 	@Test
    48. 	void testDelete(){ //删除指定数据行
    49. 		productService.delete(10) ;
    50. 	}
    51.  
    52. 	@Test
    53. 	void testGetPage(){ //分页查询
    54. 		productService.getPage(1,5) ;
    55. 	}
    56.  
    57.  
    58. }

    5.8、业务层的开发(基于MyBatis-Plus构建)

    使用MP进行业务层的开发有业务层通用接口Iservice和业务层通用实现类ServiceImpl，可以帮助完成业务层的快速开发，可以在其继续添加方法，注意不要覆盖方法即可。

    1）继承Iservice接口就可以实现增删改查，内部不需要再写具体接口方法

    1. import com.baomidou.mybatisplus.extension.service.IService;
    2. import com.items.domain.Product;
    3.  
    4. public interface IProductService extends IService {
    5.     //这是追加的方法，原始的方法直接继承了，不用再写
    6.     Boolean insert(Product product) ;
    7.     Boolean modify(Product product) ;
    8.     Boolean delete(Integer id) ;
    9.     Product get(Integer id) ;
    10. }

    2）接口实现类，为了不重写所有的方法，可以直接继承ServiceImpl即可

    1. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    2. import com.items.dao.ProductDao;
    3. import com.items.domain.Product;
    4. import com.items.service.IProductService;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.stereotype.Service;
    7.  
    8. @Service
    9. public class ProductServiceImpl extends ServiceImpl implements IProductService {
    10.     //里面是追加方法的实现
    11.    @Autowired
    12.    private ProductDao productDao ;
    13.  
    14.     @Override
    15.     public Boolean insert(Product product) {
    16.         return productDao.insert(product) > 0 ;
    17.     }
    18.  
    19.     @Override
    20.     public Boolean modify(Product product) {
    21.         return productDao.updateById(product) > 0 ;
    22.     }
    23.  
    24.     @Override
    25.     public Boolean delete(Integer id) {
    26.         return productDao.deleteById(id) > 0 ;
    27.     }
    28.  
    29.     @Override
    30.     public Product get(Integer id) {
    31.         return productDao.selectById(id) ;
    32.     }
    33. }

    3）最后创建一个测试类进行测试，如下：

    1.  
    2. import com.baomidou.mybatisplus.core.metadata.IPage;
    3. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    4. import com.items.domain.Product;
    5. import org.junit.jupiter.api.Test;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.boot.test.context.SpringBootTest;
    8.  
    9. @SpringBootTest
    10. class Service1ApplicationTests {
    11.  
    12. 	@Autowired
    13. 	private IProductService iProductService ;
    14.  
    15. 	@Test
    16. 	void testGetById() { //按照id查询
    17. 		System.out.println(iProductService.getById(1)) ;
    18. 	}
    19.  
    20. 	@Test
    21. 	void testGetAll() { //查询所有
    22. 		System.out.println(iProductService.list()) ;
    23. 	}
    24.  
    25. 	@Test
    26. 	void testSave(){ //添加
    27. 		//如果setter和getter方法不能用，需要在设置->插件中下载lombok的差件，重启IDE就可以劣
    28. 		Product product = new Product() ;
    29. 		product.setName("测试案例1");
    30. 		product.setCount(1234);
    31. 		product.setPrice(1234.0);
    32. 		iProductService.save(product) ;
    33. 	}
    34.  
    35. 	@Test
    36. 	void testUpdate(){ //修改
    37. 		Product product = new Product() ;
    38. 		product.setId(1);
    39. 		product.setName("修改id=1的案例");
    40. 		product.setCount(10000);
    41. 		product.setPrice(12000.00);
    42. 		iProductService.updateById(product) ;
    43. 	}
    44.  
    45. 	@Test
    46. 	void testDelete(){ //删除指定数据行
    47. 		iProductService.removeById(15) ;
    48. 	}
    49.  
    50. 	@Test
    51. 	void testGetPage(){ //分页查询
    52. 		IPage page = new Page<>(1,5) ;
    53. 		iProductService.page(page) ;
    54. 		System.out.println(page.getCurrent());
    55. 		System.out.println(page.getSize());
    56. 		System.out.println(page.getTotal());
    57. 		System.out.println(page.getPages());
    58. 		System.out.println(page.getRecords());
    59. 	}
    60.  
    61.  
    62. }

    5.9、表现层标准开发

    基于Restful风格的变现层开发，新增POST,删除DELETE,修改PUT,查询GET，接收实体参数使用@RequestBody注解，接收路径变量参数使用@PathVariable注解。

    1. import com.baomidou.mybatisplus.core.metadata.IPage;
    2. import com.items.domain.Product;
    3. import com.items.service.IProductService;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.web.bind.annotation.*;
    6.  
    7. import java.util.List;
    8.  
    9. @RestController
    10. @RequestMapping("/products")
    11. public class ProductController {
    12.  
    13.     @Autowired
    14.     private IProductService productService ;
    15.  
    16.     @GetMapping
    17.     public List getAll() {
    18.         return productService.list() ;
    19.     }
    20.  
    21.     @PostMapping
    22.     public Boolean save(@RequestBody Product product){
    23.         return productService.save(product) ;
    24.     }
    25.  
    26.     @PutMapping
    27.     public Boolean update(@RequestBody Product product){
    28.         return productService.updateById(product) ;
    29.     }
    30.  
    31.     @DeleteMapping("/{id}")
    32.     public Boolean delete(@PathVariable Integer id){
    33.         return productService.removeById(id) ;
    34.     }
    35.  
    36.     @GetMapping("/{id}")
    37.     public Product getById(@PathVariable Integer id){
    38.         return productService.getById(id) ;
    39.     }
    40.  
    41.     //按条件查询页面数据
    42.     @GetMapping("/{currentPage}/{pageSize}")
    43.     public IPage getPage(@PathVariable Integer currentPage, @PathVariable Integer pageSize){
    44.         return productService.getPage(currentPage, pageSize) ;
    45.     }
    46.  
    47. }

    下面对表现层进行数据一致化处理，把所有的格式统一为一样的。我们需要设计表现层返回结果的模型类，用于前后端数据格式统一，也叫做前后端数据协议。

    将数据都返回成flag标记是否操作成功，object标记操作结果。

    1. import lombok.Data;
    2.  
    3. @Data //可以不用写setter和getter方法之类的
    4. public class R {
    5.     private Boolean flag ;
    6.     private Object data ;
    7.  
    8.     public R() {
    9.     }
    10.  
    11.     public R(Boolean flag) {
    12.         this.flag = flag;
    13.     }
    14.  
    15.     public R(Boolean flag, Object data) {
    16.         this.flag = flag;
    17.         this.data = data ;
    18.     }
    19. }
    1. import com.baomidou.mybatisplus.core.metadata.IPage;
    2. import com.items.domain.Product;
    3. import com.items.service.IProductService;
    4. import com.items.utils.R;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.web.bind.annotation.*;
    7.  
    8. import java.util.List;
    9.  
    10. @RestController
    11. @RequestMapping("/products")
    12. public class ProductController {
    13.  
    14.     @Autowired
    15.     private IProductService productService ;
    16.  
    17.     @GetMapping
    18.     public R getAll() {
    19.         return new R(true,productService.list()) ;
    20.     }
    21.  
    22.     @PostMapping
    23.     public R save(@RequestBody Product product){
    24.         return new R(productService.save(product)) ;
    25.     }
    26.  
    27.     @PutMapping
    28.     public R update(@RequestBody Product product){
    29.         return new R(productService.updateById(product)) ;
    30.     }
    31.  
    32.     @DeleteMapping("/{id}")
    33.     public R delete(@PathVariable Integer id){
    34.         return new R(productService.removeById(id)) ;
    35.     }
    36.  
    37.     @GetMapping("/{id}")
    38.     public R getById(@PathVariable Integer id){
    39.         return new R(true , productService.getById(id)) ;
    40.     }
    41.  
    42.     //按条件查询页面数据
    43.     @GetMapping("/{currentPage}/{pageSize}")
    44.     public R getPage(@PathVariable Integer currentPage, @PathVariable Integer pageSize){
    45.         return new R(true, productService.getPage(currentPage, pageSize)) ;
    46.     }
    47.  
    48. }

    5.10、前后端协议联调

    前端发送异步请求，调用后端接口。前端页面代码如下：

    1. html>
    2. <html>
    3.  
    4. <head>
    5.  
    6.     
    7.  
    8.     <meta charset="utf-8">
    9.  
    10.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
    11.  
    12.     <title>基于SpringBoot整合SSM案例title>
    13.  
    14.     <meta content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no" name="viewport">
    15.  
    16.     
    17.  
    18.     <link rel="stylesheet" href="../plugins/elementui/index.css">
    19.  
    20.     <link rel="stylesheet" href="../plugins/font-awesome/css/font-awesome.min.css">
    21.  
    22.     <link rel="stylesheet" href="../css/style.css">
    23.  
    24. head>
    25.  
    26. <body class="hold-transition">
    27.  
    28. <div id="app">
    29.  
    30.     <div class="content-header">
    31.  
    32.         <h1>仓库管理系统h1>
    33.  
    34.     div>
    35.  
    36.     <div class="app-container">
    37.  
    38.         <div class="box">
    39.  
    40.             <div class="filter-container">
    41.                 <el-input v-model="pagination.count" placeholder="数量" style="width: 200px;" class="filter-item">el-input>
    42.                 <el-input v-model="pagination.name" placeholder="名称" style="width: 200px;" class="filter-item">el-input>
    43.                 <el-input v-model="pagination.price" placeholder="价格" style="width: 200px;" class="filter-item">el-input>
    44.                 <el-button @click="getAll()" class="dalfBut">查询el-button>
    45.                 <el-button type="primary" class="butT" @click="handleCreate()">新建el-button>
    46.             div>
    47.  
    48.             <el-table size="small" current-row-key="id" :data="dataList" stripe highlight-current-row>
    49.  
    50.                 <el-table-column type="index" align="center" label="序号">el-table-column>
    51.  
    52.                 <el-table-column prop="count" label="数量" align="center">el-table-column>
    53.  
    54.                 <el-table-column prop="name" label="名称" align="center">el-table-column>
    55.  
    56.                 <el-table-column prop="price" label="价格" align="center">el-table-column>
    57.  
    58.                 <el-table-column label="操作" align="center">
    59.  
    60.                     <template slot-scope="scope">
    61.  
    62.                         <el-button type="primary" size="mini" @click="handleUpdate(scope.row)">编辑el-button>
    63.  
    64.                         <el-button type="danger" size="mini" @click="handleDelete(scope.row)">删除el-button>
    65.  
    66.                     template>
    67.  
    68.                 el-table-column>
    69.  
    70.             el-table>
    71.  
    72.             
    73.             
    74.             <div class="pagination-container">
    75.  
    76.                 <el-pagination
    77.                         class="pagiantion"
    78.  
    79.                         @current-change="handleCurrentChange"
    80.  
    81.                         :current-page="pagination.currentPage"
    82.  
    83.                         :page-size="pagination.pageSize"
    84.  
    85.                         layout="total, prev, pager, next, jumper"
    86.  
    87.                         :total="pagination.total">
    88.  
    89.                 el-pagination>
    90.  
    91.             div>
    92.  
    93.             
    94.  
    95.             <div class="add-form">
    96.  
    97.                 <el-dialog title="新增商品" :visible.sync="dialogFormVisible">
    98.  
    99.                     <el-form ref="dataAddForm" :model="formData" :rules="rules" label-position="right" label-width="100px">
    100.  
    101.                         <el-row>
    102.  
    103.                             <el-col :span="12">
    104.  
    105.                                 <el-form-item label="数量" prop="count">
    106.  
    107.                                     <el-input v-model="formData.count"/>
    108.  
    109.                                 el-form-item>
    110.  
    111.                             el-col>
    112.  
    113.                             <el-col :span="12">
    114.  
    115.                                 <el-form-item label="名称" prop="name">
    116.  
    117.                                     <el-input v-model="formData.name"/>
    118.  
    119.                                 el-form-item>
    120.  
    121.                             el-col>
    122.  
    123.                         el-row>
    124.  
    125.  
    126.                         <el-row>
    127.  
    128.                             <el-col :span="24">
    129.  
    130.                                 <el-form-item label="价格">
    131.  
    132.                                     <el-input v-model="formData.price" type="textarea">el-input>
    133.  
    134.                                 el-form-item>
    135.  
    136.                             el-col>
    137.  
    138.                         el-row>
    139.  
    140.                     el-form>
    141.  
    142.                     <div slot="footer" class="dialog-footer">
    143.  
    144.                         <el-button @click="cancel()">取消el-button>
    145.  
    146.                         <el-button type ="primary" @click="handleAdd()">确定el-button>
    147.  
    148.                     div>
    149.  
    150.                 el-dialog>
    151.  
    152.             div>
    153.  
    154.             
    155.  
    156.             <div class="add-form">
    157.  
    158.                 <el-dialog title="编辑检查项" :visible.sync="dialogFormVisible4Edit">
    159.  
    160.                     <el-form ref="dataEditForm" :model="formData" :rules="rules" label-position="right" label-width="100px">
    161.  
    162.                         <el-row>
    163.  
    164.                             <el-col :span="12">
    165.  
    166.                                 <el-form-item label="数量" prop="count">
    167.  
    168.                                     <el-input v-model="formData.count"/>
    169.  
    170.                                 el-form-item>
    171.  
    172.                             el-col>
    173.  
    174.                             <el-col :span="12">
    175.  
    176.                                 <el-form-item label="名称" prop="name">
    177.  
    178.                                     <el-input v-model="formData.name"/>
    179.  
    180.                                 el-form-item>
    181.  
    182.                             el-col>
    183.  
    184.                         el-row>
    185.  
    186.                         <el-row>
    187.  
    188.                             <el-col :span="24">
    189.  
    190.                                 <el-form-item label="价格">
    191.  
    192.                                     <el-input v-model="formData.price" type="textarea">el-input>
    193.  
    194.                                 el-form-item>
    195.  
    196.                             el-col>
    197.  
    198.                         el-row>
    199.  
    200.                     el-form>
    201.  
    202.                     <div slot="footer" class="dialog-footer">
    203.  
    204.                         <el-button @click="cancel()">取消el-button>
    205.  
    206.                         <el-button type="primary" @click="handleEdit()">确定el-button>
    207.  
    208.                     div>
    209.  
    210.                 el-dialog>
    211.  
    212.             div>
    213.  
    214.         div>
    215.  
    216.     div>
    217.  
    218. div>
    219.  
    220. body>
    221.  
    223.  
    224. <script src="../js/vue.js">script>
    225.  
    226. <script src="../plugins/elementui/index.js">script>
    227.  
    228. <script type ="text/javascript" src="../js/jquery.min.js">script>
    229.  
    230. <script src="../js/axios-0.18.0.js">script>
    231.  
    232. <script>
    233.     var vue = new Vue({
    234.         el: '#app',
    235.         data:{
    236.             dataList: [],//当前页要展示的列表数据
    237.             dialogFormVisible: false,//添加表单是否可见
    238.             dialogFormVisible4Edit:false,//编辑表单是否可见
    239.             formData: {},//表单数据
    240.             rules: {//校验规则
    241.                 count: [{ required: true, message: '必填项', trigger: 'blur' }],
    242.                 name: [{ required: true, message: '必填项', trigger: 'blur' }]
    243.             },
    244.             pagination: {//分页相关模型数据
    245.                 currentPage: 1,//当前页码
    246.                 pageSize:10,//每页显示的记录数
    247.                 total:0,//总记录数
    248.                 count: "",
    249.                 name: "",
    250.                 price: ""
    251.             }
    252.         },
    253.  
    254.         //钩子函数，VUE对象初始化完成后自动执行
    255.         created() {
    256.             this.getAll();
    257.         },
    258.  
    259.         methods: {
    260.            //分页查询
    261.             getAll() {
    262.                 // 组织参数，拼接url请求地址
    263.                 var paramStr = "?name=" + this.pagination.name
    264.                     + "&count=" + this.pagination.count
    265.                     + "&price=" + this.pagination.price;
    266.                 console.log(paramStr);
    267.                 axios.get("/products/" + this.pagination.currentPage + "/" + this.pagination.pageSize + paramStr).then(res => {
    268.                     // console.log(res.data);
    269.                     this.pagination.currentPage = res.data.data.current;
    270.                     this.pagination.pageSize = res.data.data.size;
    271.                     this.pagination.total = res.data.data.total;
    272.                     this.dataList = res.data.data.records;
    273.                 });
    274.             },
    275.             //切换页码
    276.             handleCurrentChange(currentPage) {
    277.                 // 修改页码值为当前选中的页码值
    278.                 this.pagination.currentPage = currentPage;
    279.                 // 执行查询
    280.                 this.getAll();
    281.             },
    282.  
    283.             //弹出添加窗口
    284.             handleCreate() {
    285.                 this.dialogFormVisible = true;
    286.                 this.resetForm();
    287.             },
    288.  
    289.             //重置表单
    290.             resetForm() {
    291.                 this.formData = {};
    292.             },
    293.  
    294.             //添加
    295.             handleAdd () {
    296.                 axios.post("/products", this.formData).then(res => {
    297.                     // 判断当前操作是否成功
    298.                     if(res.data.flag) {
    299.                         // 1.关闭弹层
    300.                         this.dialogFormVisible = false;
    301.                         this.$message.success(res.data.msg);
    302.                     } else {
    303.                         this.$message.error(res.data.msg);
    304.                     }
    305.                 }).finally(() => {
    306.                     // 2.重新加载数据
    307.                     this.getAll();
    308.                 });
    309.             },
    310.  
    311.             //取消
    312.             cancel(){
    313.                 this.dialogFormVisible = false;
    314.                 this.dialogFormVisible4Edit = false;
    315.                 this.$message.info("当前操作取消！");
    316.             },
    317.             // 删除
    318.             handleDelete(row) {
    319.                 // console.log(row);
    320.                 this.$confirm("删除的数据将不可恢复，是否继续？", "提示", {type : "info"}).then(() => {
    321.                     axios.delete("/products/" + row.id).then(res => {
    322.                         if (res.data.flag) {
    323.                             this.$message.success(res.data.msg);
    324.                         } else {
    325.                             this.$message.error(res.data.msg);
    326.                         }
    327.                     }).finally(() => {
    328.                         this.getAll();
    329.                     });
    330.                 }).catch(() => {
    331.                     this.$message.info("取消操作");
    332.                 });
    333.             },
    334.  
    335.             //弹出编辑窗口，以便于修改操作
    336.             handleUpdate(row) {
    337.                 // 发送异步请求
    338.                 axios.get("/products/" + row.id).then(res => {
    339.                     // console.log(res.data);
    340.                     if (res.data.flag && res.data.data != null) {
    341.                         this.dialogFormVisible4Edit = true;
    342.                         this.formData = res.data.data;
    343.                     } else {
    344.                         this.$message.error(res.data.msg);
    345.                     }
    346.                 }).finally(() => { //不管弹出与否，自动刷新
    347.                     this.getAll();
    348.                 });
    349.             },
    350.  
    351.             //修改
    352.             handleEdit() {
    353.                 axios.put("/products", this.formData).then(res => {
    354.                     // 判断当前操作是否成功
    355.                     if(res.data.flag) {
    356.                         // 1.关闭弹层
    357.                         this.dialogFormVisible4Edit = false;
    358.                         this.$message.success(res.data.msg);
    359.                     } else {
    360.                         this.$message.error(res.data.msg);
    361.                     }
    362.                 }).finally(() => {
    363.                     // 2.重新加载数据
    364.                     this.getAll();
    365.                 });
    366.             },
    367.  
    368.             //条件查询
    369.         }
    370.     })
    371.  
    372. script>
    373.  
    374. html>

    后端的代码做了修改，加了异常处理：

    1.  
    2. import org.springframework.web.bind.annotation.ExceptionHandler;
    3. import org.springframework.web.bind.annotation.RestControllerAdvice;
    4.  
    5. //作为SpringMVC的异常处理
    6. @RestControllerAdvice
    7. public class ExceptionAdvice {
    8.  
    9.     @ExceptionHandler //拦截异常信息
    10.     public R doException(Exception e){
    11.         e.printStackTrace();
    12.         return new R(false, "服务器故障，请您稍后再试！") ;
    13.     }
    14. }

    对于业务层的添加功能，增加了添加成功和添加失败的提示信息msg，直接在前端获取。

    1.     @PostMapping
    2.     public R save(@RequestBody Product product){
    3.         Boolean flag = productService.save(product) ;
    4.         return new R(flag, flag ? "添加成功" : "添加失败") ;
    5.     }
    1.  
    2.     public R(Boolean flag, String msg){
    3.         this.flag = flag ;
    4.         this.msg = msg ;
    5.     }

    对于按条件查询问题，在控制层引入了实体类product，并覆盖业务层的方法和实现类。

    1. //按条件查询页面数据
    2.     @GetMapping("/{currentPage}/{pageSize}")
    3.     public R getPage(@PathVariable Integer currentPage, @PathVariable Integer pageSize, Product product){
    4.         return new R(true, productService.getPage(currentPage, pageSize,product)) ;
    5.     }
     IPage getPage(Integer currentPage, Integer pageSize, Product product);
    1.     @Override
    2.     public IPage getPage(Integer currentPage, Integer pageSize, Product product) {
    3.         IPage iPage = new Page (currentPage,pageSize) ;
    4.         LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>() ;
    5.         lambdaQueryWrapper.like(Strings.isNotEmpty(product.getName()),Product::getName,product.getName()) ;
    6.         lambdaQueryWrapper.like(!(product.getCount() == null), Product::getCount, product.getCount()) ;
    7.         lambdaQueryWrapper.eq(!(product.getPrice() == null), Product::getPrice, product.getPrice()) ;
    8.         return productDao.selectPage(iPage, lambdaQueryWrapper) ;
    9.     }

    查询全部的数据页面如下：

     按数量查询如下：

    按名称查询如下：

     

    按价格查询如下：

     

    修改功能如下：

     

    删除功能如下：

     

    添加功能如下：

      

    最后的总结如下：

  • 相关阅读:
    状态管理Pinia
    财报解读：抢滩“睡眠经济”，麒盛科技如何制胜市场？
    原型-设计模式
    【Linux03-基本工具之VIM】Linux下的强大编辑器（附软件生态与yum）
    Python 例题（10）
    雷军的开源情怀
    实现打包后暴露可修改接口地址文件
    Python+Selenium做自动化测试
    SpringBoot+Jwt+Redis
    springboot+jsp+ssm助农系统农产品宣传网站设计
  • 原文地址：https://blog.csdn.net/nuist_NJUPT/article/details/127726184