boot spring 开发 技术架构选型 spring boot开发教学

一、快速上手SpringBoot

设计SpringBoot目的是用来简化Spring应用的初始搭建以及开发过程

一）SpringBoot入门程序开发

1.SpringBoot入门程序开发步骤：

①创建新模块，选择Spring Initializr，并配置模块相关基础信息

②：选择当前模块需要使用的技术集

③：开发控制器类

package com.itheima.test.controller;

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

/**
 * @Description: // 类说明
 * @ClassName: BookController    // 类名
 * @Author: 曾伟鸿            // 创建者
 * @Date: 2022/2/6 15:08   // 时间
 * @Version: 1.0       // 版本
 */
@RestController
@RequestMapping("/books")
public class BookController {
    @GetMapping
    public String getById(){
        System.out.println("66666");
        return "66666666666";
    }
}

④：运行自动生成的Application类

2.Spring程序与SpringBoot程序对比

• Spring程序缺点

• 依赖设置繁琐
• 配置繁琐

• SpringBoot程序优点

• 起步依赖（简化依赖配置）
• 自动配置（简化常用工程相关配置）
• 辅助功能（内置服务器，……）

 注意事项：基于idea开发SpringBoot程序需要确保联网且能够加载到程序框架结构

3.创建SpringBoot工程的四种方式

1. 基于Idea创建SpringBoot工程
2. 基于官网创建SpringBoot工程
3. 基于阿里云创建SpringBoot工程
4. 手工创建Maven工程修改为SpringBoot工程（一般不用）

①基于Idea创建SpringBoot工程

上面第一个创建工程就是基于idea创建的SpringBoot工程

②基于官网创建SpringBoot工程

步骤：

1. 打开SpringBoot官网（https://start.spring.io/），选择Quickstart Your Project
2. 创建工程，并保存项目
3. 解压项目，通过IDE导入项目

③基于阿里云创建SpringBoot工程

基于阿里云创建项目，地址：https://start.aliyun.com

注意事项：

• 阿里云提供的坐标版本较低，如果需要使用高版本，进入工程后手工切换SpringBoot版本
• 阿里云提供的工程模板与Spring官网提供的工程模板略有不同

步骤：

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

4.如何隐藏指定文件/文件夹

• Setting → File Types → Ignored Files and Folders
• 输入要隐藏的文件名，支持*号通配符
• 回车确认添加

二）浅谈入门程序工作原理

        1.parent（仅定义，未使用）

        开发SpringBoot程序要继承spring-boot-starter-parent

2. spring-boot-starter-parent中定义了若干个依赖管理

3. 继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突

4. 继承parent的形式也可以采用引入依赖的形式实现效果

        

        2.starter（解决配置问题）

        1.开发SpringBoot程序需要导入坐标时通常导入对应的starter

        2. 每个不同的starter根据功能不同，通常包含多个依赖坐标

        3. 使用starter可以实现快速配置的效果，达到简化配置的目的

• starter

• SpringBoot中常见项目名称，定义了当前项目使用的所有依赖坐标，以达到减少依赖配置的目的

• parent

• 所有SpringBoot项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的 
• spring-boot-starter-parent各版本间存在着诸多坐标版本不同

• 实际开发 

• 使用任意坐标时，仅书写GAV中的G和A，V由SpringBoot提供，除非SpringBoot未提供对应版本V 
• 如发生坐标错误，再指定Version（要小心版本冲突）

        3.引导类

  1.SpringBoot工程提供引导类用来启动程序

        2. SpringBoot工程启动后创建并初始化Spring容器

• 启动方式

package com.itheima.test;

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

@SpringBootApplication
public class TestApplication {

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

}

• SpringBoot的引导类是Boot工程的执行入口，运行main方法就可以启动项目 （未启动Web服务器）
• SpringBoot工程运行后初始化Spring容器，扫描引导类所在包加载bean

        4.辅助功能（内嵌tomcat）

        1. 内嵌Tomcat服务器是SpringBoot辅助功能之一

        2. 内嵌Tomcat工作原理是将Tomcat服务器作为对象运行，并将该对象交给Spring容器管理

        3. 变更内嵌服务器思想是去除现有服务器，添加全新的服务器

        内置服务器

        

        使用maven依赖管理变更起步依赖项

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!--web起步依赖环境中，排除Tomcat起步依赖-->
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!--添加Jetty起步依赖，版本由SpringBoot的starter控制-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
</dependencies>

二、SpringBoot基础配置

一）SpringBoot默认配置文件application.properties，通过键值对配置对应属性

①修改服务器端口

server.port=80

②关闭运行日志图标（banner）

spring.main.banner-mode=off

③设置日志相关

logging.level.root=debug

二）SpringBoot提供了多种属性配置方式

• properties（传统格式/默认格式）

server.port=80

• yml（主流格式）

server: port: 81

• yaml

server: port: 82

        SpringBoot配置文件加载顺序：

        application.properties > application.yml > application.yaml 

        常用配置文件种类：

        application.yml

        

        不同配置文件中相同配置按照加载优先级相互覆盖，不同配置文件中不同配置全部保留

三）自动提示功能消失解决方案（指定SpringBoot配置文件）

• Setting → Project Structure → Facets 
• 选中对应项目/工程 
• Customize Spring Boot 
• 选择配置文件

 

四）yaml简介

• YAML（YAML Ain't Markup Language），一种数据序列化格式 
• 优点：

• 容易阅读 
• 容易与脚本语言交互 
• 以数据为核心，重数据轻格式 

• YAML文件扩展名 

• .yml（主流） 
• .yaml

1.语法规则

• 大小写敏感 
• 属性层级关系使用多行描述，每行结尾使用冒号结束 
• 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）
• 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
• # 表示注释

• 核心规则：数据前面要加空格与冒号隔开

2.字面值表现方式

3.数组表示方式

        在属性名书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔

五）yaml数据读取

一）读取单个数据

使用@Value读取单个数据，属性名引用方式：${一级属性名.二级属性名……}

1. 使用@Value配合SpEL读取单个数据
2. 如果数据存在多层级，依次书写层级名称即可

二）使用属性名引用方式引用属性读取数据

1. 在配置文件中可以使用${属性名}方式引用属性值
2. 如果属性中出现特殊字符，可以使用双引号包裹起来作为字符解析

三）封装全部数据到Environment对象

1. 使用Environment对象封装全部配置信息
2.  使用@Autowired自动装配数据到Environment对象中

四）自定义对象封装指定数据（重点常用）

1. 使用@ConfigurationProperties注解绑定配置信息到封装类中 
2. 封装类需要定义为Spring管理的bean，否则无法进行属性注入

三、整合第三方技术

整合第三方技术通用方式 

• 导入对应的starter 
• 根据提供的配置格式，配置非默认值对应的配置项

一）整合JUnit

1. 导入测试对应的starter
2. 测试类使用@SpringBootTest修饰
3. 使用自动装配的形式添加要测试的对象
4. 测试类如果存在于引导类所在包或子包中无需指定引导类 2
5. 测试类如果不存在于引导类所在的包或子包中需要通过classes 属性指定引导类

①导入测试对应的starter

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

②测试类使用@SpringBootTest修饰

• 名称：@SpringBootTest
• 类型：测试类注解
• 位置：测试类定义上方
• 作用：设置JUnit加载的SpringBoot启动类
• 相关属性

• classes：设置SpringBoot启动类

• 范例:

@SpringBootTest(classes = Springboot05JUnitApplication.class) class Springboot07JUnitApplicationTests {}

 注意事项：如果测试类在SpringBoot启动类的包或子包中，可以省略启动类的设置，也就是省略classes的设定

③使用自动装配的形式添加要测试的对象

@SpringBootTest
class Springboot07JunitApplicationTests {
    @Autowired
    private BookService bookService;
    
    @Test
    public void testSave(){
        bookService.save();
    }
}

二）整合MyBatis

1. 勾选MyBatis技术，也就是导入MyBatis对应的starter

1. MyBatis模块需要使用的技术集（MyBatis、MySQL）

2.  数据库连接相关信息转换成配置
3.  数据库SQL映射需要添加@Mapper被容器识别到
4. MySQL 8.X驱动强制要求设置时区

1. 修改url，添加serverTimezone设定
2. 修改MySQL数据库配置（略）

5. 驱动类过时，提醒更换为com.mysql.cj.jdbc.Driver

②设置数据源参数

        SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区

jdbc:mysql://localhost:3306/mabatis-puls?serverTimezone=UTC

        或在MySQL数据库端配置时区解决此问题

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mabatis-puls?serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: *******
    password: ******

③定义数据层接口与映射配置

@Mapper
public interface UserDao {
    @Select("select * from user")
    public List<User> getAll();
}

④测试类中注入dao接口，测试功能

@SpringBootTest
class Springboot08MybatisApplicationTests {

    @Autowired
    private BookDao bookDao;

    @Test
    public void testGetById() {
        Book book = bookDao.getById(1);
        System.out.println(book);
    }
}

⑤

三）整合MyBatis-Plus

MyBatis-Plus与MyBatis区别 

• 导入坐标不同
• 数据层实现简化

步骤：

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

①手动添加SpringBoot整合MyBatis-Plus的坐标，可以通过mvnrepository获取

        由于SpringBoot中未收录MyBatis-Plus的坐标版本，需要指定对应的Version(用官方网站建的模块)，如果用阿里云的就不用导入了

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

②由于SpringBoot中未收录MyBatis-Plus的坐标版本，需要指定对应的Version

@Mapper
public interface UserDao extends BaseMapper<User> {

}

③其他同SpringBoot整合MyBatis

四）整合Druid

        1. 整合Druid需要导入Druid对应的starter

        2. 根据Druid提供的配置方式进行配置

四、基于SpringBoot实现SSM整合

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

一）实体开发

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

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

• lombok版本由SpringBoot提供，无需指定版本

开发常用三个注解：

• @Data
• @NoArgsConstructor
• @AllArgsConstructor

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

 例如：

package com.itheima2.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;


@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
    private int id;
    private String name;
    private String author;
    private Integer price;
    private int sales;
    private int stock;
    private String img_path;
}

二）数据层开发

1. 手工导入starter坐标（2个）
2. 配置数据源与MyBatisPlus对应的配置（为方便调试可以开启MyBatisPlus的日志）
3. 开发Dao接口（继承BaseMapper）
4. 制作测试类测试Dao功能是否有效

1.导入MyBatisPlus与Druid对应的starter

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

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

2.配置数据源与MyBatisPlus对应的基础配置（id生成策略使用数据库自增策略）

#配置数据源
spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/book?servierTimezone=UTC
      username: root
      password: Zwh1174946082!

#Mp配置
mybatis-plus:
  global-config:
    db-config:
      #设置前缀
      table-prefix: t_
      #设置递增类型
      id-type: auto
  #开启Mp运行日志
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3.创建一个类继承BaseMapper并指定泛型

package com.itheima2.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima2.pojo.Book;
import org.apache.ibatis.annotations.Mapper;


@Mapper
public interface BookDao extends BaseMapper<Book> {

}

三）数据层开发--分页功能

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

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

IPage对象中封装了分页操作中的所有数据

• 当前页码值               page.getTotal()
• 每页显示数据数量     page.getSize()
• 最大页码值                
• 数据总量

@Test
void testGetPage(){
    IPage page = new Page(1,5);
    bookDao.selectPage(page,null);
}

②分页操作是在MyBatisPlus的常规操作基础上增强得到，内部是动态的拼写SQL语句，因此需要增强对应的功能， 使用MyBatisPlus拦截器实现

package com.itheima2.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class MPConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        //1.创建一个MP的拦截器
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        
        //2.添加具体的拦截器
        
        //添加分页的拦截器
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());

        return interceptor;
    }

}

四）数据层开发--条件查询功能

1. 推荐使用LambdaQueryWrapper对象，所有查询操作封装成方法调用（这样就不用手动去写属性了）
2.  所有查询操作封装成方法调用
3. 查询条件支持动态条件拼装

@Test
void testGetByCondition(){
    IPage page = new Page(1,10);
    LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();

    lqw.like(Book::getName,"Spring");

    bookDao.selectPage(page,lqw);
}

五）业务层开发--快速开发

快速开发方案

• 使用MyBatisPlus提供有业务层通用接口（ISerivce）与业务层通用实现类（ServiceImpl）
• 在通用类基础上做功能重载或功能追加
• 注意重载时不要覆盖原始操作，避免原始提供的功能丢失

①接口定义

public interface IBookService extends IService<Book> {

//追加的功能

//可以用@Override查看是否与IService里面的方法重名，如果@Override不报错就是重名了，报错就不重名
}

②实现类定义

@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);
    }
}

六）表现层开发

• 基于Restful制作表现层接口

• 新增：POST
• 删除：DELETE
• 修改：PUT
• 查询：GET

• 实体数据：@RequestBody
• 路径变量：@PathVariable

1.表现层接口开发

package com.itheima.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.itheima.controller.utils.R;
import com.itheima.domain.Book;
import com.itheima.service.IBookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.util.List;

@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) throws IOException {
        //测试用的专门用来制作异常
        if (book.getName().equals("123")) throw new IOException();
        boolean flag = bookService.save(book);
        return new R(flag, flag ? "添加成功^_^" : "添加失败-_-!");
    }

    @PutMapping
    public R update(@RequestBody Book book) throws IOException {
        if (book.getName().equals("123")) throw new IOException();
        boolean flag = bookService.modify(book);
        return new R(flag, flag ? "修改成功^_^" : "修改失败-_-!");
    }

    @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, @PathVariable int pageSize, Book book) {


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

}

2.表现层消息一致性处理

设计表现层返回结果的模型类，用于后端与前端进行数据格式统一，也称为前后端数据协议

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

package com.itheima2.controller.utils;


import lombok.Data;


@Data
public class R {
    private Boolean flag;
    private Object data;
    private String msg;

    public R() {
    }

    public R(Boolean flag) {
        this.flag = flag;
    }

    public R(Boolean flag, Object data) {
        this.flag = flag;
        this.data = data;
    }

    public R(Boolean flag, String msg) {
        this.flag = flag;
        this.msg = msg;
    }

    public R(String msg) {
        this.flag = false;
        this.msg = msg;
    }
}

七）前后端协议联调

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

①页面层 

<script>
    var vue = new Vue({
        el: '#app',
        data:{
            dataList: [],//当前页要展示的列表数据
            dialogFormVisible: false,//添加表单是否可见
            dialogFormVisible4Edit:false,//编辑表单是否可见
            formData: {},//表单数据
            rules: {//校验规则
                type: [{ required: true, message: '图书类别为必填项', trigger: 'blur' }],
                name: [{ required: true, message: '图书名称为必填项', trigger: 'blur' }]
            },
            pagination: {//分页相关模型数据
                currentPage: 1,//当前页码
                pageSize:10,//每页显示的记录数
                total:0,//总记录数
                //条件查询功能
                type: "",
                name: "",
                description: ""
            }
        },

        //钩子函数，VUE对象初始化完成后自动执行
        created() {
            //调用查询全部数据的操作
            this.getAll();
        },

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

            //分页查询
            getAll() {
                //条件查询
                //组织参数，拼接url请求地址
                param = "?type="+this.pagination.type;
                param +="&name="+this.pagination.name;
                param +="&description="+this.pagination.description;
                // console.log(param);

                //发送异步请求
                axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize+param).then((res)=>{
                    this.pagination.pageSize = res.data.data.size;
                    this.pagination.currentPage = res.data.data.current;
                    this.pagination.total = res.data.data.total;

                    this.dataList = res.data.data.records;
                });
            },

            //切换页码
            handleCurrentChange(currentPage) {
                //修改页码值为当前选中的页码值
                this.pagination.currentPage = currentPage;
                //执行查询
                this.getAll();
            },

            //弹出添加窗口
            handleCreate() {
                this.dialogFormVisible = true;
                this.resetForm();
            },

            //重置表单
            resetForm() {
                this.formData = {};
            },

            //添加
            handleAdd () {
                axios.post("/books",this.formData).then((res)=>{
                    //判断当前操作是否成功
                    if(res.data.flag){
                        //1.关闭弹层
                        this.dialogFormVisible = false;
                        this.$message.success(res.data.msg);
                    }else{
                        this.$message.error(res.data.msg);
                    }
                }).finally(()=>{
                    //2.重新加载数据
                    this.getAll();
                });
            },

            //取消
            cancel(){
                this.dialogFormVisible = false;
                this.dialogFormVisible4Edit = false;
                this.$message.info("当前操作取消");
            },

            // 删除
            handleDelete(row) {
                // console.log(row);
                this.$confirm("此操作永久删除当前信息，是否继续？","提示",{type:"info"}).then(()=>{
                    axios.delete("/books/"+row.id).then((res)=>{
                        if(res.data.flag){
                            this.$message.success("删除成功");
                        }else{
                            this.$message.error("数据同步失败，自动刷新");
                        }
                    }).finally(()=>{
                        //2.重新加载数据
                        this.getAll();
                    });
                }).catch(()=>{
                    this.$message.info("取消操作");
                });
            },

            //弹出编辑窗口
            handleUpdate(row) {
                axios.get("/books/"+row.id).then((res)=>{
                    if(res.data.flag && res.data.data != null ){
                        this.dialogFormVisible4Edit = true;
                        this.formData = res.data.data;
                    }else{
                        this.$message.error("数据同步失败，自动刷新");
                    }
                }).finally(()=>{
                    //2.重新加载数据
                    this.getAll();
                });
            },

            //修改
            handleEdit() {
                axios.put("/books",this.formData).then((res)=>{
                    //判断当前操作是否成功
                    if(res.data.flag){
                        //1.关闭弹层
                        this.dialogFormVisible4Edit = false;
                        this.$message.success("修改成功");
                    }else{
                        this.$message.error("修改失败");
                    }
                }).finally(()=>{
                    //2.重新加载数据
                    this.getAll();
                });
            },

            //条件查询
        }
    })

</script>