SpringBoot入门基础

不想当年

已于 2023-01-04 16:13:24 修改

阅读量362

点赞数 1

于 2022-12-08 16:35:13 首次发布

本文链接：https://blog.csdn.net/qq_43114723/article/details/128239278

版权

基础

一、基本概念

1.1 SpringBoot是什么

（1） SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用搭建和开发过程的一种框架；
（2）SpringBoot完成了对各种框架的整合，让这些框架集成在一起变得更加简单，简化了我们在集成过程中繁琐的模板化配置。

1.2 SpringBoot的特点

（1）依赖管理

父项目作依赖管理；
开发导入starter场景启动器
无需关注版本号，自动版本仲裁
可以修改版本号

（2）自动配置

自动配置Tomcat
自动配置好Springmvc
自动配置好web常见功能
默认的包结构
各种配置拥有默认值
按需加载所有自动配置项

1.3 SpringBoot的优缺点

(1)Spring Boot 优点：

容易上手，提升开发效率，为 Spring 开发提供一个更快、更简单的开发框架。
开箱即用，远离繁琐的配置。
提供了一系列大型项目通用的非业务性功能，例如：内嵌服务器、安全管理、运行数据监控、运行状况检查和外部化配置等。
SpringBoot总结就是使编码变简单、配置变简单、部署变简单、监控变简单等等。

(2)SpringBoot缺点：

人称版本帝，迭代快，需要时刻关注变化
封装太深，内部原理复杂，不容易精通

二、SpringBoot入门案例

2.1 IDEA入门（Maven）

前言：
1> SpringBoot在创建项目时，使用jar的打包方式。
2> SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。
3> 使用SpringBoot和Spring构建的项目，业务代码编写方式完全一样。

具体步骤：
1>创建Maven项目
2>导入SpringBoot起步依赖
3>编写引导类（主函数）
4>定义Controller（web）
5>启动测试

详细步骤：
1>创建Maven项目
在这里插入图片描述
记得Mven进行配置一下

2>导入SpringBoot起步依赖（pom.xml）

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from dao -->
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3>编写引导类

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//主程序
@SpringBootApplication
public class HelloApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class,args);
    }
}

4>定义Controller

package com.itheima.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "Hello springboot!";
    }
}

5>启动测试

启动引导类
在浏览器中输入地址：http://localhost:8080/hello ，则会出现以下场景，证明SpringBoot启动成功。

总结：maven创建项目，界面比较简洁，但pom.xml内容需要自己手动添加。

2.2 IDEA 入门(采用 Spring Initializr快速构建)

Spring Initializr
从本质上来说就是一个Web应用程序，它能为你生成Spring Boot项目结构。虽
然不能生成应用程序代码，但它能为你提供一个基本的项目结构，以及一个用于构建代码的Maven或Gradle构建说明文件。你只需要写应用程序的代码就好了。

具体步骤：
1>创建项目，选择Spring Initializr
2>定义Controller（web）
3>启动测试

详细步骤：
1>创建项目，选择Spring Initializr
在这里插入图片描述

可以进行相应的选择，这样可以直接加入相应的依赖，不用手动导入，然后记得maven配置：
生成的界面：导入类和pom.xml都已经自动导入好。

2>定义Controller

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello() {
        return "Hello springboot!";
    }
}

3>启动测试
在这里插入图片描述

在浏览器中输入地址：http://localhost:8080/hello ，则会出现以下场景，证明SpringBoot启动成功。

总结：Spring Initializr创建可以省略导入类（主函数）和pom.xml内容的手动创建，但是创建出来的界面不够简洁，需要手动去调整。
问题：
（1）导入SpringBoot版本过高的话，会导致一定错误，将SpringBoot版本手动改动下即可。

（2）建立的界面不够简洁：
可以通过设置进行相应的隐藏：

（3）如果在建立项目时，点击下一步刷新不出来，则需要进行地址的改变：
https://start.aliyun.com

三、SpringBoot入门案例详解

3.1 起步原理

起步依赖原理分析：
1> Spring-boot-starter-web
2> Spring -boot-starter-parent

总结：
1.在Spring -boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本；
(这样可以不用写版本号，自动仲裁）
2.在各种starter中，定义了完成该功能需要的坐标集合，其中大部分版本信息来自于父工程；
3.我们的工程继承parent,引入stater后，通过依赖传递，就可以简单方便获取需要的jar包，并且不会存在版本冲突等问题。

**如果想改变相关版本，比如mysql版本；
1.查看相关底层默认版本；
2. 在https://mvnrepository.com/查找可以使用版本；
3.在pom.xml中写配置

    <properties>
        <mysql.version>5.1.13</mysql.version>
    </properties>

3.2 引导类

/**
* @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
*/
//主程序
@SpringBootApplication
public class HelloApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class,args);
    }
}

@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类。

四、配置文件

3.1配置文件的分类

SpringBoot使用一个全局的配置文件，配置文件名是固定的；
（1）application.properties
（2）application.yml
（3) application.yaml
配置文件的作用：修改SpringBoot自动配置的默认值；
SpringBoot在底层都给我们自动配置好；

总结：
SpringBoot提供了3种配置文件类型：properties、yml和yaml；
默认配置文件名称：application；
在同一级目录下优先级为：properties>yml>yaml
具体目录在下图：
在这里插入图片描述

3.2 yml的基本语法

yml是一种标记语言

server:
    port: 8081

xml语法

<server>
    <port>8081</port>
</server>

properties语法

server.port = 8081

注意：
k:(空格)v：表示一对键值对（空格必须有）；
以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的。

server:
   port: 8081    //中间有空格
   path: /hello

属性和值也是大小写敏感；
总结：
（1）大小写敏感
（2）数据值前边必须有空格，作为分隔符
（3）使用缩进表示层级
（4）缩进时不允许使用Tab键，只允许使用空格（各个系统Tab对应的空格数目可能不同，导致层次混乱）
（5）缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
（6）#表示注释，从这个字符一直到行尾，都会被解析器忽略。

ymal的数据格式：

对象（map）：键值对的集合

person:
   name: zhangsan
#行内写法
person: {name: zhangsan}

数组：一组按次序排列的值

address:
    - beijing
    - shanghai
 #行内写法
address: [beijing,shanghai]

纯量：单个的、不可再分的值

msg1: 'hello \n world'    #单引号忽略转义字符
msg2: "hello \n world"    #双引号识别转义字符

3.3 读取配置文件

(1) @Value
(2) Environment
(3) @ConfigurationProperties

详细步骤：
(1)使用@Value读取单个数据，属性名引用@Value(${一级属性名.二级属性名…})

lesson: SpringBoot

server:
  port: 8080

address:
  - beijing
  - shanghai

在controller中：

@RestController
public class HelloController {
    @Value("${lesson}")
    private String lesson1;

    @Value("${server.port}")
    private String port1;

    @Value("${address[0]}")
    private String address1;

    @RequestMapping("/hello")
    public String hello(){
        System.out.println("lesson1的值是：" + lesson1);
        System.out.println("port1的值是：" + port1);
        System.out.println("address1的值是：" + address1);
        return "Hello springboot!";
    }
}

在打印台上输出结果：

lesson1的值是：SpringBoot
port1的值是：8080
address1的值是：beijing

(2)读取ymal的全部数据：封装全部数据到Environment对象中。
格式：

   import org.springframework.beans.factory.annotation.Autowired;
    @Autowired
    private Environment env;

在controller中：

@RestController
public class HelloController {
    @Autowired
    private Environment env;

    @RequestMapping("/hello")
    public String hello(){
        System.out.println(env.getProperty("lesson"));
        System.out.println(env.getProperty("server.port"));
        return "Hello springboot!";
    }
}

输出结果：

SpringBoot
8080

（3）使用@ConfigurationProperties读取指定的引用类型数据
比如读取yaml

spring:
  datasource:
    druid:
      driver: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: password

思路：
（1）定义数据模型封装yaml中文件中对应的数据；
（2）对应Spring管控的bean;
（3）指定加载的数据。

具体步骤：
（1）定义数据模型：

public class MydataSource {
    private String driver;
    private String url;
    private String username;
    private String password;
 }
 getter,setter,toString省略...

（2）对应Spring管控的bean;

@Component
public class MydataSource {
   private String driver;
   private String url;
   private String username;
   private String password;
}
getter,setter,toString省略...

（3）指定加载的数据

@Component

@ConfigurationProperties(prefix = "spring.datasource.druid" )
public class MydataSource {
   private String driver;
   private String url;
   private String username;
   private String password;
}
getter,setter,toString省略...

测试
在controller中：

@RestController
public class HelloController {
    @Autowired
    private MydataSource mydataSource;

    @RequestMapping("/hello")
    public String hello(){
        System.out.println(mydataSource);
        return "Hello springboot!";
    }
}

控制台上输出结果：

MydataSource{driver='com.mysql.cj.jdbc.Driver', url='jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC', username='root', password='password'}

总结：最后一种@ConfigurationProperties使用较多。
1.使用@ConfigurationProperties注解绑定配置信息到封装类中；
2.封装类需要定义为Spring管理的bean，否则无法进入属性注入。

五、Springboot整合其他框架

5.1 Springboot整合Junit

整合Junit步骤：
采用SpringBoot Initializr 方式
(1)不需要选择其加入依赖，默认会加入test依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

(2)测试类使用@SpringBootTest

@SpringBootTest
class SpringbootApplicationTests {
    //注册要测试的对象
    @Autowired
    private BookDao bookDao;

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

(3)实现接口和实现类

实现接口：

public interface BookDao {
    public void save();
}

实现类

@Repository
public class BookDaoImpl implements BookDao {
    @Override
    public void save(){
        System.out.println("helloworld!");
    }
}

问题：
如果SpringbootApplicationTestst和测试类，测试方法不在统一目录下，则会发生一定错误：
java.lang.IllegalStateException: Unable to find a @SpringBootConfiguration, you need to use @ContextConfiguration or @SpringBootTest(classes=…) with your test…

解决方法：
1.将SpringbootApplicationTests和测试类，测试方法放在统一目录下；
2.在SpringbootApplicationTests上加上注解：classes = SpringbootApplication.class

@SpringBootTest
@ContextConfiguration(classes = SpringbootApplication.class)
class SpringbootApplicationTests {
    //注册要测试的对象
    @Autowired
    private BookDao bookDao;

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

5.2 Springboot整合Mybatis

步骤：
1.采用SpringBoot快速创建的方法：
选择Mybatis和Mysql 驱动（加依赖）
2.写配置：
application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssmbuild?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    username: root
    password: password

3.写实体类

public class Books {
   private int bookId;
   private String bookName;
   private int bookCounts;
   private String detail;

getter,setter...
}

4.写SQL语句和方法

@Mapper
public interface BooksDao {
    @Select("select * from books where bookId = #{bookId}")
    public Books getById(Integer id);
}

5.测试类

@SpringBootTest
class SpringbootMybatisApplicationTests {
    @Autowired
    private BooksDao booksDao;
    @Test
    void contextLoads() {
        System.out.println(booksDao.getById(1));
    }
}

5.3 Springboot整合Mybatis-plus

前言：准备数据：
数据库创建：mybatis_plus

DROP TABLE IF EXISTS user;

CREATE TABLE user(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id));

加入表数据

DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

1.导入POM配置文件

        <!--3.mybatis-plus  版本很重要3.0.5-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

2.数据库连接配置
application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    username: root
    password: password

3.编写实体类

package com.wsk.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
   private Long id;
   private String name;
   private Integer age;
   private String email;
}

编写实体类对应的mapper接口

@Repository//代表持久层
public interface UserMapper extends BaseMapper<User> {
    //所有CRUD操作都编写完成了，不用像以前一样配置一大堆文件
}

在主启动类添加@MapperScan注解

//扫描mapper包下的所有接口
@MapperScan("com.wsk.mapper")
@SpringBootApplication
public class MybatisPlusApplication {
   public static void main(String[] args) {
       SpringApplication.run(MybatisPlusApplication.class, args);
   }
}

进行Test测试

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)    //不加的会报错空指针异常

class MybatisPlusApplicationTests {
    //继承了BaseMapper，所有的方法都来自父类，我们也可以编写自己的扩展方法！
    @Autowired
    private UserMapper userMapper;
    @Test
    void contextLoads() {
        //参数是一个wrapper ，条件构造器，这里我们先不用 null
        List<User> userList = userMapper.selectList(null);//查询全部的用户
        userList.forEach(System.out::println);
    }
}

5.4 Springboot整合Druid

在SpringBoot整合mybatis的基础上进行改动：
步骤：
1.采用SpringBoot快速创建的方法：
选择Mybatis和Mysql 驱动（加依赖）
另外在官网上https://mvnrepository.com/ 上搜索druid的依赖：

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.6</version>
        </dependency>

2.写配置：
application.yml

spring:
  datasource:
      druid:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/ssmbuild?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
        username: root
        password: password

3.写实体类

public class Books {
   private int bookId;
   private String bookName;
   private int bookCounts;
   private String detail;

getter,setter...
}

4.写SQL语句和方法

@Mapper
public interface BooksDao {
    @Select("select * from books where bookId = #{bookId}")
    public Books getById(Integer id);
}

5.测试类

@SpringBootTest
class SpringbootMybatisApplicationTests {
    @Autowired
    private BooksDao booksDao;
    @Test
    void contextLoads() {
        System.out.println(booksDao.getById(1));
    }
}

六、SSMP整合案例

6.1 数据层(dao层)

步骤：
1.导入相应依赖（pom.xml）
2.设置maven，导入lombok插件
3.书写实体类
4.书写数据层
5.进行测试

详细步骤：
1.导入相应依赖（pom.xml）
手动引入mybatis-plus,druid,lombok的相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.4.RELEASE</version>
	</parent>

	<groupId>com.itsheep</groupId>
	<artifactId>springboot_ssmp</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>com.mysql</groupId>
			<artifactId>mysql-connector-j</artifactId>
			<scope>runtime</scope>
			<version>8.0.31</version>
		</dependency>

		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>3.3.1</version>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.2.6</version>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.junit.jupiter</groupId>
			<artifactId>junit-jupiter</artifactId>
			<version>RELEASE</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

yml文件进行相应的设置：application.yml

server:
  port: 80

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssmbuild?serverTimezone=UTC
      username: root
      password: password

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
      id-type: auto     #id的自增策略，mybatisplus的默认算法是雪花算法，这里设置为自增算法

  configuration:    #mybatis-plus的日志记录，其中一种
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

2.设置maven，导入lombok插件
在设置中找到plugins，进行下载，然后重启Ideal
在这里插入图片描述
3.书写实体类
书写实体类，实体类中的元素要和数据库中的数据一一对应

package com.itsheep.domain;

import lombok.Data;

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

@Data：可省去getter，setter等
4.书写数据层
使用框架：mybatis-plus

package com.itsheep.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itsheep.domain.Book;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface BookDao extends BaseMapper<Book> {

}

5.进行测试
进行测试，在test中进行相应的测试

import javax.annotation.Resource;

@Slf4j
@SpringBootTest
public class BookDaoTest {
    //@Autowired
    @Resource      //@Autowired和@Resource的区别
    private BookDao bookDao;
//    void testGetById() {
//        System.out.println(bookDao.getById(2));
//    }

    //查询
    @Test
    void testGetById() {
        bookDao.selectById(1);
    }

    //查询所有
    @Test
    void testGetALL() {
        bookDao.selectList(null); 
    }

    //增加信息
    @Test
    void testSave() {
        Book book = new Book();
        book.setDescription("测试数据");
        book.setName("zdy");
        book.setType("自传");
        bookDao.insert(book);
        log.info("插入数据成功!");
    }

    //删除信息
    @Test
    void testDelete() {
        bookDao.deleteById(15);
        log.info("删除数据成功!");
    }

    //更改信息
    @Test
    void testUpdate() {
        Book book = new Book();
        book.setId(15);
        book.setDescription("更新后的测试数据");
        book.setName("zdy");
        book.setType("自传");
        bookDao.updateById(book);
        log.info("更新数据成功!");
    }

    //分页查询      需要进行配置，设置拦截器
    @Test                      
    void testGetPage() {
        IPage<Book> page = new Page<Book>(1,2);
        bookDao.selectPage(page,null);
    }

    //条件查询1
    @Test
    void testGetBy() {
        QueryWrapper<Book> qw = new QueryWrapper<Book>();
        qw.like("name","Spring");
        System.out.println(bookDao.selectList(qw));
    }

    //条件查询2     常用，防止“name”为null
    @Test
    void testGetBy2() {
        String name = null;
        LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
        //lqw.like(Book::getName,"Spring");
        lqw.like(name != null,Book::getName,name);
        System.out.println(bookDao.selectList(lqw));
    }
}

分页查询过程中，需要设置拦截器 MpConfig

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor(){
        MybatisPlusInterceptor  mpInterceptor = new MybatisPlusInterceptor();
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}

6.2 业务层（Service层）

业务层面向具体的业务，名称定义为具体的业务名称，并与Dao层的名称进行区分。
BookService：

public interface BookService {
    Boolean save(Book book);
    Boolean delete(Integer id);
    Boolean update(Book book);
    Book getById(Integer id);
    List<Book> getAll();
    IPage<Book> getPage(int cruentPage, int Pagesize);
}

BookServiceIpml：

@Service
public class BookServiceIpml implements BookService {
    @Autowired
    private BookDao bookDao;

    @Override
    public Boolean save(Book book) {
       return (bookDao.insert(book))>0;
    }

    @Override
    public Boolean delete(Integer id) {
        return (bookDao.deleteById(id))>0;
    }

    @Override
    public Boolean update(Book book) {
        return (bookDao.updateById(book))>0;
    }

    @Override
    public Book getById(Integer id) {
        return bookDao.selectById(id);
    }

    @Override
    public List<Book> getAll() {
        return bookDao.selectList(null);
    }

    @Override
    public IPage<Book> getPage(int cruentPage, int Pagesize) {
        IPage page = new Page(cruentPage,Pagesize);
        bookDao.selectPage(page,null);
        return page;
    }
}

业务测试类：BookServiceTest

@Slf4j
@SpringBootTest
public class BookServiceTest {
    @Autowired
    private BookService bookService;

   //增加信息
    @Test
    void testSave() {
        Book book = new Book();
        book.setDescription("测试数据aaa");
        book.setName("张东阳");
        book.setType("自传");
        bookService.save(book);
        log.info("插入数据成功!");
    }

    //删除信息
    @Test
    void testDelete() {
        bookService.delete(16);
        log.info("删除数据成功!");
    }

    //更改信息
    @Test
    void testUpdate() {
        Book book = new Book();
        book.setId(15);
        book.setDescription("更新后的测试数据");
        book.setName("zdy");
        book.setType("自传");
        bookService.update(book);
        log.info("更新数据成功!");
    }

    //查询
    @Test
    void testGetById() {
        bookService.getById(1);
    }

    //查询所有
    @Test
    void testGetALL() {
        bookService.getAll();
    }

    //分页查询
    @Test
    void testGetPage() {
        bookService.getPage(1,2);
    }
}

6.3 Mybatis-plus的简单的三层架构

调用顺序：Controller调用Service层，Service层调用Dao层。
1.实体类

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

2.Dao层

@Mapper
public interface BookMapper extends BaseMapper<Book> {
}

3.Service层：
在实际开发中，Service层是具体的业务场景，大部分要重写方法。

BookService接口

public interface BookService extends IService<Book> {
}

BookServiceImpl实现类

@Service
public class BookServiceImpl extends ServiceImpl<BookMapper,Book> implements BookService {
}

4.Controller层

@RestController
public class BookController {
    @Autowired
    private BookService bookservice;

    @PostMapping("/select")
    public Book BookSelect(@RequestParam String id){
        return bookservice.getById(id);
    }
}

注：Service层和Dao层的方法名一般不一样，Dao层面向的是具体的数据，所以命名一般跟数据有关，而Service层中方法命名面向具体的业务，和业务的含义有关。
举例：

Dao层
SelectByUsernameAndPassword(String username,String password)

Service层
login（String username,String password）