【瑞吉外卖模块-CRUD】

原创 已于 2025-11-21 18:11:34 修改 · 252 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #mybatis #后端

于 2025-11-20 23:41:21 首次发布

下面是一个完整的 Spring Boot + MyBatis Plus CRUD 示例，以用户管理为例：

1. 项目结构和依赖

pom.xml 关键依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

application.yml 配置

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true
  global-config:
    db-config:
      id-type: auto
      logic-delete-field: deleted
      logic-delete-value: 1
      logic-not-delete-value: 0

logging:
  level:
    com.example.mapper: debug

2. 实体类 (Entity)

package com.rongx.reggie.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;

@Data
@EqualsAndHashCode(callSuper = false)
@TableName("user")
public class User {
    
    @TableId(type = IdType.AUTO)
    private Long id;
    
    private String username;
    
    private String password;
    
    private String email;
    
    private String phone;
    
    private Integer status;
    
    private Integer age;
    
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
    
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
    
    @TableLogic
    private Integer deleted;
    
    // 版本号，用于乐观锁
    @Version
    private Integer version;
}

3. Mapper 接口

package com.rongx.reggie.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rongx.reggie.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
    
    // 可以在这里添加自定义的 SQL 方法
    // 例如：根据用户名查询用户
    // User selectByUsername(@Param("username") String username);
}

4. Service 接口和实现

Service 接口

package com.rongx.reggie.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.rongx.reggie.entity.User;

public interface UserService extends IService<User> {
    
    /**
     * 自定义业务方法：根据用户名查询用户
     */
    User getByUsername(String username);
    
    /**
     * 自定义业务方法：用户注册
     */
    boolean register(User user);
    
    /**
     * 自定义业务方法：更新用户状态
     */
    boolean updateStatus(Long id, Integer status);
}

Service 实现类

package com.rongx.reggie.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rongx.reggie.entity.User;
import com.rongx.reggie.mapper.UserMapper;
import com.rongx.reggie.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    @Override
    public User getByUsername(String username) {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUsername, username);
        return this.getOne(wrapper);
    }

    @Override
    public boolean register(User user) {
        // 检查用户名是否已存在
        User existingUser = this.getByUsername(user.getUsername());
        if (existingUser != null) {
            throw new RuntimeException("用户名已存在");
        }
        
        // 密码加密（简单示例）
        String encryptedPassword = DigestUtils.md5DigestAsHex(user.getPassword().getBytes());
        user.setPassword(encryptedPassword);
        
        // 设置默认状态
        user.setStatus(1);
        
        return this.save(user);
    }

    @Override
    public boolean updateStatus(Long id, Integer status) {
        User user = new User();
        user.setId(id);
        user.setStatus(status);
        return this.updateById(user);
    }
}

5. Controller 层

package com.rongx.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.rongx.reggie.common.R;
import com.rongx.reggie.entity.User;
import com.rongx.reggie.service.UserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/user")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;

    // ==================== 新增操作 ====================
    
    /**
     * 新增用户
     */
    @PostMapping
    public R<String> save(@RequestBody User user) {
        log.info("新增用户: {}", user);
        try {
            boolean success = userService.register(user);
            return success ? R.success("新增用户成功") : R.error("新增用户失败");
        } catch (Exception e) {
            log.error("新增用户异常", e);
            return R.error(e.getMessage());
        }
    }

    /**
     * 批量新增用户
     */
    @PostMapping("/batch")
    public R<String> saveBatch(@RequestBody List<User> users) {
        log.info("批量新增用户，数量: {}", users.size());
        boolean success = userService.saveBatch(users);
        return success ? R.success("批量新增成功") : R.error("批量新增失败");
    }

    // ==================== 查询操作 ====================

    /**
     * 根据ID查询用户
     */
    @GetMapping("/{id}")
    public R<User> getById(@PathVariable Long id) {
        log.info("根据ID查询用户: id={}", id);
        User user = userService.getById(id);
        return user != null ? R.success(user) : R.error("用户不存在");
    }

    /**
     * 查询所有用户
     */
    @GetMapping("/list")
    public R<List<User>> list() {
        List<User> users = userService.list();
        return R.success(users);
    }

    /**
     * 分页查询用户
     */
    @GetMapping("/page")
    public R<IPage<User>> page(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize,
            @RequestParam(required = false) String username,
            @RequestParam(required = false) String email) {
        
        log.info("分页查询用户: page={}, size={}, username={}, email={}", 
                pageNum, pageSize, username, email);
        
        // 创建分页对象
        Page<User> page = new Page<>(pageNum, pageSize);
        
        // 创建查询条件
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(username != null, User::getUsername, username)
               .like(email != null, User::getEmail, email)
               .orderByDesc(User::getCreateTime);
        
        // 执行分页查询
        IPage<User> userPage = userService.page(page, wrapper);
        
        return R.success(userPage);
    }

    /**
     * 条件查询用户列表
     */
    @GetMapping("/listByCondition")
    public R<List<User>> listByCondition(User user) {
        log.info("条件查询用户: {}", user);
        
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        
        // 动态添加查询条件
        if (user.getUsername() != null) {
            wrapper.like("username", user.getUsername());
        }
        if (user.getEmail() != null) {
            wrapper.like("email", user.getEmail());
        }
        if (user.getStatus() != null) {
            wrapper.eq("status", user.getStatus());
        }
        
        wrapper.orderByDesc("create_time");
        
        List<User> users = userService.list(wrapper);
        return R.success(users);
    }

    /**
     * 根据用户名查询用户
     */
    @GetMapping("/username/{username}")
    public R<User> getByUsername(@PathVariable String username) {
        log.info("根据用户名查询用户: username={}", username);
        User user = userService.getByUsername(username);
        return user != null ? R.success(user) : R.error("用户不存在");
    }

    // ==================== 更新操作 ====================

    /**
     * 更新用户信息
     */
    @PutMapping
    public R<String> update(@RequestBody User user) {
        log.info("更新用户: {}", user);
        boolean success = userService.updateById(user);
        return success ? R.success("更新成功") : R.error("更新失败");
    }

    /**
     * 批量更新用户
     */
    @PutMapping("/batch")
    public R<String> updateBatch(@RequestBody List<User> users) {
        log.info("批量更新用户，数量: {}", users.size());
        boolean success = userService.updateBatchById(users);
        return success ? R.success("批量更新成功") : R.error("批量更新失败");
    }

    /**
     * 更新用户状态
     */
    @PutMapping("/status/{id}")
    public R<String> updateStatus(@PathVariable Long id, @RequestParam Integer status) {
        log.info("更新用户状态: id={}, status={}", id, status);
        boolean success = userService.updateStatus(id, status);
        return success ? R.success("状态更新成功") : R.error("状态更新失败");
    }

    // ==================== 删除操作 ====================

    /**
     * 根据ID删除用户（逻辑删除）
     */
    @DeleteMapping("/{id}")
    public R<String> delete(@PathVariable Long id) {
        log.info("删除用户: id={}", id);
        boolean success = userService.removeById(id);
        return success ? R.success("删除成功") : R.error("删除失败");
    }

    /**
     * 批量删除用户
     */
    @DeleteMapping("/batch")
    public R<String> deleteBatch(@RequestBody List<Long> ids) {
        log.info("批量删除用户: ids={}", ids);
        boolean success = userService.removeByIds(ids);
        return success ? R.success("批量删除成功") : R.error("批量删除失败");
    }

    /**
     * 根据条件删除用户
     */
    @DeleteMapping("/byCondition")
    public R<String> deleteByCondition(@RequestBody User user) {
        log.info("根据条件删除用户: {}", user);
        
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        if (user.getUsername() != null) {
            wrapper.eq("username", user.getUsername());
        }
        if (user.getStatus() != null) {
            wrapper.eq("status", user.getStatus());
        }
        
        boolean success = userService.remove(wrapper);
        return success ? R.success("删除成功") : R.error("删除失败");
    }

    // ==================== 统计操作 ====================

    /**
     * 统计用户数量
     */
    @GetMapping("/count")
    public R<Long> count() {
        long count = userService.count();
        return R.success(count);
    }

    /**
     * 根据条件统计用户数量
     */
    @GetMapping("/countByCondition")
    public R<Long> countByCondition(User user) {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        if (user.getStatus() != null) {
            wrapper.eq("status", user.getStatus());
        }
        if (user.getUsername() != null) {
            wrapper.like("username", user.getUsername());
        }
        
        long count = userService.count(wrapper);
        return R.success(count);
    }
}

6. 配置类

MyBatis Plus 配置

package com.rongx.reggie.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.time.LocalDateTime;

@Slf4j
@Configuration
public class MybatisPlusConfig {

    /**
     * MyBatis Plus 插件配置
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        
        // 分页插件
        PaginationInnerInterceptor paginationInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
        paginationInterceptor.setMaxLimit(1000L); // 单页分页条数限制
        paginationInterceptor.setOverflow(true);   // 页码超出后是否处理
        
        interceptor.addInnerInterceptor(paginationInterceptor);
        
        return interceptor;
    }

    /**
     * 自动填充处理器
     */
    @Bean
    public MetaObjectHandler metaObjectHandler() {
        return new MetaObjectHandler() {
            @Override
            public void insertFill(MetaObject metaObject) {
                log.info("开始插入填充...");
                this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
                this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
            }

            @Override
            public void updateFill(MetaObject metaObject) {
                log.info("开始更新填充...");
                this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
            }
        };
    }
}

7. 统一返回结果封装

package com.rongx.reggie.common;

import lombok.Data;
import java.util.HashMap;
import java.util.Map;

@Data
public class R<T> {
    private Integer code;
    private String msg;
    private T data;
    private Map<String, Object> map = new HashMap<>();

    public static <T> R<T> success(T object) {
        R<T> r = new R<>();
        r.data = object;
        r.code = 1;
        return r;
    }

    public static <T> R<T> error(String msg) {
        R<T> r = new R<>();
        r.msg = msg;
        r.code = 0;
        return r;
    }

    public R<T> add(String key, Object value) {
        this.map.put(key, value);
        return this;
    }
}

8. 数据库表结构

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `username` varchar(50) NOT NULL COMMENT '用户名',
  `password` varchar(100) NOT NULL COMMENT '密码',
  `email` varchar(100) DEFAULT NULL COMMENT '邮箱',
  `phone` varchar(20) DEFAULT NULL COMMENT '手机号',
  `status` int(1) DEFAULT '1' COMMENT '状态 0:禁用 1:正常',
  `age` int(3) DEFAULT NULL COMMENT '年龄',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `deleted` int(1) DEFAULT '0' COMMENT '逻辑删除 0:未删除 1:已删除',
  `version` int(11) DEFAULT '0' COMMENT '版本号',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_username` (`username`),
  KEY `idx_status` (`status`),
  KEY `idx_create_time` (`create_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

9. 测试用例

package com.rongx.reggie;

import com.rongx.reggie.entity.User;
import com.rongx.reggie.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;

@Slf4j
@SpringBootTest
class UserCRUDTests {

    @Autowired
    private UserService userService;

    @Test
    void testCRUD() {
        // 1. 新增
        User user = new User();
        user.setUsername("testuser");
        user.setPassword("123456");
        user.setEmail("test@example.com");
        user.setPhone("13800138000");
        userService.save(user);
        log.info("新增用户: {}", user);

        // 2. 查询
        User foundUser = userService.getById(user.getId());
        log.info("查询用户: {}", foundUser);

        // 3. 更新
        foundUser.setEmail("updated@example.com");
        userService.updateById(foundUser);
        log.info("更新用户: {}", foundUser);

        // 4. 删除（逻辑删除）
        userService.removeById(user.getId());
        log.info("删除用户完成");

        // 5. 批量操作
        List<User> users = Arrays.asList(
            createUser("user1", "user1@example.com"),
            createUser("user2", "user2@example.com"),
            createUser("user3", "user3@example.com")
        );
        userService.saveBatch(users);
        log.info("批量新增完成");
    }

    private User createUser(String username, String email) {
        User user = new User();
        user.setUsername(username);
        user.setPassword("123456");
        user.setEmail(email);
        return user;
    }
}

10. API 使用示例

10.1 新增用户

POST /user
Content-Type: application/json

{
  "username": "zhangsan",
  "password": "123456",
  "email": "zhangsan@example.com",
  "phone": "13800138000",
  "age": 25
}

10.2 分页查询

GET /user/page?pageNum=1&pageSize=10&username=zhang

10.3 条件查询

GET /user/listByCondition?username=zhang&status=1

10.4 更新用户

PUT /user
Content-Type: application/json

{
  "id": 1,
  "username": "zhangsan",
  "email": "newemail@example.com",
  "age": 26
}

10.5 删除用户

DELETE /user/1

11. 高级查询示例

复杂条件查询

// 在 Service 中实现复杂查询
public List<User> complexQuery(String keyword, Integer minAge, Integer maxAge, Integer status) {
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    
    // 多个条件组合
    wrapper.and(qw -> qw
            .like(User::getUsername, keyword)
            .or()
            .like(User::getEmail, keyword)
            .or()
            .like(User::getPhone, keyword)
        )
        .ge(minAge != null, User::getAge, minAge)
        .le(maxAge != null, User::getAge, maxAge)
        .eq(status != null, User::getStatus, status)
        .orderByDesc(User::getCreateTime);
    
    return this.list(wrapper);
}

这个完整的 CRUD 示例涵盖了 Spring Boot + MyBatis Plus 的常见操作，包括：

  • ✅ 基础 CRUD 操作
  • ✅ 分页查询
  • ✅ 条件查询
  • ✅ 批量操作
  • ✅ 逻辑删除
  • ✅ 自动填充
  • ✅ 统一返回格式
  • ✅ 异常处理

您可以根据实际业务需求进行调整和扩展。

瑞吉外卖09-菜品模块的CRUD与启售、停售
金鳞踏雨
11-11 1398
我们先看看这个页面，剥离出本质其实就是！这里面还有一个，在黑马视频中是没有的，我们这里也将其一起来实现一下！这里我们基本上在前面都有讲过一些，所以这里就不做过多的分析了！
黑马程序员——瑞吉外卖项目解析（2）
wn030416的博客
01-29 524
只有登录才能访问首页，使用过滤器或者拦截器实现这里使用过滤器实现。
瑞吉外卖项目
鱼仔的博客
08-08 1470
标准的SpringBoot单体项目。
瑞吉外卖项目详细分析笔记及所有功能补充代码
热门推荐
SeeYouAgain的博客
01-16 3万+
瑞吉外卖项目的详细笔记及部分功能的补充实现，实现了视频剩余没有定义的功能，例如管理端的订单明细，起售停售；移动端的订单查看及再来一单等，也是对整个项目整体步骤流程的经验总结。
黑马实战项目瑞吉外卖的总结
ai15013602354的博客
09-13 2万+
黑马瑞吉外卖项目的总结，b站视频链接:https://www.bilibili.com/video/BV13a411q753?p=173
瑞吉外卖-Day01
m0_59281987的博客
07-04 2537
作为一名软件开发工程师,我们需要了解在软件开发过程中的开发流程， 以及软件开发过程中涉及到的岗位角色，角色的分工、职责， 并了解软件开发中涉及到的三种软件环境。那么这一小节，我们将从 软件开发流程、角色分工、软件环境 三个方面，来整体上介绍一下软件开发。在开发瑞吉外卖这个项目之前，我们需要全方位的来介绍一下当前我们学习的这个项目。接下来，我们将从以下的五个方面， 来介绍瑞吉外卖这个项目。本项目（瑞吉外卖）是专门为餐饮企业（餐厅、饭店）定制的一款软件产品，包括 系统管理后台 和 移动端应用 两部分。
瑞吉外卖开发梳理及重点知识讲解
m0_53951384的博客
08-18 5378
瑞吉外卖是一个单体架构，整体的业务逻辑也较为简单。如果刚学SpringBoot技术，想要通过项目练手，那这是一个很好的选择，不仅可以练习SpringBoot技术，还可以学习Mybatis-Plus、Redis、项目部署，服务器等相关知识，建议新手跟着教程结合笔记学习，掌握开发流程的梳理，项目中的很多逻辑上的处理还是比较通用的，下次遇到同样的需求也更容易实现出来，作为新手来说，自己探索虽然也是一个锻炼的过程，但由于掌握的技术比较少，所以很多功能的实现只能基于自己掌握的技术，耗费的时间往往很多效果其实也一般
瑞吉外卖项目，后端源码解析
奔跑吧，兄弟
12-09 1126
本文从三层架构设计切入瑞吉外卖，剖析统一响应封装、MyBatis-Plus 应用、事务管理、DTO 模式等核心技术点，详解菜品管理、套餐管理、购物车与订单等核心业务实现逻辑，还给出缓存、异步处理等生产环境优化建议，助力初学者掌握企业级 Java 开发核心技能与设计思想。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1477
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
精选资源
黑马瑞吉外卖源码及工程项目全套
07-17
在瑞吉外卖项目中，MyBatis用于处理数据库的CRUD操作，如订单创建、更新、查询和删除等。 4. **订单系统**：外卖平台的核心功能之一，订单系统负责处理用户下单、支付、商家接单、配送等流程。修复的bug可能涉及...
精选资源
Springboot +Vue 瑞吉外卖项目实例总结
09-24
本文将以“瑞吉外卖项目”为例，深入探讨这一技术组合的实践应用，为同类项目的开发提供参考与借鉴。 首先，让我们对SpringBoot进行简单回顾。SpringBoot是由Pivotal团队提供的全新框架，其设计目的之一是为了简化...
精选资源
基于java的瑞吉外卖项目源码.zip
11-02
《基于Java的瑞吉外卖项目源码解析》 在当今的互联网时代，外卖订餐系统已经成为日常生活的一部分。本文将深入探讨一个基于Java开发的瑞吉外卖项目，通过源码分析，帮助开发者理解其架构设计、功能实现以及技术选型...
黑马程序员瑞吉外卖基本功能完整版
03-01
在瑞吉外卖系统中，这些功能可能涉及到用户管理、菜品管理、订单处理等多个模块。例如： 1. **用户管理**：创建新用户、查询用户信息、修改用户资料和删除用户账号。这通常涉及到用户注册、登录、个人信息维护等...
MyBatis-Plus 全面介绍 & Spring Boot 集成实战
技术分析
12-16 621
本文全面介绍了MyBatis-Plus(MP)框架的核心功能与应用实践。MP作为MyBatis的增强工具，提供了通用CRUD、条件构造器、自动分页等开箱即用功能，可大幅减少重复SQL编写。文章详细讲解了MP的核心组件(如BaseMapper、IService)、SpringBoot集成步骤(包括实体类设计、自动填充处理等)，并演示了条件查询、分页等核心功能的使用方法。此外，还介绍了乐观锁、代码生成器、多数据源等高级功能，对比了MP与原生MyBatis的差异，最后给出了最佳实践建议。
Spring Boot 中 @Async 与 @Transactional 结合使用全解析：避坑指南
席木木的博客
12-19 568
摘要：SpringBoot开发中，@Async和@Transactional注解结合使用时易出现事务失效等问题。本文解析了二者冲突的核心原因：@Async触发线程切换导致事务上下文丢失，并列举了3类典型问题现象。针对不同业务场景，给出了正确实现方案：独立事务场景、事务提交后回调场景等，强调避免内部调用和跨线程共享事务。最后提供了4个关键避坑指南，包括注解生效条件、事务失效场景解决方案及性能优化建议。通过理清线程上下文与事务归属关系，可安全实现异步与事务的协同工作。
Spring Boot 使用FastExcel实现多级表头动态数据填充导出
最新发布
shitou的博客
12-19 181
本文介绍了使用FastExcel库实现动态表头Excel导出的方法。主要包括：1）通过Maven引入FastExcel依赖；2）定义动态表头实体类，使用注解配置表头样式、列宽等属性；3）实现自定义表头处理器(CellWriteHandler)，动态替换表头中的占位符变量；4）提供导出工具类，支持按指标类型生成包含年度和月度数据的多Sheet Excel文件。该方法通过注解和处理器机制，实现了灵活的表头定制和动态数据填充功能。
Spring Boot WebFlux 实现流式数据传输与断点续传
liuhm的博客
12-19 963
本文介绍了基于Spring Boot WebFlux的流式数据传输方案，支持断点续传功能。通过Redis存储会话状态和数据片段，结合Reactor的Flux异步处理，实现了AI对话助手在页面刷新后仍能继续输出的效果。核心设计包括：1) Redis存储已生成数据片段和接收进度；2) 异步数据生成避免阻塞；3) 合并历史数据和新数据的响应式流；4) 使用AtomicInteger确保线程安全。该方案有效解决了传统方案中上下文丢失、资源浪费等问题，提升了用户体验。
深入Spring Boot源码（五）：外部化配置与Profile机制深度解析
qq_45110186的博客
12-17 761
本文深入解析了SpringBoot强大的外部化配置机制，详细介绍了其17种配置源加载优先级、类型安全的属性绑定原理、Profile环境隔离机制和YAML结构化配置支持。文章剖析了配置动态更新的@RefreshScope实现原理，并分享了自定义配置扩展、配置加密等高级技巧。通过源码分析展示了SpringBoot如何实现配置加载、属性绑定和环境感知等核心功能，同时提供了生产环境配置建议和调试技巧。这套统一的配置管理方案有效解决了传统Java应用配置分散、环境差异等痛点，在灵活性和简便性之间取得了完美平衡。
深入Spring Boot源码（六）：Actuator端点与监控机制深度解析
qq_45110186的博客
12-17 804
本文深入解析了SpringBoot Actuator模块的内部机制，重点介绍了其核心功能实现原理。内容涵盖：1）Actuator架构设计理念与模块组成；2）端点抽象体系及自动配置机制；3）健康检查的分层设计与内置指示器实现；4）指标收集与Micrometer集成；5）信息端点实现与构建信息暴露；6）端点安全控制策略；7）自定义端点开发全流程。文章还提供了生产环境配置建议和测试策略，帮助开发者全面掌握Actuator的监控能力，为应用运维提供有力支持。
瑞吉外卖java代码
12-09
<think>根据用户引用和查询，用户想要获取瑞吉外卖项目的Java代码。从引用[2]中可以看到，该项目是黑马程序员的实战项目，视频教程在B站上有。引用[3]和[4]展示了一个通用返回结果类R的代码片段。但用户希望获取整个项目的代码。 需要注意的是，通常一个完整的项目代码不会直接在回答中提供，因为： 1. 项目代码量庞大，不适合在对话中展示 2. 涉及版权问题，该项目属于黑马程序员的教程内容 建议用户通过以下途径获取代码： 1. 官方教程配套资源（如黑马程序员官网或B站视频简介中的代码仓库链接） 2. GitHub等开源平台搜索（但需注意版权） 不过，我可以根据引用[3]和[4]提供通用返回类R的完整代码，并解释其作用。此外，还可以提供一个简单的示例（如控制器中使用R类的代码片段）。 下面先展示R类的代码（与引用[3][4]一致）： ```java package com.itheima.reggie.common; import lombok.Data; import java.util.HashMap; import java.util.Map; @Data public class R<T> { private Integer code; //编码：1成功，0和其它数字为失败 private String msg; //错误信息 private T data; //数据 private Map<String, Object> map = new HashMap<>(); //动态数据 public static <T> R<T> success(T object) { R<T> r = new R<>(); r.data = object; r.code = 1; return r; } public static <T> R<T> error(String msg) { R<T> r = new R<>(); r.msg = msg; r.code = 0; return r; } public R<T> add(String key, Object value) { this.map.put(key, value); return this; } } ``` 然后展示一个使用R类的控制器示例： ```java @RestController @RequestMapping("/dish") public class DishController { @Autowired private DishService dishService; @GetMapping("/{id}") public R<Dish> getById(@PathVariable Long id) { Dish dish = dishService.getById(id); if (dish != null) { return R.success(dish); } return R.error("菜品不存在"); } } ``` 最后，建议用户通过正规渠道获取完整项目代码，并说明原因。 相关问题部分，根据项目学习可能产生的疑问生成。 </think> 根据您的需求，瑞吉外卖项目的完整Java代码可通过以下正规渠道获取： ### 1. 官方教程资源（推荐） 项目完整代码可在黑马程序员官方提供的B站教程配套资源中获取： - 📺 [B站视频教程](https://www.bilibili.com/video/BV13a411q753) - 💻 代码获取方式： ```markdown 1. 视频简介区查看GitHub仓库链接 2. 或访问黑马程序员官网获取课程配套资料 ``` 此教程包含完整的项目分层代码：Controller、Service、DAO、实体类等[^2]。 ### 2. 核心代码示例 以下为项目中的**通用返回结果封装类**（关键组件）： ```java package com.itheima.reggie.common; import lombok.Data; import java.util.HashMap; import java.util.Map; @Data public class R<T> { private Integer code; // 1=成功, 0=失败 private String msg; // 错误信息 private T data; // 响应数据 private Map<String, Object> map = new HashMap<>(); // 动态数据 public static <T> R<T> success(T object) { R<T> r = new R<>(); r.data = object; r.code = 1; return r; } public static <T> R<T> error(String msg) { R<T> r = new R<>(); r.msg = msg; r.code = 0; return r; } public R<T> add(String key, Object value) { this.map.put(key, value); return this; } } ``` ▲ 此类用于标准化API响应格式（如`{code:1, data:{...}}`）[^3][^4] ### 3. 技术栈组成 | 层级 | 技术组件 | |-------------|--------------------------| | 前端 | HTML/CSS/JS, Vue.js | | 后端框架 | Spring Boot 2.x | | ORM | MyBatis-Plus | | 数据库 | MySQL | | 工具 | Lombok, Swagger API文档 | ### 4. 注意事项 - 🔒 完整代码涉及版权问题，需通过正规课程获取 - 核心业务模块包括： - 菜品管理模块（CRUD操作） - 购物车与订单系统（Redis缓存） - JWT用户认证 - 数据统计报表
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值