SpringBoot框架的学习-手写笔记小白也能看得懂

瑶瑶在学习

于 2024-07-17 10:46:12 发布

阅读量1k

点赞数 23

分类专栏：后端java高级篇文章标签： spring boot 学习笔记

本文链接：https://blog.csdn.net/m0_74194490/article/details/140488450

版权

后端java高级篇专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.SpringBoot搭建

1.1什么是SpringBoot

SpringBoot也是spring公司开发的一款框架。

为了简化Spring项目的初始化搭建的。不是对Spring功能上的增强。

spring项目搭建的缺点：①配置麻烦②依赖注入③tomcat启动慢

这些SpringBoot都给简化了

1.2SpringBoot的特点

1）自动配置

Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。

2）起步依赖--依赖传递

起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。

简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

3）辅助功能

提供了一些大型项目中常见的非功能性特性，如嵌入式服务器tomcat、安全、指标，健康检测、外部配置等。

1.3快速搭建SpringBoot的项目

1.3.1JDK17版本

<?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>
        <!--springboot3.0以上必须使用jdk17-->
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ykq</groupId>
    <artifactId>qy174-demo01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>qy174-demo01</name>
    <description>qy174-demo01</description>

    <properties>
        <java.version>8</java.version>
    </properties>
    <dependencies>
        <!--web依赖jar-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--单元测试jar-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>


    <!--如果下方出现红色可以删除-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

1.3.2JDK8版本

2.SpringBoot的常用配置文件种类和获取方式

2.1 常用的配置文件种类

SpringBoot提供了两种配置文件。默认配置文件名称：application

在同一级目录下优先级为：properties>yml>yaml

①properties ②yml/yaml

# key=value
# 端口号
server.port=8080
# 上下文路径
server.servlet.context-path=/qq

server:
  port: 8081
  servlet:
    context-path: /bb

yml/yaml格式

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

2.2 读取配置文件中的内容（重点）

把自己的信息放入配置文件中，方便修改。

比如OSS、支付...

第一种：@ConfigurationProperties

第二种：@Value("${获取的属性名}")

第三种：自动注入Environment类型的属性,用getProperty方法获取想要的属性内容

3. profile多环境配置（重点）

我们在开发SpringBoot应用时，通常同一套程序会被安装到不同环境，

比如：开发、测试、生产等。

其中数据库地址、服务器端口等等配置都不相同，如果每次打包时都要修改配置文件，就比较麻烦。

profile功能就是进行动态配置切换的。

profile小结：

1）profile是用来完成不同环境下，配置动态切换功能的。

2）profile配置方式

多peofile文件方式：提供多个配置文件，每个代表一种环境。

- application-dev.properties/yml/yaml--开发环境
- application-test.properties/yml/yaml--测试环境
- application-pro.properties/yml/yaml--生产环境

yml/yaml多文档方式

- 在yml/yaml中使用--分隔不同配置

3)profile激活方式

配置文件：在配置文件中配置：spring.profiles.active=dev/test/pro
运行打包文件：java -jar ./springBoot01-0.0.1-SNAPSHOT.jar
命令行参数：java -jar xxx.jar --spring.profiles.active=dev/test/pro
虚拟机参数：在VM options指定：-Dspring.properties.active=dev/test/pro

4. springboot注册web组件(servlet、filter组件)

web组件：就是servlet、filter组件

之前servlet的步骤：

①创建一个类并继承HttpServlet重写service方法

②注册到web.xml文件中

SpringBoot中如何注册servlet和Filter？（没有web.xml文件了）

--提供了一个配置类

步骤：

// 创建一个Servlet
public class MyServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
    }
}
 // 创建一个Filter
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("过滤器++++++++++++++");
    }
}

package com.wjy.springboot01.config;

import com.wjy.springboot01.filter.MyFilter;
import com.wjy.springboot01.servlet.MyServlet;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration//表示该类为配置类，等价于之前的xml配置文件
public class MyConfig {
// Servlet服务器
    @Bean
    public ServletRegistrationBean myServlet(){
        ServletRegistrationBean bean = new ServletRegistratio nBean();
        bean.setServlet(new MyServlet());
        bean.setName("my");
        bean.setLoadOnStartup(1);
        bean.addUrlMappings("/my");
        return bean;
    }

//    过滤器
    @Bean
    public FilterRegistrationBean myFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new MyFilter());
        bean.addUrlPatterns("/*");
        return bean;
    }
}

测试访问

5. springboot包扫描的原理(面试)

ssm项目必须加包扫描。而现在springboot没有在写包扫描了。自带了包扫描的功能。

核心在主类上@SpringBootApplication上，它是一个复合注解。里面包含@EnableAutoConfiguration开启自动配置，里面包含@AutoConfigurationPackage。@Import({AutoConfigurationPackages.Registrar.class})需要导入一个自动配置包的类。加载主类所在的包，并按照该包进行扫描。

我们如果不想让他扫描主类所在的包，我们可以使用@CompentScan(basePackages={})来指定自己的包

6. springboot自动装配的原理(面试)

在main中运行run方法，在run方法中引入@SpringBootApplication依赖的类，该类下包含@EnableAutoConfiguration注解，开启自动配置功能，该注解下包含@Import注解，该注解必须导入AutoConfigurationImportSelector.class自动配置选择器类，该类会自动装配一些自动配置类，完成自动装配。

7. springboot整合第三方框架

版本号--jdk17,springBoot3

7.1整合mybatis

引入依赖

<?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>
  <!--springboot工程需要继承的父工程-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.1</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.wjy</groupId>
  <artifactId>springBoot01</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>springBoot01</name>
  <description>springBoot01</description>

  <properties>
    <java.version>17</java.version>
  </properties>
  <dependencies>

    
    <!--web开发的起步依赖jar-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--mysql驱动类-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.28</version>
    </dependency>
    <!--mybatis和springboot整合的jar-->
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>3.0.3</version>
    </dependency>
    <!--单元测试jar-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
    </dependency>

    /
  </dependencies>
  <!--可要可不要-->
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

配置文件

spring.application.name=SpringBoot02-mybatis1
#数据源的信息
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimeZone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
#配置mybatis映射文件的路径resources包下.xml文件
mybatis.mapper-locations=classpath:mapper/*.xml

实体类

@Data
public class User{
    private Integer userid;
    private String username;
    private String sex;
    private Integer age;
}

dao/mapper接口--对数据库的操作

package com.wjy.mapper;

import com.wjy.entity.User;

import java.util.List;

/**
* @author WJY
* @description 针对表【t_user】的数据库操作Mapper
* @createDate 2024-07-12 10:28:27
* @Entity com.wjy.entity.User
*/
public interface UserMapper {
    //增加一条数据
    int insert(User user);
    //根据id查询一条数据
    User selectById(Integer id);
    //根据id修改一条数据
    int update(User user);
    //根据id删除一条数据
    int deleteById(Integer id);
    //查询全部
    List<User> selectAll();
}

入口函数

package com.wjy;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = {"com.wjy.mapper"})//为指定的包生成代理类
//指定要扫描的Mapper类的包的路径，添加@MapperScan(“com.wjy.mapper”)注解以后，com.wjy.mapper包下面的接口类，在编译之后都会生成相应的实现类
//在Mapper类上面添加注解@Mapper，这种方式要求每一个mapper类都需要添加此注解，比较麻烦。
public class SpringBoot02Mybatis1Application {

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

接口的映射文件--对数据库操作的语句

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wjy.mapper.UserMapper">

  <resultMap id="BaseResultMap" type="com.wjy.entity.User">
    <id property="userid" column="userid" jdbcType="INTEGER"/>
    <result property="username" column="username" jdbcType="VARCHAR"/>
    <result property="sex" column="sex" jdbcType="VARCHAR"/>
    <result property="age" column="age" jdbcType="INTEGER"/>
  </resultMap>

  <sql id="Base_Column_List">
    userid,username,sex,
    age
  </sql>
  //
  <update id="update">
    update t_user
    <set>
      <if test="username!=null and username!=''">
        username=#{username}
      </if>
      <if test="sex!=null and sex!=''">
        sex=#{sex}
      </if>
      <if test="age!=null and age!=''">
        age=#{age}
      </if>
      where userid=#{userid}
    </set>
  </update>
  <delete id="deleteById">
    delete from t_user where userid=#{userid}
  </delete>

  <select id="selectById" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from t_user
    where  userid = #{userid,jdbcType=INTEGER} 
  </select>

  <select id="selectAll" resultType="com.wjy.entity.User">
    select * from t_user
  </select>


  <insert id="insert" keyColumn="userid" keyProperty="userid" parameterType="com.wjy.entity.User" useGeneratedKeys="true">
    insert into t_user
    ( userid,username,sex
    ,age)
    values (#{userid,jdbcType=INTEGER},#{username,jdbcType=VARCHAR},#{sex,jdbcType=VARCHAR}
    ,#{age,jdbcType=INTEGER})
  </insert>
  
</mapper>

vo包下R类，传递参数信息类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class R {
    private Integer code;
    private String msg;
    private Object data;
}

service业务接口层

public interface UserService {
    public R selectUserById(int id);
    public R insertUser(User user);
    public R updateUser(User user);
    public R deleteUserById(int id);
    public R selectAll();
}

serviceImpl业务层--提供一些服务的

package com.wjy.service.impl;

import com.wjy.entity.User;
import com.wjy.mapper.UserMapper;
import com.wjy.service.UserService;
import com.wjy.vo.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public R selectUserById(int id) {
        User user = userMapper.selectById(id);
        if (user != null) {
            return new R(200,"成功",user);
        }
        return null;
    }

    @Override
    public R insertUser(User user) {
        int insert = userMapper.insert(user);
        if (insert > 0) {
            return new R(200,"插入成功",insert);
        }
        return null;
    }

    @Override
    public R updateUser(User user) {
        int update = userMapper.update(user);
        if (update > 0) {
            return new R(200,"修改成功",update);
        }
        return null;
    }

    @Override
    public R deleteUserById(int id) {
        int i = userMapper.deleteById(id);
        if (i > 0) {
            return new R(200,"删除成功",i);
        }
        return null;
    }

    @Override
    public R selectAll() {
        List<User> users = userMapper.selectAll();
        return new R(200,"查询成功",users);
    }
}

controller控制层

查询是get,增加修改是put，删除delete

帮助记忆：查询为获取数据，增加修改都是放入数据，删除就是删除

package com.wjy.controller;

import com.wjy.entity.User;
import com.wjy.service.UserService;
import com.wjy.vo.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;
//根据id查找
    @GetMapping("sel")
    public R sel(int id){
        return userService.selectUserById(id);
    }
//插入一条数据
    @PutMapping("insert")
    public R insert(@RequestBody User user){
        return userService.insertUser(user);
    }
//修改一条数据
    @PutMapping("update")
    public R update(@RequestBody User user){
        return userService.updateUser(user);
    }
//删除一条数据
    @DeleteMapping("del")
    public R del(int id){
        return userService.deleteUserById(id);
    }
//查找全部信息
    @GetMapping("all")
    public R all(){
        return userService.selectAll();
    }
}

7.2 整合swagger3

7.2.1什么是swagger3？

swagger是一个规范和完整的框架，用于生成、描述、调用和可视化Restful风格的web服务。

作用：接口的文档在线自动生成、功能的测试。

一句话来说：swagger就是在线生成接口文档，测试功能的。

7.2.3为什么需要使用swagger3？

7.2.4如何使用seagger3/2？

1.引入依赖

<!--swagger3-->
<dependency>
  <groupId>com.github.xiaoymin</groupId>
  <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
  <version>4.1.0</version>
</dependency>

2.创建swagger配置类

package com.wjy.config;

import io.swagger.v3.oas.models.ExternalDocumentation;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SwaggerConfig {
    @Bean
    public OpenAPI springShopOpenAPI() {
        return new OpenAPI()
            .info(new Info()
                    .title("用户管理系统API")//标题
                    .contact(new Contact())
                    .description("改系统中的接口专门操作用户的")//简介
                    .version("v1.0")//版本号
                    .license(new License().name("Apache 2.0").url("http://springdoc.org")))
                    .externalDocs(new ExternalDocumentation()
                    .description("外部文档")
                    .url("https://springshop.wiki.github.org/docs"));
    }
}

<!--1.引入swagger2依赖-->
        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>swagger-spring-boot-starter</artifactId>
            <version>1.9.1.RELEASE</version>
        </dependency>
        <!--图形化依赖-->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.6</version>
        </dependency>
/创建swagger2配置类///
package com.ykq.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.VendorExtension;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

import java.util.ArrayList;
@Configuration
public class SwaggerConfig {

    //创建swagger实例
    @Bean
    public Docket docket() {
        Docket docket=
                new Docket(DocumentationType.SWAGGER_2)
                        .apiInfo(getInfo())//设置接口文档的信息
                        .select()
                        .apis(RequestHandlerSelectors.basePackage("com.ykq.controller")) //指定为那些路径下得到类生成接口文档
                        .build()
                ;

        return docket;
    }

    private ApiInfo getInfo(){
        Contact DEFAULT_CONTACT = new Contact("李东威", "http://www.ldw.com", "110@qq.com");
        ApiInfo DEFAULT = new ApiInfo("用户管理系统API", "该系统中的接口专门操作用户的", "v1.0", "http://www.baidu.com",
                DEFAULT_CONTACT, "漫动者", "http://www.jd.com", new ArrayList<VendorExtension>());
        return DEFAULT;
    }
}

3.在入口函数类上引入@EnableSwagger2开启

7.2.5访问swagger接口文档网址

第一种: http://localhost:8080/swagger-ui.html

第二种: http://localhost:8080/doc.html

7.2.6swagger常用注解

注解位置	swagger3	swagger2
Controller类上	@Tag(name="")	@Api(tag="")
Controller方法上 (API端口方法)	@Operation(summary="",desciption="")	@ApiOperation(value="")
Controller所有参数 (API方法的所有参数概述)	@Parameters（ @Parameter（name="参数名",value="对参数的描述",require="是否必写"），... ）	@ApiImplicitiParams（ @ApiImplicitiParam（name="参数名",value="对参数的描述",require="是否必写",dataType="数据类型"）,.... ）
实体类entity类上	@Schema(description="")	@ApiModel（value=""）
实体类entity属性上	@Schema(description="")	@ApiModelProperty(value="")

package com.wjy.controller;
import com.wjy.entity.User;
import com.wjy.service.UserService;
import com.wjy.vo.R;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("user")
@Tag(name = "用户控制层类")
public class UserController {
    @Autowired
    private UserService userService;

    @Operation(summary = "查询全部user表的信息")
    @GetMapping("sel")
    public R getUser(){
        return userService.findAll();
    }

    @Operation(summary = "增加数据",description = "增加条数据")
    @PutMapping("add")
    public R addUser(@Parameter(name = "user",description = "用户对象表",required = true) @RequestBody User user){
        return userService.insert(user);
    }
}

package com.wjy.entity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

@Data
@Schema(description = "用户实体类")
public class User {
    @Schema(description = "用户编号")
    private Integer userid;
    @Schema(description = "姓名")
    private String username;
    @Schema(description = "性别")
    private String sex;
    @Schema(description = "年龄")
    private Integer age;
}

package com.wjy.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Schema(description = "传递数据类")
public class R {
    @Schema(description = "状态码数")
    private Integer code;
    @Schema(description = "是否成功消息")
    private String msg;
    @Schema(description = "传递的数据")
    private Object data;
}

7.3整合定时器

在指定的时间执行相应的业务代码。

--场景1：oss修改图片时，存在一个冗余图片，定时删除冗余图片。

--场景2：下单。30分钟未支付取消订单。

--场景3：新用户注册成功后，7天发送问候语。

使用：

1.引入定时器依赖

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

2.创建一个定时业务--配置类中

package com.wjy.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Scheduled;

@Configuration
public class MyQuartzConfig {

    //定时业务代码
    //定义定时规则
    @Scheduled(cron = "0 30 * * * ? ")
    public void show(){
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        //发生短信 或者删除oss冗余文件  或者取消订单
    }
}

3.在入口函数中开启

cron:在线表达式生成器工具：Cron - 在线Cron表达式生成器

7.4整合mybatis-plus

官网：快速开始 | MyBatis-Plus

7.4.1概述

MyBatis-Plus 是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

7.4.2特点

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作。
强大的 CRUD 操作：内置==通用 Mapper==、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询。
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

7.4.3mybatis-plus的如何使用

1.注入依赖jar

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

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

2.配置文件

数据库
映射文件路径

- mybatis-plus.mapper-locations=classpath*:mapper/*.xml

配置日志-sql日志

- mybatis-plus.configuration.log-impl=StdOutImpl

spring.application.name=qy174-springboot-mp
#数据库
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mp?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
#映射文件路径
mybatis-plus.mapper-locations=classpath*:mapper/*.xml
#配置日志--sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

3.写实体类--加上swagger在线文档说明

package com.wjy.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @TableName dept
 */
@TableName(value ="dept")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Schema(description = "部门实体类")
public class Dept{
    @TableId(type = IdType.AUTO)
    @Schema(description = "部门编号")
    private Integer id;
    @Schema(description = "部门名称")
    private String deptName;
}


package com.wjy.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;

import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;

/**
 * @TableName emp
 */
@TableName(value ="emp")
@Data
@AllArgsConstructor
@NoArgsConstructor
@Schema(description = "员工实体类")
public class Emp{
    @TableId(type = IdType.AUTO)
    @Schema(description = "员工编号")
    private Integer id;
    @Schema(description = "员工姓名")
    private String name;
    @Schema(description = "生日")
    private String birthday;
    @Schema(description = "入职时间")
    private String hireDate;
    @Schema(description = "薪资")
    private Double salary;
    @Schema(description = "部门编号--外键")
    private Integer deptId;

    @TableField(exist = false)
    private Dept dept;
}

4.mapper接口层

extends了BaseMapper<Emp>类（具有单表操作的功能）
IPage<Emp> selectByPage(IPage<Emp> page, @Param("ew") Wrapper<Emp> queryWrapper);(链表查询分页操作)--单独设置

package com.wjy.mapper;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.wjy.entity.Emp;
import org.apache.ibatis.annotations.Param;

/**
* @author WJY
* @description 针对表【emp】的数据库操作Mapper
* @createDate 2024-07-14 09:48:05
* @Entity com.wjy.entity.Emp
*/
public interface EmpMapper extends BaseMapper<Emp> {
    //分页链表查询接口--查询条件
    IPage<Emp> selectByPage(IPage<Emp> page, @Param("ew") Wrapper<Emp> queryWrapper);
}

package com.wjy.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wjy.entity.Dept;

/**
* @author WJY
* @description 针对表【dept】的数据库操作Mapper
* @createDate 2024-07-14 09:47:57
* @Entity com.wjy.entity.Dept
*/
public interface DeptMapper extends BaseMapper<Dept> {

}

5.mapper映射层.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wjy.mapper.EmpMapper">
    <resultMap id="BaseMapping" type="com.wjy.entity.Emp">
        <id property="id" column="id" javaType="java.lang.Integer"/>
        <result property="name" column="name"/>
        <result property="birthday" column="birthday"/>
        <result property="hireDate" column="hire_date"/>
        <result property="birthday" column="birthday"/>
        <result property="salary" column="salary"/>
        <result property="deptId" column="dept_id"/>

<!--多对一的标签-->
        <association property="dept" javaType="com.wjy.entity.Dept">
            <id property="id" column="id"/>
            <result property="deptName" column="dept_name"/>
        </association>
    </resultMap>
<!--查询员工表所有员工包含部门信息-->
    <select id="selectByPage" resultMap="BaseMapping">
        select * from companny.emp e join companny.dept d
        on e.dept_id = d.id
        <if test="ew!=null and ew.sqlSelect!=''">
            ${ew.customSqlSegment}
        </if>
    </select>
</mapper>

6.配置类

package com.wjy.config;

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

@Configuration
@MapperScan("com.wjy.mapper")
public class MybatisPlusConfig {

    /**
     * 添加分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 如果配置多个插件, 切记分页最后添加
        // 如果有多数据源可以不配具体类型, 否则都建议配上具体的 DbType
        return interceptor;
    }
}

package com.wjy.config;

import io.swagger.v3.oas.models.ExternalDocumentation;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SwaggerConfig {
    @Bean
    public OpenAPI springShopOpenAPI() {
        return new OpenAPI()
            .info(new Info()
                    .title("用户管理系统API")//标题
                    .contact(new Contact())
                    .description("改系统中的接口专门操作用户的")//简介
                    .version("v1.0")//版本号
                    .license(new License().name("Apache 2.0").url("http://springdoc.org")))
                    .externalDocs(new ExternalDocumentation()
                    .description("外部文档")
                    .url("https://springshop.wiki.github.org/docs"));
    }
}

7.vo类--前端所需要提供的数据

比如R：code、msg、data。后端给前端的提示信息以及传输的数据

package com.wjy.vo;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Schema(description = "前端传来的关于员工表的数据")
public class EmpVo {
    @Schema(description = "姓名")
    private String name;

}

8.入口函数

package com.wjy;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication//启动类
@MapperScan(basePackages = "com.wjy.mapper")//扫描mapper接口
public class SpringBootmybtaisPlusCrudApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootmybtaisPlusCrudApplication.class, args);
    }

}

9.测试

单表操作：直接调用mybtais-plus自带的方法

如果有附加条件操作，增删改new UpdateWrapper<>()条件类

，查询操作new QueryWrapper<>()条件类

---StringUtils工具类判断是否为空等

package com.wjy;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wjy.entity.Dept;
import com.wjy.entity.Emp;
import com.wjy.mapper.DeptMapper;
import com.wjy.mapper.EmpMapper;
import com.wjy.vo.EmpVo;
import org.junit.jupiter.api.Test;
import org.junit.platform.commons.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;
import java.util.List;
import java.util.Objects;

@SpringBootTest//启动类
class SpringBootmybtaisPlusCrudApplicationTests {

    @Autowired//自动注入
    private DeptMapper deptMapper;
    @Autowired
    private EmpMapper empMapper;

    /**
     * 增加
     */
    @Test
    void insert() {
        //增加员工
        int i = empMapper.insert(new Emp(null, "王佳瑶", "20001-12-03", "2024-07-14", 200000.0, 6,null));
        System.out.println(i);
        //增加部门
        int i1 = deptMapper.insert(new Dept(null, "干饭部"));
        System.out.println(i1);
    }

    /**
     * 删除
     */
    @Test
    void del(){
        //根据id删除
        System.out.println(deptMapper.deleteById(11));
        //条件删除
        UpdateWrapper<Emp> wrapper = new UpdateWrapper<>();
        //删除员工表中姓张的员工 或者 薪水小于10000
        wrapper.likeLeft("name","张").or().lt("salary",10000);
        empMapper.delete(wrapper);
    }

    /**
     * 修改
     */
    @Test
    void update(){
        //修改部门信息--根据id修改
        System.out.println(deptMapper.updateById(new Dept(7, "玩乐部")));
        //给员工姓王的部门换为7号部门
        Emp emp = new Emp();
        emp.setDeptId(7);
        UpdateWrapper<Emp> wrapper = new UpdateWrapper<>();
        wrapper.likeRight("name","王");
        empMapper.update(emp,wrapper);//(修改的内容，条件)
    }

    /**
     * 查询--前端查询员工姓王的
     */
    @Test
    void select(){
        EmpVo empVo = new EmpVo();
        empVo.setName("王");
        QueryWrapper<Emp> wrapper = new QueryWrapper<>();
        //使用工具类--判断员工姓名是否为空
        if (StringUtils.isNotBlank(empVo.getName())) {
            wrapper.likeRight("name",empVo.getName());
        }
        List<Emp> emps = empMapper.selectList(wrapper);
        emps.stream()
                .forEach(System.out::println);
    }

    /**
     * 查询+分页效果--链表查询（自己定义）
     */
    @Test
    void selPage(){
        Page<Emp> page = new Page<>(1, 5);
        QueryWrapper<Emp> wrapper = new QueryWrapper<>();
        //wrapper.likeRight("name","王");
        IPage<Emp> empIPage = empMapper.selectByPage(page, wrapper);
        empIPage.getRecords().stream()
                .forEach(System.out::println);
        System.out.println("总条数："+empIPage.getTotal());
        System.out.println("总页数"+empIPage.getPages());
        System.out.println("当前页的记录数据"+empIPage.getRecords());
    }
}

瑶瑶在学习

关注

23
点赞
踩
28

收藏

觉得还不错? 一键收藏
1
评论
SpringBoot框架的学习-手写笔记小白也能看得懂

SpringBoot也是spring公司开发的一款框架。为了简化Spring项目的初始化搭建的。不是对Spring功能上的增强。spring项目搭建的缺点：①配置麻烦②依赖注入③tomcat启动慢这些SpringBoot都给简化了swagger是一个规范和完整的框架，用于生成、描述、调用和可视化Restful风格的web服务。作用：接口的文档在线自动生成、功能的测试。swagger就是在线生成接口文档测试功能的。是一个MyBatis。
复制链接

扫一扫

专栏目录