添加依赖

在 /pom.xml 文件中写入以下代码

xml

<!-- MySQL 官方新版驱动（适配 5.7+/8.0+） -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.0.33</version>
    <scope>runtime</scope> <!-- 仅运行时依赖，符合 Spring Boot 最佳实践 -->
</dependency>

<!-- MyBatis-Plus 核心起步依赖（自动整合 MyBatis + 核心功能） -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.5</version> <!-- 稳定版 -->
</dependency>

mysql连接配置 +

yml

spring:
  # 数据库 + 连接池（HikariCP）配置（Spring Boot 默认连接池，性能最优）
  datasource:
    # 驱动类名（新版 MySQL 8.x 固定）
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/xys1?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
    username: root
    password: root
    # HikariCP 连接池自定义配置（核心！生产环境必须调优）
    hikari:
      minimum-idle: 5 # 最小空闲连接数（默认5，根据业务调整）
      maximum-pool-size: 20 # 最大连接数（默认10，高并发场景可调大）
      auto-commit: true # 自动提交事务
      idle-timeout: 300000 # 空闲连接超时时间（5分钟，默认600000）
      pool-name: DemoHikariCP # 连接池名称（便于监控）
      max-lifetime: 1800000 # 连接最大存活时间（30分钟，默认1800000）
      connection-timeout: 30000 # 连接超时时间（30秒，默认30000）
      # 连接测试（确保获取的连接可用）
      connection-test-query: SELECT 1

# MyBatis-Plus 完整配置（核心！体现 MyBatis-Plus 特性）
mybatis-plus:
  mapper-locations: classpath:mapper/**/*.xml # 1. 映射文件位置（如果有 XML 自定义 SQL，需配置）
  type-aliases-package: com.example.xys1.entity.** # 2. 实体类包名（自动扫描，简化别名）
  global-config:
    db-config:
      # 主键策略（MySQL 自增主键）
      id-type: auto
      # 表名前缀（如果表名统一加前缀，如 t_user，实体类是 User，可配置）
      # table-prefix: t_
      # 逻辑删除配置（MyBatis-Plus 核心特性）
      # logic-delete-field: isDeleted # 全局逻辑删除字段名
      # logic-delete-value: 1 # 逻辑删除值（表示已删除）
      # logic-not-delete-value: 0 # 逻辑未删除值
    # 关闭 Banner 打印（可选）
    banner: false
  # 4. 配置项（开发调试必备）
  configuration:
    map-underscore-to-camel-case: true # 驼峰转换（默认开启，可省略）
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 开发环境用这个org.apache.ibatis.logging.stdout.StdOutImpl 生产环境改成这个 org.apache.ibatis.logging.nologging.NoLoggingImpl
    default-statement-timeout: 30 # 设置超时时间（避免慢 SQL 阻塞）
    local-cache-scope: SESSION # 推荐 SESSION，除非你明确知道需要 STATEMENT

创建文件 (controller,entity,mapper,service,dto5个,vo2个)

controller

package com.example.xys1.controller;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.xys1.dto.article.*;
import com.example.xys1.entity.ArtiCleEntity;
import com.example.xys1.service.ArticleService;
import com.example.xys1.utils.MysqlLimitStrUtil;
import com.example.xys1.utils.res.PageVo;
import com.example.xys1.utils.res.ResUtil;
import com.example.xys1.vo.article.ArticleInfoVo;
import com.example.xys1.vo.article.ArticleItemVo;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

// 标识为控制器，且所有方法返回值直接转为 JSON（无需视图解析）
@RestController
@RequestMapping("/article")
public class ArticleController {
    @Resource
    private ArticleService articleService;

    @PostMapping("/articleAdd")
    public ResUtil<String> articleAdd(@RequestBody ArticleAddDto dto) {
        ArtiCleEntity addEntity = new ArtiCleEntity();
        addEntity.setCreateBy(1001L);
        addEntity.setCreateAt(System.currentTimeMillis());

        addEntity.setTitle(dto.getTitle());
        addEntity.setContent(dto.getContent());
        addEntity.setCoverImg(dto.getCoverImg());

        articleService.save(addEntity);
        return ResUtil.ok(String.valueOf(addEntity.getId()));
    }

    @PostMapping("/articleDelete")
    public ResUtil<?> articleDelete(@RequestBody ArticleDeleteDto dto) {
        articleService.removeByIds(dto.getIds());
        return ResUtil.ok(null);
    }

    @PostMapping("/articleUpdate")
    public ResUtil<?> articleUpdate(@RequestBody ArticleUpdateDto dto) {
        ArtiCleEntity updateEntity = new ArtiCleEntity();
        updateEntity.setUpdateBy(1001L);
        updateEntity.setUpdateBy(System.currentTimeMillis());

        updateEntity.setId(dto.getId());
        updateEntity.setTitle(dto.getTitle());
        updateEntity.setContent(dto.getContent());
        updateEntity.setCoverImg(dto.getCoverImg());

        articleService.updateById(updateEntity);
        return ResUtil.ok(null);
    }

    @PostMapping("/articleList")
    public ResUtil<PageVo<ArticleItemVo>> articleList(@RequestBody ArticleListDto dto) {
        // queryWrapper
        LambdaQueryWrapper<ArtiCleEntity> queryWrapper = getQueryWrapper(dto);

        // total
        long total = articleService.count(queryWrapper);

        // list
        List<ArtiCleEntity> list = new ArrayList<>();
        if (total > 0L) {
            queryWrapper.last(MysqlLimitStrUtil.getLimitStr(dto.getPageNum(), dto.getPageSize()));
            list = articleService.list(queryWrapper);
        }

        // newList
        List<ArticleItemVo> newList = list.stream().map(item -> {
            ArticleItemVo vo = new ArticleItemVo();
            vo.setId(item.getId());
            vo.setTitle(item.getTitle());
            vo.setCoverImg(item.getCoverImg());
            vo.setCreateAtStr("a");
            vo.setUpdateAtStr("b");
            return vo;
        }).collect(Collectors.toList());

        // return
        PageVo<ArticleItemVo> pageVo = new PageVo<>();
        pageVo.setTotal(Convert.toLong(total));
        pageVo.setRows(newList);
        return ResUtil.ok(pageVo);
    }

    private LambdaQueryWrapper<ArtiCleEntity> getQueryWrapper(ArticleListDto dto) {
        // where
        LambdaQueryWrapper<ArtiCleEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(StrUtil.isNotBlank(dto.getTitle()), ArtiCleEntity::getTitle, dto.getTitle());

        // 排序
        queryWrapper.orderByDesc(ArtiCleEntity::getId);
        return queryWrapper;
    }

    @PostMapping("/articleInfo")
    public ResUtil<ArticleInfoVo> articleInfo(@RequestBody ArticleInfoDto dto) {
        ArtiCleEntity find = articleService.getById(dto.getId());
        if (Objects.isNull(find)) {
            return ResUtil.fail("'信息不存在'");
        }

        ArticleInfoVo vo = new ArticleInfoVo();
        BeanUtil.copyProperties(find, vo);

        return ResUtil.ok(vo);
    }
}

entity

package com.example.xys1.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;

@Data
@TableName("article")
public class ArtiCleEntity {

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @TableField("remark")
    private String remark;

    @TableField("create_by")
    private Long createBy;

    @TableField("delete_by")
    private Long deleteBy;

    @TableField("update_by")
    private Long updateBy;

    @TableField("create_at")
    private Long createAt;

    @TableField("delete_at")
    private Long deleteAt;

    @TableField("update_at")
    private Long updateAt;

    // -------------------

    @TableField("title")
    private String title;

    @TableField("content")
    private String content;

    @TableField("cover_img")
    private String coverImg;

}

mapper

package com.example.xys1.mapper;

import org.apache.ibatis.annotations.Mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.xys1.entity.ArtiCleEntity;

@Mapper
public interface ArticleMapper extends BaseMapper<ArtiCleEntity> {
}

service

package com.example.xys1.service;

import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.xys1.mapper.ArticleMapper;
import com.example.xys1.entity.ArtiCleEntity;

@Service
public class ArticleService extends ServiceImpl<ArticleMapper, ArtiCleEntity> {
}

dto.add

package com.example.xys1.dto.article;

import lombok.Data;

@Data
public class ArticleAddDto {
    private String title;
    private String content;
    private String coverImg;
}

dto.delete

package com.example.xys1.dto.article;

import lombok.Data;

import java.util.List;

@Data
public class ArticleDeleteDto {
    private List<Long> ids;
}

dto.update

package com.example.xys1.dto.article;

import lombok.Data;

@Data
public class ArticleUpdateDto {
    private Long id;
    private String title;
    private String content;
    private String coverImg;
}

dto.list

package com.example.xys1.dto.article;

import lombok.Data;

@Data
public class ArticleListDto {
    private Long pageNum = 1L;
    private Long pageSize = 10L;
    private String title;
}

dto.info

package com.example.xys1.dto.article;

import lombok.Data;

@Data
public class ArticleInfoDto {
    private Long id;
}

vo.list

package com.example.xys1.vo.article;

import lombok.Data;

@Data
public class ArticleItemVo {
    private Long id;
    private String title;
    private String coverImg;

    private String createAtStr;
    private String updateAtStr;
}

vo.info

package com.example.xys1.vo.article;

import lombok.Data;

@Data
public class ArticleInfoVo {
    private Long id;
    private String remark;
    private Long createBy;
    private Long createAt;
    private Long deleteBy;
    private Long deleteAt;
    private Long updateBy;
    private Long updateAt;

    private String title;
    private String content;
    private String coverImg;
}

ResUtil

PageVo

添加依赖 ​

mysql连接配置 + ​

创建文件 (controller,entity,mapper,service,dto5个,vo2个) ​

添加依赖

mysql连接配置 +

创建文件 (controller,entity,mapper,service,dto5个,vo2个)