1.SpringBoot是什么

Spring Boot是  一个基于 Spring 框架的快速  开发框架，目标是简化 Spring 应用程序的初始设置和开发过程，那它到底怎么做的呢？

        我们需要从框架的概念再到 Spring 框架，然后再到Spring Boot框架。

        框架，顾名思义就是平常开发 java 时，有些工具类，配置类，咱们不需要每次重新开发，可以从之前项目中复制，这个就是框架的雏形。咱们可以在每次开发的时候  用已经写好的代码  进行重复使用，就不需要自己再重写了，这些代码的集合就叫做框架。

        Spring 就是框架，它主要是通过容器来管理对象的框架，管理对象的创建和使用，其实 它就是一个小瓶子 ，你可以通过它的规范，把你的对象放在这个 Spring 的小瓶子里 面 ，这样你 就实现了对这个项目中的对象进行集中管理，这个框架的思路 就叫 IoC（控制反转），这样我们就实现了项目的解耦。

        不用Spring（老办法）：饭、菜、碗、筷子，全部都要你自己亲手做、亲手准备，想吃啥自己弄，所有事自己说了算；用Spring（控制反转）：你啥都不用准备，有个食堂（Spring容器），提前把饭、菜、碗筷全部备好，你只需要坐下张嘴吃就行。

        啥是控制反转：以前：你自己掌控一切，自己准备所有东西；现在：不用你准备，食堂提前备好给你做事的主动权，从你身上，转到食堂身上。主动权反过来了。

        啥叫管理对象：饭菜碗筷就是代码里的对象食堂统一收好、备好，就是Spring统一管理

        啥叫解耦：以前你必须自己做饭，不会做就吃不上；现在食堂换厨师、换菜品，你照样坐着吃，不受影响。

        关于项目解耦，举个例子，咱们平时使用的是这个比较常用的数据库，就是 mysql，假如我们的项目要换成其他的数据库，如果不使用这个 IoC，每次切换数据库时，都需要修改很多地方的代码，比如这个数据库的连接，sql 语句的设置，甚至是数据库相关的配置。有了 IoC，你就可以通过 Spring 容器来实现解耦，避免直接去修改代码。

        IoC 一般的实现逻辑就是 先定义一个接口，然后定义它的通用方法，避免硬编码，然后你可以 根据 你的 实际情况定义多个实现类，然后 在 XML 文件中配置，确定  这个 接口对应的对象、类对象是哪一个就可以正常使用了，这样就实现了代码的解耦，不用修改一行代码，就把对象给换了。

        为了照顾我们小白，Spring 官方开发出了 Spring Boot 框架，它的特点约定大于配置，也就是在 Spring 中很多需要配置的东西在 Spring Boot里面直接默认就能使用了。

        在 Spring Boot 中有很多种办法 在这个容器中创建对象，比方说，你可以使用这个 component 注解来修饰你的类，只要这样一修饰，就在容器中创建了这个类的对象。

import org.springframework.stereotype.Component

@Component
public class GreetingService {

    public String getGreeting(String name) {
        return "hello, " + name + "!";
    }
}

        还有一种就是通过配置类来进行管理，也就是如下，在后续过程中会给大家进行演示。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    //定义一个 Bean ， 返回 GreetingService 实例
    @Bean
    public GreetingService greetingService() {
        return new GreetingService;
    }

}

        当然 Spring 自身也整合了很多的开源技术，通过定义好的注解，就可以往 Spring Boot中注入相应的对象，从而实现相关功能。比如用来替代 Servlet 开发的 Spring MVC 框架。咱们只需要在上面加个 @RestController 或 @Controller 就可以往容器里添加我们的 Spring MVC 对象了。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {

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

    @GetMapping("/hello")
    public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {
        return String.format("Hello %s!", name);
    }
}

        除此之外，Spring Boot 还内嵌了 tomcat 服务器，在运行启动类的时候呢，tomcat 就已经启动了，只用把 jar 包放在服务器上就可以运行了

2.快速体验

        场景：浏览器发送/hello请求，返回"Hello,Spring Boot 3!"

1.创建项目

        maven项目

 <!--所有springboot项⽬都必须继承⾃spring-boot-starter-parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
    </parent>

2.导入场景

        场景启动器

    <dependencies>
        <!--  web开发的场景启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

3.主程序

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 启动SpringBoot项目的主入口程序
 */

@SpringBootApplication
/*
    @SpringBootApplication 是 SpringBoot 的核心注解，作用是开启自动配置、扫描组件、启动整个项目。
    没按之前：车是死的
    一按 @SpringBootApplication：
        发动机启动
        电路接通
        空调可用
        方向盘能用
        全部自动准备好！
 */


public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class,args);
        /*
            SpringApplication：SpringBoot 自带的启动工具，专门用来开项目
            run()：就是 “运行、启动” 的意思
            Main.class：告诉工具：我的项目入口是 Main 这个类
            args：运行参数，固定写法，新手完全不用管
         */

    }
}

4.业务

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

//@ResponseBody
//@Controller

/*
@RestController
放在类上面
表示：我这个类要给浏览器返回数据
 */
@RestController
public class HelloController {

    /*
       @GetMapping("/hello")
       放在方法上面
       表示：浏览器访问 /hello 就跑我这个方法
        */
    @GetMapping("/hello")
    public String hello(){
        return "Hello,Spring Boot 3!";
    }
}

5.测试

        默认启动访问： localhost:8080

6.打包

  <!--    SpringBoot应⽤打包插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

注：这个application.properties其实就是 Spring Boot 的配置文件，配置对象的一些参数，例如定义数据库的账户名和密码，项目的端口号等等。但不是主流了，可以将后缀改成 yml 文件。

3.Spring Boot 整合 Spring MVC 实现第一个 API 接口

pom 文件中添加依赖

    <dependencies>
        <!--  web开发的场景启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

现在的 Spring MVC 不需要 XML 文件的配置，只需要在对应的类上添加 RestController 或者 Controller 注解就可以了

package com.example.springbootproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
//只要写这个注释就相当于在 Spring 容器中创建了一个 Spring MVC 对象，
//接受请求的话就需要创建方法

public class DemoApplication {

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

    /**
     *
     *hello
     *@return
    **/
    //在方法上添加一个注解，和访问路径进行匹配
    @RequestMapping("/hello")
    //这个注解里面的hello前缀，就是说当访问这个路径的时候会执行当前的方法
  
    public String hello(){
        return "Hello World";
    }

}

RestController 和 Controller 注解有什么区别

- RestController 修饰的类，返回的参数全部序列化成 json 的形式返回到前端。适合前后端分离的项目。

- Controller 可以返回视图，例如 Controller 它可以直接返回 HTML 页面 JSP 页面等。

运行成功：

给这个类所有的请求，都需要加一个前缀 index，只需要在 public class DemoApplication { 前一行加个@RequestMapping("/index")

那么怎么 给 这个工程里面的 所有请求之前  加上一个不固定的前缀 API？

- 在 application.yml 文件里进行统一的配置，添加 

server:
    servlet:
        context-path:/api

运行效果：

如何修改项目的端口？

- yml 文件进行配置，直接在这个 server 下面添加这个 port 属性

server:
    servlet:
        context-path:/api
    port:90

运行效果：

4.Spring MVC 实现 Restful API 请求方法

之前我们学习 servlet 的时候，请求的类型只有两种，一种是 get 请求，另外一种是 post 请求。那么什么是 restful 请求呢？

- 其实它是一种规范，和你使用什么代码没有关系，就是除了这两个请求外，还提供了另外两个请求类型，例如 post 和 delete，然后根据你操作的业务动作来发送不同类型的请求。

Restful 主要分为：

直接用浏览器输入框输入网址的话，默认发送的就是 get 请求，访问路径就代表资源，请求类型就代表动作，所以访问路径就基本上只用名词来作为资源，不用动词。

实现 get 请求的无参 API 接口，可以使用 @GetMapping 注解。

package com.example.springbootproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
//只要写这个注释就相当于在 Spring 容器中创建了一个 Spring MVC 对象，
//接受请求的话就需要创建方法
@RequestMapping("/index")

public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);}
    
    @GetMapping
    //注解修饰的方法可以接受 get 请求了
    public String index() {
        return "GET无参请求API方法已经实现"；
    }
    //这个写出来的就叫 API 的接口方法，就可以用来接受前端请求了，现在演示的是没有参数的

}

如果你要在 index 方法前面加前缀的话，你就需要在这个 GetMapping 里面加值。用了 GetMapping 里面加值后，就不需要使用这个 @RequestMapping 注解了。

运行成功：

现在这个路径只添加到接口类，就可以匹配到 GetMapping 中，但是并没有在方法名中写前缀，这就是 Spring MVC 写 Restful API 的特性。它会根据请求类型前缀路径会进行匹配对应的方法。

实现 get 请求的有参 API 接口：

package com.example.springbootproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
//只要写这个注释就相当于在 Spring 容器中创建了一个 Spring MVC 对象，
//接受请求的话就需要创建方法
@RequestMapping("/index")

public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);}
    
    @GetMapping
    //注解修饰的方法可以接受 get 请求了
    public String index() {
        return "GET无参请求API方法已经实现"；
    }
    //这个写出来的就叫 API 的接口方法，就可以用来接受前端请求了，现在演示的是没有参数的

    @GetMapping("/{id}")  //{}里面填你想传什么值
    public String index(@PathVariable Long id) {
        System.out.printf("ID=%s\n",id);
        return "GET Restful请求传值的方法实现成功"    
    }
}

如果想要读前端传递过来的参数的话，就得用 PathVariable  形参来机型修饰形参，你就能在这个方法体里读出来了

打开浏览器，咱们传递参数只用在这个后面加上斜杠，然后加上参数的值就可以了

传统传值的方式进行传值：

package com.example.springbootproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController

@RequestMapping("/index")
public class SpringBootProjectApplication {

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



    @GetMapping("/{id}")
    public String index(@PathVariable Long id) {
        System.out.printf("ID=%s\n",id);
        return "GET Restful请求传值的方法实现成功";
    }


    @GetMapping
    //相同的注解在一个类中，参数必须不一样，不然报错
    public String index2(@RequestParam Long id,@RequestParam String name) {
        System.out.printf("ID=%s, name=%s\n",id,name);
        return "Get 普通请求传值方法已经实现了";

    }


}

只要你在这个方法的形参前面添加上这个RequstParam注解进行修饰，然后咱们就能在方法体里面把前端传递的参数就读出来了。

运行结果：

put 和 delete 请求也可以通过 restful 传值，也可以通过普通的方式进行传值；post 的请求的话一般不传递参数，如果需要传递数据，需要传递这个数据的请求体（也就是表单数据）。前后端分离的项目的话，基本使用这个json的数据进行传递，，但是浏览器没办法直接发送post请求的，需要自行下载接口调试工具。可以用API fox。post 的请求示例如下：

    //post 请求
    @PostMapping
    public String save(@RequestBody Map<String,String> map) {
        System.out.printf(map.toString());
        return "POST请求接收成功";
    }

在 Api Fox 中发送请求：

后端就会反序列化成map对象：

put 请求：

    @PutMapping
    public String update(@PathVariable Long id,@RequestBody Map<String,String> map) {
        System.out.printf("ID=%s,name=%s\n",id,map);
        return "PUT请求接受成功";
    }

delete：

    @DeleteMapping("/{id}")
    public String delete(@PathVariable Long id) {
        System.out.printf("ID=%s\n",id);
        return "Deltet请求接收成功";
    }

5.Spring Boot 多环境配置和修改项目启动水印

在 resources 文件夹中新建 banner.txt 文件，将水印复制到 banner.txt 中，重新运行。

还有一种情况，在上线项目中，我们的端口或者是前缀啊，它跟我们实际开发不一致，怎么办？

复制两份 application.yml 文件，修改文件名如图上所示。删除原 application.yml 文件里的内容，改成：

spring:
  profiles:
    active: 

active：后面输入 dev 那文件读取的就是 application-dev.yml 文件里的参数（以此类推，prod也一样）。

6.三层架构

前端的请求进入到后端后，会通过三个层的代码进行处理。控制层（controller层）、业务层（service层）、持久层（mapper层）。

控制层代码都是用这个 Spring MVC 写的API方法接口，用来接受用户的请求和返回其他层传递过来的数据。处理的逻辑呢，会调用业务层的方法进行处理，业务层他只负责调用持久层的方法，持久层负责数据的增删，它是直接和数据库打交道的，将数据返回给业务层，再给控制层，在返回给前端。

spring boot 就是通过三个包的形式来具体展示这三层架构的

这个controller层用于接收用户的post、put、get、delete等请求。

持久层框架：mybatis、mybatis-plus（它具备了 mybatis 和 JPA 的双重属性，既可以自己写的 sql ，也可以使用定义好的方法）

7.安装 Mysql、Redis 和 Navicat

Mysql 和 Navicat官网上有。 Redis 非关系型数据库（主要使用 Key Value 的形式来进行存储数据），可以在 github 搜就行。

8.Spring boot 整合 Mybatis-plus

navicat 创建数据库和表，复制官网的代码（快速开始 | MyBatis-Plus）

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user`
(
    id BIGINT NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT 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');

改application.yml 文件内容：

以后在application-dev.yml文件中修改配置信息。在pom文件中添加依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
    <version>3.5.15</version>
</dependency>


//mysql驱动
<dependency>
     <groupId>com.mysql</groupId>
     <artifactId>mysql-connector-j</artifactId>
     <!-- 去掉version标签，让Spring Boot自动管理 -->
</dependency>

在application-dev.yml 文件中配置mysql的信息

server:
  servlet:
    context-path: /api
  port: 8080

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/0813-demo?allowPublicKeyRetrieval=true&useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: root123

在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹

@MapperScan("com.example.springbootproject.mapper")

在引入一个包，就是这个 lombok ，使用这个就不用再写 get，set 方法了。直接用 @data 注解就可以替代了。引入 lombok 的依赖。

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

创建entity实体包，User类

编写实体类 User.java：

package com.example.springbootproject.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("`user`")
//标识当前实体类映射数据库中的哪张表好。

public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

编写 Mapper 接口类 UserMapper.java：

package com.example.springbootproject.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.springbootproject.entity.User;

public interface UserMapper extends BaseMapper<User> {

}