【SpringBoot2 基础篇】学习笔记

文章目录

  • 前言
  • 1. 快速上手SpringBoot
    • 1.1 SpringBoot入门程序开发
      • 1.1.1 IDE创建工程
      • 1.1.2 官网创建工程
      • 1.1.3 基于阿里云创建项目
      • 1.1.4 手工创建项目
    • 1.2 浅谈入门程序工作原理
      • 1.2.1 parent
      • 1.2.2 starter
      • 1.2.3 引导类
      • 1.2.4 内嵌tomcat
  • 2. SpringBoot基础配置
    • 2.1 属性配置
    • 2.2 配置文件分类
    • 2.3 yaml文件
    • 2.4 yaml数据读取
  • 3. Rest
    • 3.1 REST简介
    • 3.2 REST风格简介
    • 3.3 REST入门案例
    • 3.4 REST快速开发
  • 4. 基于SpringBoot实现SSM整合
    • 4.1 整合JUnit
    • 4.2 整合MyBatis
    • 4.3 整合MyBatis-Plus
    • 4.4 整合Druid
    • 4.5 SSMP整合案例
      • 4.5.1 模块创建
      • 4.5.2 实体类开发
      • 4.5.3 数据层开发
      • 4.5.4 业务层开发
      • 4.5.5 表现层
      • 4.5.6 前后端协议联调
      • 4.5.7 功能开发
      • 4.5.8 SSMP整合总结

前言

SpringBoot 简介

  • SpringBoot是由Pivotal团队提供的全新框架,其设计目的是用来简化Spring应用的初始搭建以及开发过程
  • Spring程序缺点
    • 依赖设置繁琐
    • 配置繁琐
  • SpringBoot程序优点
    • 起步依赖(简化依赖配置)
    • 自动配置(简化常用工程相关配置)
    • 辅助功能(内置服务器,……)

1. 快速上手SpringBoot

创建SpringBoot工程的四种方式

  • 基于Idea创建SpringBoot工程
  • 基于官网创建SpringBoot工程
  • 基于阿里云创建SpringBoot工程
  • 手工创建Maven工程修改为SpringBoot工程`

1.1 SpringBoot入门程序开发

1.1.1 IDE创建工程

  • 创建新模块,选择Spring Initializr,并配置模块相关基础信息
    【SpringBoot2 基础篇】学习笔记_第1张图片
  • 选择当前模块需要使用的技术集
    【SpringBoot2 基础篇】学习笔记_第2张图片
    创建好之后,检查maven以及JDK。
  • 开发控制器类
//Rest模式
@RestController
@RequestMapping("/books")
public class BookController {
	@GetMapping
	public String getById(){
		System.out.println("springboot is running...");
		return "springboot is running...";
	}
}
  • 运行自动生成的Application类
    【SpringBoot2 基础篇】学习笔记_第3张图片
    最简单的SpringBoot入门案例:
    【SpringBoot2 基础篇】学习笔记_第4张图片
    【SpringBoot2 基础篇】学习笔记_第5张图片
    最简SpringBoot程序所包含的基础文件:
    • pom.xml文件
    • Application类

Spring程序与SpringBoot程序对比:

【SpringBoot2 基础篇】学习笔记_第6张图片

1.1.2 官网创建工程

如果IDEA无法联网,如何创建SpringBoot工程呢?

  1. 打开SpringBoot官网,选择Quickstart Your Project
  2. 创建工程,并保存项目
  3. 解压项目,通过IDE导入项目

基于SpringBoot官网创建项目,地址:SpringBoot官网
【SpringBoot2 基础篇】学习笔记_第7张图片

1.1.3 基于阿里云创建项目

  1. 选择start来源为自定义URL
  2. 输入阿里云start地址
  3. 创建项目

地址:https://start.aliyun.com
【SpringBoot2 基础篇】学习笔记_第8张图片
在这里插入图片描述

1.1.4 手工创建项目

  1. 创建普通Maven工程
  2. 继承spring-boot-starter-parent
  3. 添加依赖spring-boot-starter-web
  4. 制作引导类Application

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0modelVersion>
	<parent>
		<groupId>org.springframework.bootgroupId>
		<artifactId>spring-boot-starter-parentartifactId>
		<version>2.5.4version>
	parent>
		<groupId>com.itheimagroupId>
		<artifactId>springboot_01_03_quickstartartifactId>
		<version>1.0-SNAPSHOTversion>
	<dependencies>
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-webartifactId>
		dependency>
	dependencies>
project>

制作引导类Application

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

【SpringBoot2 基础篇】学习笔记_第9张图片

1.2 浅谈入门程序工作原理

1.2.1 parent

【SpringBoot2 基础篇】学习笔记_第10张图片
小结:

  1. 开发SpringBoot程序要继承spring-boot-starter-parent
  2. spring-boot-starter-parent中定义了若干个依赖管理
  3. 继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突
  4. 继承parent的形式也可以采用引入依赖的形式实现效果

1.2.2 starter

【SpringBoot2 基础篇】学习笔记_第11张图片

  • starter
    • SpringBoot中常见项目名称,定义了当前项目使用的所有依赖坐标,以达到减少依赖配置的目的
  • parent
    • 所有SpringBoot项目要继承的项目,定义了若干个坐标版本号(依赖管理,而非依赖),以达到减少依赖冲突的目的
    • spring-boot-starter-parent各版本间存在着诸多坐标版本不同
  • 实际开发
    • 使用任意坐标时,仅书写GAV中的G和A,V由SpringBoot提供,除非SpringBoot未提供对应版本V
    • 如发生坐标错误,再指定Version(要小心版本冲突)

小结:

  1. 开发SpringBoot程序需要导入坐标时通常导入对应的starte
  2. 每个不同的starter根据功能不同,通常包含多个依赖坐标
  3. 使用starter可以实现快速配置的效果,达到简化配置的目的

1.2.3 引导类

  • 启动方式
    @SpringBootApplication
    public class Springboot01QuickstartApplication {
    	public static void main(String[] args) {
    		SpringApplication.run(Springboot01QuickstartApplication.class, args);
    	}
    }
    
  • SpringBoot的引导类是Boot工程的执行入口,运行main方法就可以启动项目
  • SpringBoot工程运行后初始化Spring容器,扫描引导类所在包加载bean

小结:

  • SpringBoot工程提供引导类用来启动程序
  • SpringBoot工程启动后创建并初始化Spring容器

1.2.4 内嵌tomcat

【SpringBoot2 基础篇】学习笔记_第12张图片
使用maven依赖管理变更起步依赖项

<dependencies>
	<dependency>
		<groupId>org.springframework.bootgroupId>
		<artifactId>spring-boot-starter-webartifactId>
		
		<exclusions>
			<exclusion>
				<groupId>org.springframework.bootgroupId>
				<artifactId>spring-boot-starter-tomcatartifactId>
			exclusion>
		exclusions>
	dependency>

	<dependency>
		<groupId>org.springframework.bootgroupId>
		<artifactId>spring-boot-starter-jettyartifactId>
	dependency>
dependencies>

Jetty比Tomcat更轻量级,可扩展性更强(相较于Tomcat),谷歌应用引擎(GAE)已经全面切换为Jetty

内置服务器:

  • tomcat(默认): apache出品,粉丝多,应用面广,负载了若干较重的组件
  • jetty:更轻量级,负载性能远不及tomcat
  • undertow:负载性能勉强跑赢tomcat

小结:

  1. 内嵌Tomcat服务器是SpringBoot辅助功能之一
  2. 内嵌Tomcat工作原理是将Tomcat服务器作为对象运行,并将该对象交给Spring容器管理
  3. 变更内嵌服务器思想是去除现有服务器,添加全新的服务器

总结:

  1. 入门案例(4种方式创建SpringBoot工程)
  2. SpringBoot概述
    • parent
    • starter
    • 引导类
    • 辅助功能(内嵌tomcat)

2. SpringBoot基础配置

2.1 属性配置

  • 修改服务器端口
    【SpringBoot2 基础篇】学习笔记_第13张图片

  • SpringBoot默认配置文件application.properties,通过键值对配置对应属性

  • 修改配置

    • 修改服务器端口
    • 关闭运行日志图标(banner)
    • 设置日志相关
#服务器端口配置
server.port=80
#关闭运行日志图标(banner)
spring.main.banner-mode=off
#设置日志相关
logging.level.root=debug

2.2 配置文件分类

【SpringBoot2 基础篇】学习笔记_第14张图片

SpringBoot提供了3种配置文件的格式:

  • properties(传统格式/默认格式)
  • yml(主流格式)
  • yaml

如果三种配置文件共存,则优先properties

  • SpringBoot配置文件加载顺序
    • application.properties > application.yml > application.yaml
  • 常用配置文件种类
    • application.yml

小结:

  1. 配置文件间的加载优先级
    • properties(最高)
    • yml
    • yaml(最低)
  2. 不同配置文件中相同配置按照加载优先级相互覆盖,不同配置文件中不同配置全部保留
    【SpringBoot2 基础篇】学习笔记_第15张图片
    【SpringBoot2 基础篇】学习笔记_第16张图片

2.3 yaml文件

【SpringBoot2 基础篇】学习笔记_第17张图片
yaml语法规则:
【SpringBoot2 基础篇】学习笔记_第18张图片
【SpringBoot2 基础篇】学习笔记_第19张图片
在这里插入图片描述
小结:

  1. yaml语法规则
    • 大小写敏感
    • 属性层级关系使用多行描述,每行结尾使用冒号结束
    • 使用缩进表示层级关系,同层级左侧对齐,只允许使用空格(不允许使用Tab键)
    • 属性值前面添加空格(属性名与属性值之间使用冒号+空格作为分隔)
    • #表示注释
  2. 注意属性名冒号后面与数据之间有一个空格
  3. 字面值、对象数据格式、数组数据格式(略)

2.4 yaml数据读取

【SpringBoot2 基础篇】学习笔记_第20张图片
【SpringBoot2 基础篇】学习笔记_第21张图片
【SpringBoot2 基础篇】学习笔记_第22张图片
如果数据量过大,可以封装全部数据到Environment对象

【SpringBoot2 基础篇】学习笔记_第23张图片
读取yaml引用类型属性数据:

  1. 定义数据模型封装yaml文件中对应的数据
  2. 定义为spring管控的bean(@Component)
  3. 指定加载的数据(@ConfigurationProperties)

【SpringBoot2 基础篇】学习笔记_第24张图片

@Component
@ConfigurationProperties(prefix = "datasource")
public class MyDataSource {
    private String drive;
    private String url;
    private String username;
    private String password;

    public MyDataSource() {
    }

    public MyDataSource(String drive, String url, String username, String password) {
        this.drive = drive;
        this.url = url;
        this.username = username;
        this.password = password;
    }

    public String getDrive() {
        return drive;
    }

    public void setDrive(String drive) {
        this.drive = drive;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "MyDataSource{" + "drive='" + drive + '\'' + ", url='" + url + '\'' + ", username='" + username + '\'' + ", password='" + password + '\'' + '}';
    }
}

小结:

  1. 使用@Value配合SpEL读取单个数据
  2. 如果数据存在多层级,依次书写层级名称即可
  3. 在配置文件中可以使用 ${属性名} 方式引用属性值
  4. 如果属性中出现特殊字符,可以使用双引号包裹起来作为字符解析
  5. 使用Environment对象封装全部配置信息
  6. 使用@Autowired自动装配数据到Environment对象中
  7. 使用@ConfigurationProperties注解绑定配置信息到封装类中
  8. 封装类需要定义为Spring管理的bean,否则无法进行属性注入

3. Rest

3.1 REST简介

  • REST (Representational State Transfer),表现形式状态转换
    • 传统风格资源描述形式
      • http://localhost/user/getById?id=1
      • http://localhost/user/saveUser
    • REST风格描述形式
      • http: / / localhost/user/1
      • http: / / localhost/user
  • 优点:
    • 隐藏资源的访问行为,无法通过地址得知对资源是何种操作
    • 书写简化

3.2 REST风格简介

  • 按照REST风格访问资源时使用行为动作区分对资源进行了何种操作

    • http: / /localhost/users
      查询全部用户信息 GET(查询)
    • http: // localhost/users/1
      查询指定用户信息 GET(查询)
    • http: / / localhost/users
      添加用户信息 POST(新增/保存)
    • http: / / localhost/users
      修改用户信息 PUT(修改/更新)
    • http: / / localhost/users/1
      删除用户信息 DELETE(删除)
  • 根据REST风格对资源进行访问称为RESTful
    在这里插入图片描述
    小结:

    1. REST
    2. 动作4个
    3. RESTful

3.3 REST入门案例

【SpringBoot2 基础篇】学习笔记_第25张图片
【SpringBoot2 基础篇】学习笔记_第26张图片

名称:@RequestMapping

类型:方法注解

位置:SpringMVC控制器方法定义上方

作用:设置当前控制器方法请求访问路径

范例:

@RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user){
	system.out.println( "user save. . ." + user);
	return "{ 'module' : 'user save ' }";
}
  • 属性
    • value(默认)︰请求访问路径
    • method: http请求动作,标准动作 (GET/POST/PUT/DELETE)

小结:

  • @RequestBody
  • @RequestParam
  • @PathVariable
  1. 区别

    @RequestParam用于接收url地址传参或表单传参

    @RequestBody用于接收json数据

    @PathVariable用于接收路径参数,使用{参数名称}描述路径参数

  2. 应用

    后期开发中,发送请求参数超过1个时,以json格式为主,@RequestBody应用较广

    如果发送非json格式数据,选用@RequestParam接收请求参数

    采用RESTful进行开发,当参数数量较少时,例如1个,可以采用@PathVariable接收请求路径变量,通常用于传递id值

3.4 REST快速开发

  • 名称:@RestController

  • 类型:类注解

  • 位置:基于SpringMVC的RESTful开发控制器类定义上方

  • 作用:设置当前控制器类为RESTful风格,等同于@Controller与@ResponseBody两个注解组合功能

  • 范例:

    @RestController
    public class BookController {}
    
  • 名称:@GetMapping @PostMapping @PutMapping @DeleteMapping

  • 类型:方法注解

  • 位置:基于SpringMVC的RESTful开发控制器方法定义上方
    作用:设置当前控制器方法请求访问路径与请求动作,每种对应一个请求动作,例如@GetMapping对应GET请求

  • 范例:

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
    	system.out.println( "book getById.. . "+id);
    	return "{'module' : 'book getById'}";
    }
    
  • 属性

    • value(默认)︰请求访问路径

小结:

  1. RESTful快速开发(标准开发)
  2. @RestController
  3. 标准请求动作映射(4种)

4. 基于SpringBoot实现SSM整合

4.1 整合JUnit

SpringBoot整合JUnit:

  • 名称:@SpringBootTest
  • 类型:测试类注解
  • 位置:测试类定义上方
  • 作用:设置JUnit加载的SpringBoot启动类
  • 相关属性
    • classes:设置SpringBoot启动类
@SpringBootTest
class Springboot04JunitApplicationTests {
    //1.注入你要测试的对象
    @Autowired
    private BookDao bookDao;

    @Test
    void contextLoads() {
        //2.执行要测试的对象对应的方法
        bookDao.save();
    }
}

小结:

  1. 导入测试对应的starter
  2. 测试类使用@SpringBootTest修饰
  3. 使用自动装配的形式添加要测试的对象

若是将测试类移到其他包,再运行,会出现以下错误:

【SpringBoot2 基础篇】学习笔记_第27张图片
原 因:当前的测试类并在引导类所在包或则子包下(不在同级目录),无法被扫描,测试类无法找到引导类。

@SpringBootTest(classes = Springboot04JunitApplication.class)
class Springboot04JunitApplicationTests {
}

注意事项:

如果测试类在SpringBoot启动类的包或子包中,可以省略启动类的设置,也就是省略classes的设定

小结:

  1. 测试类如果存在于引导类所在包或子包中无需指定引导类
  2. 测试类如果不存在于引导类所在的包或子包中需要通过classes属性指定引导类

4.2 整合MyBatis

【SpringBoot2 基础篇】学习笔记_第28张图片
【SpringBoot2 基础篇】学习笔记_第29张图片

【SpringBoot2 基础篇】学习笔记_第30张图片

【SpringBoot2 基础篇】学习笔记_第31张图片
【SpringBoot2 基础篇】学习笔记_第32张图片
小结:

  1. 勾选MyBatis技术,也就是导入MyBatis对应的starter
  2. 数据库连接相关信息转换成配置
  3. 数据库SQL映射需要添加@Mapper被容器识别到

4.3 整合MyBatis-Plus

MyBatis-Plus与MyBatis区别:

  • 导入坐标不同
  • 数据层实现简化
    【SpringBoot2 基础篇】学习笔记_第33张图片
    【SpringBoot2 基础篇】学习笔记_第34张图片其余和整合MyBatis相同。

小结:

  1. 手工添加MyBatis-Plus对应的starter
  2. 数据层接口使用BaseMapper简化开发
  3. 需要使用的第三方技术无法通过勾选确定时,需要手工添加坐标

4.4 整合Druid

  • 指定数据源类型(非整合)
spring:
  datasource:
	driver-class-name: com.mysql.cj.jdbc.Driver
	url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
	username: root
	password: root
	type: com.alibaba.druid.pool.DruidDataSource
  • 导入Druid对应的starter
<dependency>
	<groupId>com.alibabagroupId>
	<artifactId>druid-spring-boot-starterartifactId>
	<version>1.2.6version>
dependency>
  • 变更Druid的配置方式
spring:
  datasource:
	druid:
	  driver-class-name: com.mysql.cj.jdbc.Driver
	  url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
	  username: root
	  password: root

小结:

  1. 整合Druid需要导入Druid对应的starter
  2. 根据Druid提供的配置方式进行配置
  3. 整合第三方技术通用方式( 导入对应的starter,根据提供的配置格式,配置非默认值对应的配置项)

4.5 SSMP整合案例

  • 案例实现方案分析
    • 实体类开发——使用Lombok快速制作实体类
    • Dao开发——整合MyBatisPlus,制作数据层测试类
    • Service开发——基于MyBatisPlus进行增量开发,制作业务层测试类
    • Controller开发——基于Restful开发,使用PostMan测试接口功能
    • Controller开发——前后端开发协议制作
    • 页面开发——基于VUE+ElementUI制作,前后端联调,页面数据处理,页面消息处理
      • 列表、新增、修改、删除、分页、查询
    • 项目异常处理
    • 按条件查询——页面功能调整、Controller修正功能、Service修正功能

4.5.1 模块创建

  • 勾选SpringMVC与MySQL坐标

  • 导入MyBatis-Plus和Druid坐标

    <dependency>
          <groupId>com.alibabagroupId>
          <artifactId>druid-spring-boot-starterartifactId>
          <version>1.1.23version>
      dependency>
    
      <dependency>
          <groupId>com.baomidougroupId>
          <artifactId>mybatis-plus-boot-starterartifactId>
          <version>3.4.2version>
      dependency>
    
  • 修改配置文件为yml格式

  • 设置端口为80方便访问

    server:
      port: 80
    

4.5.2 实体类开发

Lombok,一个Java类库,提供了一组注解,简化POJO实体类开发

<dependency>
	<groupId>org.projectlombokgroupId>
	<artifactId>lombokartifactId>
dependency>

常用注解:@Data

为当前实体类在编译期设置对应的get/set方法,toString方法,hashCode方法,equals方法等

@Data
public class Book {
	private Integer id;
	private String type;
	private String name;
	private String description;
}

4.5.3 数据层开发

  • 导入MyBatisPlus与Druid对应的starter(模块创建时已导入)
  • 继承BaseMapper并指定泛型
    @Mapper
    public interface BookDao extends BaseMapper<Book> {
    }
    
  • 制作测试类测试结果
    @SpringBootTest
    public class BookDaoTest {
    	@Autowired
    	private BookDao bookDao;
    	@Test
    	void testSave() {
    		Book book = new Book();
    		book.setName("测试数据");
    		book.setType("测试类型");
    		book.setDescription("测试描述数据");
    		bookDao.insert(book);
    	}
    	@Test
    	void testGetById() {
    		System.out.println(bookDao.selectById(2));
    	}
    	...
    }
    

注意:如果这里直接运行testSave方法,会出现以下错误:

在这里插入图片描述

原因: 雪花算法丢失精度

解决方法:配置数据源与MyBatisPlus对应的基础配置(id生成策略使用数据库自增策略

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tb1_
      id-type: auto

为方便调试可以开启MyBatisPlus的日志

mybatis-plus:
  configuration:
	log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

分页

分页操作需要设定分页对象IPage

    @Test
    void testGetPage() {
        IPage page = new Page(1,2);
        bookDao.selectPage(page, null);
    }
  • IPage对象中封装了分页操作中的所有数据
    • 数据
    • 当前页码值
    • 每页数据总量
    • 最大页码值
    • 数据总量

如果直接在测试类这么写,会出现以下问题:

【SpringBoot2 基础篇】学习笔记_第35张图片

由于我的数据比较少,如果数据比较多,会全部显示出来,而不是出现分页的效果,可以看到sql语句尾部缺少了limit,因为无法做到分页。想要分页,必须使用拦截器(分页操作是在MyBatisPlus的常规操作基础上增强得到,内部是动态的拼写SQL语句,因此需要增强对应的功能,使用MyBatisPlus拦截器实现

@Configuration
public class MPConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
   		//定义Mp拦截器
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //添加具体的拦截器
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

结果如下:

【SpringBoot2 基础篇】学习笔记_第36张图片

小结:

  1. 使用IPage封装分页数据
  2. 分页操作依赖MyBatisPlus分页拦截器实现功能
  3. 借助MyBatisPlus日志查阅执行SQL语句

条件查询

使用QueryWrapper对象封装查询条件,推荐使用LambdaQueryWrapper对象,所有查询操作封装成方法调用

@Test
void testGetByCondition(){
	IPage page = new Page(1,2);
	LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
	lqw.like(Book::getName,"Spring");
	bookDao.selectPage(page,lqw);
}
@Test
void testGetByCondition(){
	QueryWrapper<Book> qw = new QueryWrapper<Book>();
	qw.like("name","Spring");
	bookDao.selectList(qw);
}

4.5.4 业务层开发

  • Service层接口定义与数据层接口定义具有较大区别,不要混用

    • selectByUserNameAndPassword(String username,String password); //数据层
    • login(String username,String password); //业务层
  • 接口定义

    public interface BookService {
    	boolean save(Book book);
    	boolean delete(Integer id);
    	boolean update(Book book);
    	Book getById(Integer id);
    	List<Book> getAll();
    	IPage<Book> getByPage(int currentPage,int pageSize);
    }
    
  • 实现类定义

    @Service
    public class BookServiceImpl implements BookService {
    	@Autowired
    	private BookDao bookDao;
    	
    	//大于0,是因为测出来结果是修改的行数
    	public Boolean save(Book book) {
    	return bookDao.insert(book) > 0;
    	}
    	
    	public Boolean delete(Integer id) {
    	return bookDao.deleteById(id) > 0;
    	}
    	
    	public Boolean update(Book book) {
    	return bookDao.updateById(book) > 0;
    	}
    }
    
  • 测试类定义

    @SpringBootTest
    public class BookServiceTest {
    	@Autowired
    	private BookService bookService;
    	
    	@Test
    	void testGetById(){
    	bookService.getById(9);
    	}
    	
    	@Test
    	void testGetAll(){
    	bookService.getAll();
    	}
    	
    	@Test
    	void testGetByPage(){
    	bookService.getByPage(1,5);
    	}
    }
    

快速开发

  • 快速开发方案
    • 使用MyBatisPlus提供有业务层通用接口(ISerivce)与业务层通用实现(ServiceImpl
    • 在通用类基础上做功能重载或功能追加
    • 注意重载时不要覆盖原始操作,避免原始提供的功能丢失
      【SpringBoot2 基础篇】学习笔记_第37张图片
  • 接口定义
    【SpringBoot2 基础篇】学习笔记_第38张图片
  • 实现类定义
@Service
public class BookServiceImpl2 extends ServiceImpl<BookDao,Book> implements IBookService {
}
  • 实现类追加功能
@Service
public class BookServiceImpl2 extends ServiceImpl<BookDao,Book> implements IBookService {
	@Autowired
	private BookDao bookDao;
	
	public Boolean insert(Book book) {
		return bookDao.insert(book) > 0;
	}
	
	public Boolean modify(Book book) {
		return bookDao.updateById(book) > 0;
	}
	
	public Boolean delete(Integer id) {
		return bookDao.deleteById(id) > 0;
	}
	
	public Book get(Integer id) {
		return bookDao.selectById(id);
	}
}

总结小结:

  1. 使用通用接口(ISerivce)快速开发Service
  2. 使用通用实现类(ServiceImpl)快速开发ServiceImpl
  3. 可以在通用接口基础上做功能重载或功能追加
  4. 注意重载时不要覆盖原始操作,避免原始提供的功能丢失

业务层消息一致性处理

【SpringBoot2 基础篇】学习笔记_第39张图片

  • 对异常进行统一处理,出现异常后,返回指定信息
    //作为springmvc的异常处理器
    @RestControllerAdvice
    public class ProjectExceptionAdvice {
    	//拦截所有的异常信息
    	@ExceptionHandler(Exception.class)
    	public R doOtherException(Exception ex){
    		//记录日志
    		//发送消息给运维
    		//发送邮件给开发人员,ex对象发送给开发人员
    		ex.printStackTrace();
    		return new R(false,null,"系统错误,请稍后再试!");
    	}
    }
    
  • 修改表现层返回结果的模型类,封装出现异常后对应的信息
    • flag:false
    • Data: null
    • 消息(msg): 要显示信息
    @Data
    public class R{
    	private Boolean flag;
    	private Object data;
    	private String msg;
    	public R(Boolean flag,Object data,String msg){
    		this.flag = flag;
    		this.data = data;
    		this.msg = msg;
    	}
    }
    
  • 页面消息处理,没有传递消息加载默认消息,传递消息后加载指定消息
    //添加
    handleAdd () {
    	//发送ajax请求
    	axios.post("/books",this.formData).then((res)=>{
    	//如果操作成功,关闭弹层,显示数据
    		if(res.data.flag){
    			this.dialogFormVisible = false;
    			this.$message.success("添加成功");
    		}else {
    			this.$message.error(res.data.msg);
    		}
    	}).finally(()=>{
    		this.getAll();
    	});
    },
    
  • 可以在表现层Controller中进行消息统一处理
@PostMapping
public R save(@RequestBody Book book) throws IOException {
	Boolean flag = bookService.insert(book);
	return new R(flag , flag ? "添加成功^_^" : "添加失败-_-!");
}
  • 页面消息处理
//添加
handleAdd () {
	//发送ajax请求
	axios.post("/books",this.formData).then((res)=>{
		if(res.data.flag){
			this.dialogFormVisible = false;
			this.$message.success(res.data.msg);
		}else {
			this.$message.error(res.data.msg);
		}
	}).finally(()=>{
		this.getAll();
	});
}

小结:

  1. 使用注解@RestControllerAdvice定义SpringMVC异常处理器用来处理异常
  2. 异常处理器必须被扫描加载,否则无法生效
  3. 表现层返回结果的模型类中添加消息属性用来传递消息到页面

4.5.5 表现层

表现层开发

  • 基于Restful进行表现层接口开发
  • 使用Postman测试表现层接口功能

【SpringBoot2 基础篇】学习笔记_第40张图片

【SpringBoot2 基础篇】学习笔记_第41张图片
【SpringBoot2 基础篇】学习笔记_第42张图片

小结:

  1. 基于Restful制作表现层接口
    • 新增:POST
    • 删除:DELETE
    • 修改:PUT
    • 查询:GET
  2. 接收参数
    • 实体数据:@RequestBody
    • 路径变量:@PathVariable

表现层消息一致性处理

【SpringBoot2 基础篇】学习笔记_第43张图片

【SpringBoot2 基础篇】学习笔记_第44张图片

【SpringBoot2 基础篇】学习笔记_第45张图片

  • 设计表现层返回结果的模型类,用于后端与前端进行数据格式统一,也称为前后端数据协议
    @Data
    public class R{
    	private Boolean flag;
    	private Object data;
    }
    
    public R(){}
    
    public R(Boolean flag){
    	this.flag = flag;
    }
    
    public R(Boolean flag,Object data){
    	this.flag = flag;
    	this.data = data;
    	}
    }
    
  • 表现层接口统一返回值类型结果
    @RestController
    @RequestMapping("/books")
    public class BookController {
    	 @Autowired
        private IBookService bookService;
    
         @GetMapping
    	public R getAll() {
        	return new R(true, bookService.list());
    	}
    
        @PostMapping
        public R save(@RequestBody Book book) {
    //        R r = new R();
    //        boolean flag = bookService.save(book);
    //        r.setFlag(flag);
    //		  return r;
    
            return new R(bookService.save(book));
        }
    
        @PutMapping
        public R update(@RequestBody Book book) {
            return new R(bookService.modify(book));
        }
    
        @DeleteMapping("{id}")
        public R delete(@PathVariable Integer id) {
            return new R(bookService.delete(id));
        }
    
        @GetMapping("{id}")
        public R getById(@PathVariable Integer id) {
            return new R(true, bookService.getById(id));
        }
    
        @GetMapping("{currentPage}/{PageSize}")
        public R getPage(@PathVariable int currentPage, int pageSize) {
            return new R(true, bookService.getPage(currentPage, pageSize));
        }
    }
    

小结:

  1. 设计统一的返回值结果类型便于前端开发读取数据
  2. 返回值结果类型可以根据需求自行设定,没有固定格式
  3. 返回值结果模型类用于后端与前端进行数据格式统一,也称为前后端数据协议

4.5.6 前后端协议联调

  • 前后端分离结构设计中页面归属前端服务器
  • 单体工程中页面放置在resources目录下的static目录中(建议执行clean)

前端发送异步请求,调用后端接口

//列表
getAll() {
	axios.get("/books").then((res)=>{
		console.log(res.data);
	});
},

【SpringBoot2 基础篇】学习笔记_第46张图片

小结:

  1. 单体项目中页面放置在resources/static目录下
  2. created钩子函数用于初始化页面时发起调用
  3. 页面使用axios发送异步请求获取数据后确认前后端是否联

列表页

将查询数据返回到页面,利用前端数据双向绑定进行数据展示

methods: {
    //列表
    getAll() {
        //发送异步请求
        axios.get("/books").then((res)=>{
            // console.log(res.data);
            this.dataList =res.data.data;
        });
    },

【SpringBoot2 基础篇】学习笔记_第47张图片

4.5.7 功能开发

添加功能

  • 弹出添加窗口
    //弹出添加窗口
    handleCreate() {
    	this.dialogFormVisible = true;
    },
    
  • 添加功能
     //添加
    handleAdd() {
         //发送异步请求
         axios.post("/books",this.formData).then((res)=>{
             //如果操作成功,关闭弹层,显示数据
             if(res.data.flag){
                 this.dialogFormVisible = false;
                 this.$message.success("添加成功");
             }else {
                 this.$message.error("添加失败");
             }
         }).finally(()=>{
             //重新加载数据
             this.getAll();
         });
     },
    

添加完数据之后,点击新建,发现之前创建的数据仍在表单里,如下:

【SpringBoot2 基础篇】学习笔记_第48张图片

解决这种情况,需要设置“重置表单,清除数据”

  • 清除数据
    //重置表单
    resetForm() {
    this.formData = {};
    },
    
  • 重置表单应该在每次点开新建时操作完成
    //弹出添加窗口
    handleCreate() {
    this.dialogFormVisible = true;
    this.resetForm();
    },
    
  • 误点开创建功能,如何取消,设置取消添加功能
    //取消
    cancel(){
    	this.dialogFormVisible = false;
    	this.$message.info("操作取消");
    },
    

小结:

  1. 请求方式使用POST调用后台对应操作
  2. 添加操作结束后动态刷新页面加载数据
  3. 根据操作结果不同,显示对应的提示信息
  4. 弹出添加Div时清除表单数据

删除功能

// 删除
handleDelete(row) {
    // console.log(row);
    axios.delete("/books/" + row.id).then((res) => {
        if (res.data.flag) {
            this.$message.success("删除成功");
        } else {
            this.$message.error("删除失败");
        }
    }).finally(() => {
        this.getAll();
    });
},

通过上面的方法可以实现删除的功能,但是很容易误删,需要设置弹窗提醒,是否删除

// 删除
handleDelete(row) {
	//1.弹出提示框
	this.$confirm("此操作永久删除当前数据,是否继续?","提示",{
		type:'info'
	}).then(()=>{
		//2.做删除业务
		axios.delete("/books/"+row.id).then((res)=>{
		}).finally(()=>{
		this.getAll();
		});
	}).catch(()=>{
		//3.取消删除
		this.$message.info("取消删除操作");
	});
}

【SpringBoot2 基础篇】学习笔记_第49张图片
小结:

  1. 请求方式使用Delete调用后台对应操作
  2. 删除操作需要传递当前行数据对应的id值到后台
  3. 删除操作结束后动态刷新页面加载数据
  4. 根据操作结果不同,显示对应的提示信息
  5. 删除操作前弹出提示框避免误操作

修改功能

  • 弹出修改窗口
    //弹出编辑窗口
    handleUpdate(row) {
         axios.get("/books/" + row.id).then((res) => {
             if (res.data.flag && res.data.data != null) {
                 //展示弹层,加载数据
                 this.formData = res.data.data;
                 this.dialogFormVisible4Edit = true;
             } else {
                 this.$message.error("数据同步失败,自动刷新");
             }
         }).finally(()=>{
    		  this.getAll();
    	});
     },
    
  • 删除信息维护
    // 删除
    handleDelete(row) {
        // console.log(row);
        axios.delete("/books/" + row.id).then((res) => {
            if (res.data.flag) {
                this.$message.success("删除成功");
            } else {
                this.$message.error("数据同步失败,自动刷新");
            }
        }).finally(() => {
            this.getAll();
        });
    },
    
  • 修改
     //修改
    handleEdit() {
    	axios.put("/books",this.formData).then((res)=>{
    		//如果操作成功,关闭弹层并刷新页面
    		if(res.data.flag){
    			this.dialogFormVisible4Edit = false;
    			this.$message.success("修改成功");
    		}else {
    			this.$message.error("修改失败,请重试");
    		}
    	}).finally(()=>{
    		  this.getAll();
    	});
    },
    
  • 取消添加和修改
cancel(){
	this.dialogFormVisible = false;
	this.dialogFormVisible4Edit = false;
	this.$message.info("操作取消");
},

小结:

  1. 加载要修改数据通过传递当前行数据对应的id值到后台查询数据
  2. 利用前端数据双向绑定将查询到的数据进行回显
  3. 请求方式使用PUT调用后台对应操作
  4. 修改操作结束后动态刷新页面加载数据(同新增)
  5. 根据操作结果不同,显示对应的提示信息(同新增)

分页功能

【SpringBoot2 基础篇】学习笔记_第50张图片
【SpringBoot2 基础篇】学习笔记_第51张图片
【SpringBoot2 基础篇】学习笔记_第52张图片
【SpringBoot2 基础篇】学习笔记_第53张图片
【SpringBoot2 基础篇】学习笔记_第54张图片【SpringBoot2 基础篇】学习笔记_第55张图片
小结:

  1. 使用el分页组件
  2. 定义分页组件绑定的数据模型
  3. 异步调用获取分页数据
  4. 分页数据页面回显

这样操作有一个BUG,最后一页,若只有一个数据,删了以后,最后一页的页面还在

处理方法:

对查询结果进行校验,如果当前页码值大于最大页码值,使用最大页码值作为当前页码值重新查询

@GetMapping("{currentPage}/{pageSize}")
public R getPage(@PathVariable int currentPage,@PathVariable int pageSize){
	IPage<Book> page = bookService.getPage(currentPage, pageSize);
	//如果当前页码值大于了总页码值,那么重新执行查询操作,使用最大页码值作为当前页码值
	if( currentPage > page.getPages()){
		page = bookService.getPage((int)page.getPages(), pageSize);
	}
	return new R(true, page);
}

条件查询

  • 查询条件数据封装
    • 单独封装
    • 与分页操作混合封装

由于这三个属性(name、type、description)都是跟着分页走的,所以直接放到pagination中

pagination: { 			//分页相关模型数据
	currentPage: 1, 	//当前页码
	pageSize:10, 		//每页显示的记录数
	total:0,			//总记录数
	name: "",
	type: "",
	description: ""
}
  • 页面数据模型绑定
     <div class="filter-container">
         <el-input placeholder="图书类别" v-model="pagination.type" style="width: 200px;"
                class="filter-item">el-input>
         <el-input placeholder="图书名称" v-model="pagination.name" style="width: 200px;"
                class="filter-item">el-input>
         <el-input placeholder="图书描述" v-model="pagination.description" style="width: 200px;"
                class="filter-item">el-input>
         <el-button @click="getAll()" class="dalfBut">查询el-button>
         <el-button type="primary" class="butT" @click="handleCreate()">新建el-button>
    div>
    
  • 组织数据成为get请求发送的数据并页面回显数据
    //分页查询
    getAll() {
        //获取查询条件,拼接查询条件
        // url:/books/1/10?type=???name=???&description=???
         param = "?name=" + this.pagination.name;
         param += "&type=" + this.pagination.type;
         param += "&description=" + this.pagination.description;
         console.log("-----------------" + param);
         
         //发送异步请求
         axios.get("/books/" + this.pagination.currentPage + "/" + this.pagination.pageSize + param).then((res) => {
                this.pagination.total = res.data.data.total;
                this.pagination.currentPage = res.data.data.current;
                this.pagination.pageSize = res.data.data.size;
                this.dataList = res.data.data.records;
            });
    },
    
  • Controller接收参数
    @GetMapping("{currentPage}/{pageSize}")
    public R getAll(@PathVariable int currentPage,@PathVariable int pageSize,Book book) {
    	System.out.println("参数=====>"+book);
    	IPage<Book> pageBook = bookService.getPage(currentPage,pageSize);
    	return new R(null != pageBook ,pageBook);
    }
    
  • 业务层接口功能开发
    public interface IBookService extends IService<Book> {
    	IPage<Book> getPage(Integer currentPage,Integer pageSize,Book book);
    }
    
    @Service
    public class IBookServiceImpl extends ServiceImpl<BookDao,Book> implements IBookService {
    	public IPage<Book> getPage(Integer currentPage,Integer pageSize,Book book){
     		IPage page = new Page(currentPage, pageSize);
     		
        	LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<>();
            lqw.like(Strings.isNotEmpty(book.getName()), Book::getName, book.getName());
            lqw.like(Strings.isNotEmpty(book.getType()), Book::getType, book.getType());
            lqw.like(Strings.isNotEmpty(book.getDescription()), Book::getDescription, book.getDescription());
            
       	 	return bookDao.selectPage(page, lqw);
    	}
    }
    

4.5.8 SSMP整合总结

  1. pom.xml
    配置起步依赖
  2. application.yml
    设置数据源、端口、框架技术相关配置等
  3. dao
    继承BaseMapper、设置@Mapper
  4. dao测试类
  5. service
    调用数据层接口或MyBatis-Plus提供的接口快速开发
  6. service测试类
  7. controller
    基于Restful开发,使用Postman测试跑通功能
  8. 页面
    放置在resources目录下的static目录中

你可能感兴趣的:(框架,java,spring,spring,boot,mybatis)