Merge pull request '合并' (#5) from develop into main

LiiuZeYu_branch

@@ -0,0 +1 @@
+undefined

develop

@@ -0,0 +1 @@
+undefined

tangchuanxing_branch

@@ -0,0 +1 @@
+undefined

wangjinhao_branch

@@ -0,0 +1 @@
+undefined

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/AdminLoginController.java

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import cn.hutool.core.util.StrUtil; // 引入Hutool工具类库中的StrUtil工具类，用于字符串操作
+import com.anji.captcha.model.common.ResponseModel; // 引入验证码响应模型
+import com.anji.captcha.model.vo.CaptchaVO; // 引入验证码模型
+import com.anji.captcha.service.CaptchaService; // 引入验证码服务
+import com.baomidou.mybatisplus.core.toolkit.Wrappers; // 引入MyBatis-Plus工具类Wrappers
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import com.yami.shop.security.admin.dto.CaptchaAuthenticationDTO; // 引入验证码认证DTO
+import com.yami.shop.security.common.bo.UserInfoInTokenBO; // 引入用户信息类
+import com.yami.shop.security.common.enums.SysTypeEnum; // 引入系统类型枚举
+import com.yami.shop.security.common.manager.PasswordCheckManager; // 引入密码校验管理类
+import com.yami.shop.security.common.manager.PasswordManager; // 引入密码管理类
+import com.yami.shop.security.common.manager.TokenStore; // 引入Token存储管理类
+import com.yami.shop.security.common.vo.TokenInfoVO; // 引入Token信息VO
+import com.yami.shop.sys.constant.Constant; // 引入系统常量
+import com.yami.shop.sys.model.SysMenu; // 引入系统菜单模型
+import com.yami.shop.sys.model.SysUser; // 引入系统用户模型
+import com.yami.shop.sys.service.SysMenuService; // 引入系统菜单服务
+import com.yami.shop.sys.service.SysUserService; // 引入系统用户服务
+import io.swagger.v3.oas.annotations.Operation; // 引入Swagger的Operation注解
+import io.swagger.v3.oas.annotations.tags.Tag; // 引入Swagger的Tag注解
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import org.springframework.web.bind.annotation.PostMapping; // 引入Spring的@PostMapping注解
+import org.springframework.web.bind.annotation.RequestBody; // 引入Spring的@RequestBody注解
+import org.springframework.web.bind.annotation.RestController; // 引入Spring的@RestController注解
+
+import jakarta.validation.Valid; // 引入Jakarta Validation的Valid注解
+import java.util.Arrays; // 引入Java的Arrays工具类
+import java.util.List; // 引入Java的List接口
+import java.util.Objects; // 引入Java的Objects工具类
+import java.util.Set; // 引入Java的Set接口
+import java.util.stream.Collectors; // 引入Java的Collectors工具类
+
+/**
+ * AdminLoginController类，用于处理管理员登录逻辑。
+ * 该类包含一个登录方法和一个获取用户权限的方法。
+ * 通过账号/手机号/用户名密码登录，进行验证码校验和密码校验，生成Token。
+ * @作者 FrozenWatermelon
+ * @日期 2020/6/30
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@Tag(name = "登录") // 给API文档添加标签，描述这个控制器的功能
+public class AdminLoginController {
+
+    @Autowired
+    private TokenStore tokenStore; // 自动注入Token存储管理类
+
+    @Autowired
+    private SysUserService sysUserService; // 自动注入系统用户服务
+
+    @Autowired
+    private SysMenuService sysMenuService; // 自动注入系统菜单服务
+
+    @Autowired
+    private PasswordCheckManager passwordCheckManager; // 自动注入密码校验管理类
+
+    @Autowired
+    private CaptchaService captchaService; // 自动注入验证码服务
+
+    @Autowired
+    private PasswordManager passwordManager; // 自动注入密码管理类
+
+    /**
+     * 账号密码 + 验证码登录(用于后台登录)
+     * 通过账号/手机号/用户名密码登录，并进行验证码校验和密码校验。
+     * @param captchaAuthenticationDTO 包含账号、密码和验证码的DTO对象
+     * @return 服务器响应实体，包含登录成功后的Token信息
+     */
+    @PostMapping("/adminLogin")
+    @Operation(summary = "账号密码 + 验证码登录(用于后台登录)" , description = "通过账号/手机号/用户名密码登录")
+    public ServerResponseEntity<?> login(
+            @Valid @RequestBody CaptchaAuthenticationDTO captchaAuthenticationDTO) {
+        // 登陆后台登录需要再校验一遍验证码
+        CaptchaVO captchaVO = new CaptchaVO();
+        captchaVO.setCaptchaVerification(captchaAuthenticationDTO.getCaptchaVerification());
+        ResponseModel response = captchaService.verification(captchaVO);
+        if (!response.isSuccess()) {
+            return ServerResponseEntity.showFailMsg("验证码有误或已过期");
+        }
+
+        SysUser sysUser = sysUserService.getByUserName(captchaAuthenticationDTO.getUserName());
+        if (sysUser == null) {
+            throw new YamiShopBindException("账号或密码不正确");
+        }
+
+        // 半小时内密码输入错误十次，已限制登录30分钟
+        String decryptPassword = passwordManager.decryptPassword(captchaAuthenticationDTO.getPassWord());
+        passwordCheckManager.checkPassword(SysTypeEnum.ADMIN, captchaAuthenticationDTO.getUserName(), decryptPassword, sysUser.getPassword());
+
+        // 不是店铺超级管理员，并且是禁用状态，无法登录
+        if (Objects.equals(sysUser.getStatus(), 0)) {
+            // 未找到此用户信息
+            throw new YamiShopBindException("未找到此用户信息");
+        }
+
+        UserInfoInTokenBO userInfoInToken = new UserInfoInTokenBO();
+        userInfoInToken.setUserId(String.valueOf(sysUser.getUserId()));
+        userInfoInToken.setSysType(SysTypeEnum.ADMIN.value());
+        userInfoInToken.setEnabled(sysUser.getStatus() == 1);
+        userInfoInToken.setPerms(getUserPermissions(sysUser.getUserId()));
+        userInfoInToken.setNickName(sysUser.getUsername());
+        userInfoInToken.setShopId(sysUser.getShopId());
+        // 存储token返回vo
+        TokenInfoVO tokenInfoVO = tokenStore.storeAndGetVo(userInfoInToken);
+        return ServerResponseEntity.success(tokenInfoVO);
+    }
+
+    /**
+     * 获取用户权限
+     * 根据用户ID获取用户的所有权限，如果是超级管理员，拥有最高权限。
+     * @param userId 用户ID
+     * @return 用户权限的Set集合
+     */
+    private Set<String> getUserPermissions(Long userId) {
+        List<String> permsList;
+
+        //系统管理员，拥有最高权限
+        if(userId == Constant.SUPER_ADMIN_ID){
+            List<SysMenu> menuList = sysMenuService.list(Wrappers.emptyWrapper());
+            permsList = menuList.stream().map(SysMenu::getPerms).collect(Collectors.toList());
+        }else{
+            permsList = sysUserService.queryAllPerms(userId);
+        }
+        return permsList.stream().flatMap((perms) -> {
+                    if (StrUtil.isBlank(perms)) {
+                        return null;
+                    }
+                    return Arrays.stream(perms.trim().split(StrUtil.COMMA));
+                }
+        ).collect(Collectors.toSet());
+    }
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/AreaController.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; // 引入MyBatis-Plus的条件查询包装器
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入MyBatis-Plus的分页接口
+import com.yami.shop.bean.enums.AreaLevelEnum; // 引入区域级别枚举
+import com.yami.shop.bean.model.Area; // 引入区域模型
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.util.PageParam; // 引入分页参数工具类
+import com.yami.shop.service.AreaService; // 引入区域服务类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.security.access.prepost.PreAuthorize; // 引入Spring Security的PreAuthorize注解
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid; // 引入Jakarta Validation的Valid注解
+import java.util.List; // 引入Java的List接口
+import java.util.Objects; // 引入Java的Objects工具类
+
+/**
+ * AreaController类，用于管理区域信息。
+ * 该类包含了分页获取区域、获取省市、通过父级ID获取区域列表、获取区域信息、保存区域、修改区域和删除区域的方法。
+ * @作者 lgh on 2018/10/26.
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/admin/area") // 定义请求路径的根地址为/admin/area
+public class AreaController {
+
+    @Autowired
+    private AreaService areaService; // 自动注入区域服务类
+
+    /**
+     * 分页获取区域信息
+     * @param area 查询条件
+     * @param page 分页参数
+     * @return 服务器响应实体，包含分页后的区域信息
+     */
+    @GetMapping("/page")
+    @PreAuthorize("@pms.hasPermission('admin:area:page')") // 权限检查
+    public ServerResponseEntity<IPage<Area>> page(Area area, PageParam<Area> page) {
+        IPage<Area> areaPage = areaService.page(page, new LambdaQueryWrapper<Area>());
+        return ServerResponseEntity.success(areaPage);
+    }
+
+    /**
+     * 获取省市信息
+     * @param area 查询条件
+     * @return 服务器响应实体，包含查询到的省市信息
+     */
+    @GetMapping("/list")
+    @PreAuthorize("@pms.hasPermission('admin:area:list')") // 权限检查
+    public ServerResponseEntity<List<Area>> list(Area area) {
+        List<Area> areas = areaService.list(new LambdaQueryWrapper<Area>()
+                .like(area.getAreaName() != null, Area::getAreaName, area.getAreaName()));
+        return ServerResponseEntity.success(areas);
+    }
+
+    /**
+     * 通过父级ID获取区域列表
+     * @param pid 父级ID
+     * @return 服务器响应实体，包含查询到的区域列表
+     */
+    @GetMapping("/listByPid")
+    public ServerResponseEntity<List<Area>> listByPid(Long pid) {
+        List<Area> list = areaService.listByPid(pid);
+        return ServerResponseEntity.success(list);
+    }
+
+    /**
+     * 获取区域信息
+     * @param id 区域ID
+     * @return 服务器响应实体，包含查询到的区域信息
+     */
+    @GetMapping("/info/{id}")
+    @PreAuthorize("@pms.hasPermission('admin:area:info')") // 权限检查
+    public ServerResponseEntity<Area> info(@PathVariable("id") Long id) {
+        Area area = areaService.getById(id);
+        return ServerResponseEntity.success(area);
+    }
+
+    /**
+     * 保存区域信息
+     * @param area 区域信息
+     * @return 服务器响应实体
+     */
+    @PostMapping
+    @PreAuthorize("@pms.hasPermission('admin:area:save')") // 权限检查
+    public ServerResponseEntity<Void> save(@Valid @RequestBody Area area) {
+        if (area.getParentId() != null) {
+            Area parentArea = areaService.getById(area.getParentId());
+            area.setLevel(parentArea.getLevel() + 1);
+            areaService.removeAreaCacheByParentId(area.getParentId());
+        }
+        areaService.save(area);
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 修改区域信息
+     * @param area 区域信息
+     * @return 服务器响应实体
+     */
+    @PutMapping
+    @PreAuthorize("@pms.hasPermission('admin:area:update')") // 权限检查
+    public ServerResponseEntity<Void> update(@Valid @RequestBody Area area) {
+        Area areaDb = areaService.getById(area.getAreaId());
+        // 判断当前省市区级别，如果是1级、2级则不能修改级别，不能修改成别人的下级
+        if(Objects.equals(areaDb.getLevel(), AreaLevelEnum.FIRST_LEVEL.value()) && !Objects.equals(area.getLevel(), AreaLevelEnum.FIRST_LEVEL.value())){
+            throw new YamiShopBindException("不能改变一级行政地区的级别");
+        }
+        if(Objects.equals(areaDb.getLevel(), AreaLevelEnum.SECOND_LEVEL.value()) && !Objects.equals(area.getLevel(), AreaLevelEnum.SECOND_LEVEL.value())){
+            throw new YamiShopBindException("不能改变二级行政地区的级别");
+        }
+        hasSameName(area);
+        areaService.updateById(area);
+        areaService.removeAreaCacheByParentId(area.getParentId());
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 删除区域信息
+     * @param id 区域ID
+     * @return 服务器响应实体
+     */
+    @DeleteMapping("/{id}")
+    @PreAuthorize("@pms.hasPermission('admin:area:delete')") // 权限检查
+    public ServerResponseEntity<Void> delete(@PathVariable Long id) {
+        Area area = areaService.getById(id);
+        areaService.removeById(id);
+        areaService.removeAreaCacheByParentId(area.getParentId());
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 判断是否有相同名称的区域
+     * @param area 区域信息
+     */
+    private void hasSameName(Area area) {
+        long count = areaService.count(new LambdaQueryWrapper<Area>()
+                .eq(Area::getParentId, area.getParentId())
+                .eq(Area::getAreaName, area.getAreaName())
+                .ne(Objects.nonNull(area.getAreaId()) && !Objects.equals(area.getAreaId(), 0L), Area::getAreaId, area.getAreaId())
+        );
+        if (count > 0) {
+            throw new YamiShopBindException("该地区已存在");
+        }
+    }
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/CategoryController.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; // 引入MyBatis-Plus的条件查询包装器
+import com.yami.shop.bean.model.Category; // 引入商品分类模型类
+import com.yami.shop.common.annotation.SysLog; // 引入自定义日志注解
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.security.admin.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.CategoryService; // 引入商品分类服务类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.security.access.prepost.PreAuthorize; // 引入Spring Security的PreAuthorize注解
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Date; // 引入Java的Date类
+import java.util.List; // 引入Java的List接口
+import java.util.Objects; // 引入Java的Objects工具类
+
+/**
+ * 商品分类管理控制器
+ * 该类包含分页获取、获取详细信息、保存、修改和删除商品分类的方法。
+ * @作者 lgh
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/prod/category") // 定义请求路径的根地址为/prod/category
+public class CategoryController {
+
+	@Autowired
+	private CategoryService categoryService; // 自动注入商品分类服务类
+
+	/**
+	 * 获取菜单页面的表
+	 * @return 服务器响应实体，包含商品分类列表
+	 */
+	@GetMapping("/table")
+	@PreAuthorize("@pms.hasPermission('prod:category:page')") // 权限检查
+	public ServerResponseEntity<List<Category>> table() {
+		List<Category> categoryMenuList = categoryService.tableCategory(SecurityUtils.getSysUser().getShopId());
+		return ServerResponseEntity.success(categoryMenuList);
+	}
+
+	/**
+	 * 获取分类信息
+	 * @param categoryId 商品分类ID
+	 * @return 服务器响应实体，包含商品分类的详细信息
+	 */
+	@GetMapping("/info/{categoryId}")
+	public ServerResponseEntity<Category> info(@PathVariable("categoryId") Long categoryId) {
+		Category category = categoryService.getById(categoryId);
+		return ServerResponseEntity.success(category);
+	}
+
+	/**
+	 * 保存分类
+	 * @param category 商品分类信息
+	 * @return 服务器响应实体
+	 */
+	@SysLog("保存分类") // 自定义日志注解
+	@PostMapping
+	@PreAuthorize("@pms.hasPermission('prod:category:save')") // 权限检查
+	public ServerResponseEntity<Void> save(@RequestBody Category category) {
+		category.setShopId(SecurityUtils.getSysUser().getShopId());
+		category.setRecTime(new Date());
+		Category categoryName = categoryService.getOne(new LambdaQueryWrapper<Category>().eq(Category::getCategoryName, category.getCategoryName())
+				.eq(Category::getShopId, category.getShopId()));
+		if (Objects.nonNull(categoryName)) {
+			throw new YamiShopBindException("类目名称已存在！");
+		}
+		categoryService.saveCategory(category);
+		return ServerResponseEntity.success();
+	}
+
+	/**
+	 * 更新分类
+	 * @param category 商品分类信息
+	 * @return 服务器响应实体
+	 */
+	@SysLog("更新分类") // 自定义日志注解
+	@PutMapping
+	@PreAuthorize("@pms.hasPermission('prod:category:update')") // 权限检查
+	public ServerResponseEntity<String> update(@RequestBody Category category) {
+		category.setShopId(SecurityUtils.getSysUser().getShopId());
+		if (Objects.equals(category.getParentId(), category.getCategoryId())) {
+			return ServerResponseEntity.showFailMsg("分类的上级不能是自己本身");
+		}
+		Category categoryName = categoryService.getOne(new LambdaQueryWrapper<Category>().eq(Category::getCategoryName, category.getCategoryName())
+				.eq(Category::getShopId, category.getShopId()).ne(Category::getCategoryId, category.getCategoryId()));
+		if (categoryName != null) {
+			throw new YamiShopBindException("类目名称已存在！");
+		}
+		Category categoryDb = categoryService.getById(category.getCategoryId());
+		// 如果从下线改成正常，则需要判断上级的状态
+		if (Objects.equals(categoryDb.getStatus(), 0) && Objects.equals(category.getStatus(), 1) && !Objects.equals(category.getParentId(), 0L)) {
+			Category parentCategory = categoryService.getOne(new LambdaQueryWrapper<Category>().eq(Category::getCategoryId, category.getParentId()));
+			if (Objects.isNull(parentCategory) || Objects.equals(parentCategory.getStatus(), 0)) {
+				// 修改失败，上级分类不存在或者不为正常状态
+				throw new YamiShopBindException("修改失败，上级分类不存在或者不为正常状态");
+			}
+		}
+		categoryService.updateCategory(category);
+		return ServerResponseEntity.success();
+	}
+
+	/**
+	 * 删除分类
+	 * @param categoryId 商品分类ID
+	 * @return 服务器响应实体
+	 */
+	@SysLog("删除分类") // 自定义日志注解
+	@DeleteMapping("/{categoryId}")
+	@PreAuthorize("@pms.hasPermission('prod:category:delete')") // 权限检查
+	public ServerResponseEntity<String> delete(@PathVariable("categoryId") Long categoryId) {
+		if (categoryService.count(new LambdaQueryWrapper<Category>().eq(Category::getParentId, categoryId)) > 0) {
+			return ServerResponseEntity.showFailMsg("请删除子分类，再删除该分类");
+		}
+		categoryService.deleteCategory(categoryId);
+		return ServerResponseEntity.success();
+	}
+
+	/**
+	 * 获取所有的分类
+	 * @return 服务器响应实体，包含商品分类列表
+	 */
+	@GetMapping("/listCategory")
+	public ServerResponseEntity<List<Category>> listCategory() {
+		return ServerResponseEntity.success(categoryService.list(new LambdaQueryWrapper<Category>()
+				.le(Category::getGrade, 2)
+				.eq(Category::getShopId, SecurityUtils.getSysUser().getShopId())
+				.orderByAsc(Category::getSeq)));
+	}
+
+	/**
+	 * 获取所有的产品分类
+	 * @return 服务器响应实体，包含产品分类列表
+	 */
+	@GetMapping("/listProdCategory")
+	public ServerResponseEntity<List<Category>> listProdCategory() {
+		List<Category> categories = categoryService.treeSelect(SecurityUtils.getSysUser().getShopId(), 2);
+		return ServerResponseEntity.success(categories);
+	}
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/DeliveryController.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import java.util.List; // 引入Java的List接口
+
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.web.bind.annotation.GetMapping; // 引入Spring的@GetMapping注解
+import org.springframework.web.bind.annotation.RequestMapping; // 引入Spring的@RequestMapping注解
+import org.springframework.web.bind.annotation.RestController; // 引入Spring的@RestController注解
+
+import com.yami.shop.bean.model.Delivery; // 引入配送模型
+import com.yami.shop.service.DeliveryService; // 引入配送服务类
+
+/**
+ * DeliveryController类，用于管理配送信息。
+ * 该类包含一个分页获取配送信息的方法。
+ * @作者 lgh on 2018/11/26.
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/admin/delivery") // 定义请求路径的根地址为/admin/delivery
+public class DeliveryController {
+
+	@Autowired
+	private DeliveryService deliveryService; // 自动注入配送服务类
+
+	/**
+	 * 分页获取配送信息
+	 * @return 服务器响应实体，包含配送信息列表
+	 */
+	@GetMapping("/list")
+	public ServerResponseEntity<List<Delivery>> page() {
+		List<Delivery> list = deliveryService.list(); // 获取所有配送信息
+		return ServerResponseEntity.success(list); // 返回配送信息列表
+	}
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/OrderController.java

@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import cn.hutool.core.date.DatePattern; // 引入Hutool工具类库中的日期格式化工具类
+import cn.hutool.core.date.DateUtil; // 引入Hutool工具类库中的日期工具类
+import cn.hutool.core.io.IORuntimeException; // 引入Hutool工具类库中的IO运行时异常类
+import cn.hutool.core.io.IoUtil; // 引入Hutool工具类库中的IO工具类
+import cn.hutool.poi.excel.ExcelUtil; // 引入Hutool工具类库中的Excel工具类
+import cn.hutool.poi.excel.ExcelWriter; // 引入Hutool工具类库中的Excel写入工具类
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入MyBatis-Plus的分页接口
+import com.google.common.base.Objects; // 引入Google Guava库中的Objects工具类
+import com.yami.shop.bean.enums.OrderStatus; // 引入订单状态枚举类
+import com.yami.shop.bean.model.Order; // 引入订单模型类
+import com.yami.shop.bean.model.OrderItem; // 引入订单项模型类
+import com.yami.shop.bean.model.UserAddrOrder; // 引入用户地址订单模型类
+import com.yami.shop.bean.param.DeliveryOrderParam; // 引入发货订单参数类
+import com.yami.shop.bean.param.OrderParam; // 引入订单参数类
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import com.yami.shop.common.util.PageParam; // 引入分页参数工具类
+import com.yami.shop.security.admin.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.*; // 引入各种服务类
+import jakarta.servlet.ServletOutputStream; // 引入Servlet输出流类
+import jakarta.servlet.http.HttpServletResponse; // 引入HTTP响应类
+import lombok.extern.slf4j.Slf4j; // 引入Lombok的日志记录注解
+import org.apache.poi.ss.usermodel.Sheet; // 引入Apache POI的Sheet类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import org.springframework.format.annotation.DateTimeFormat; // 引入Spring的日期时间格式化注解
+import org.springframework.security.access.prepost.PreAuthorize; // 引入Spring Security的PreAuthorize注解
+import org.springframework.web.bind.annotation.*; // 引入Spring Web的注解
+
+import java.io.IOException; // 引入Java的IO异常类
+import java.util.Arrays; // 引入Java的Arrays工具类
+import java.util.Date; // 引入Java的Date类
+import java.util.List; // 引入Java的List接口
+
+/**
+ * OrderController类，用于管理订单操作，包括分页获取、查看详情、发货、导出订单信息等功能。
+ * @作者 lgh on 2018/09/15.
+ */
+@Slf4j // 标注这是一个需要日志记录的类
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/order/order") // 定义请求路径的根地址为/order/order
+public class OrderController {
+
+    @Autowired
+    private OrderService orderService; // 自动注入订单服务类
+
+    @Autowired
+    private OrderItemService orderItemService; // 自动注入订单项服务类
+
+    @Autowired
+    private UserAddrOrderService userAddrOrderService; // 自动注入用户地址订单服务类
+
+    @Autowired
+    private ProductService productService; // 自动注入商品服务类
+
+    @Autowired
+    private SkuService skuService; // 自动注入SKU服务类
+
+    /**
+     * 分页获取订单信息
+     * @param orderParam 订单查询参数
+     * @param page 分页参数
+     * @return 服务器响应实体，包含分页后的订单信息
+     */
+    @GetMapping("/page")
+    @PreAuthorize("@pms.hasPermission('order:order:page')") // 权限检查
+    public ServerResponseEntity<IPage<Order>> page(OrderParam orderParam, PageParam<Order> page) {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        orderParam.setShopId(shopId);
+        IPage<Order> orderPage = orderService.pageOrdersDetailByOrderParam(page, orderParam);
+        return ServerResponseEntity.success(orderPage); // 返回分页结果
+    }
+
+    /**
+     * 获取订单详情信息
+     * @param orderNumber 订单编号
+     * @return 服务器响应实体，包含订单的详细信息
+     */
+    @GetMapping("/orderInfo/{orderNumber}")
+    @PreAuthorize("@pms.hasPermission('order:order:info')") // 权限检查
+    public ServerResponseEntity<Order> info(@PathVariable("orderNumber") String orderNumber) {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        Order order = orderService.getOrderByOrderNumber(orderNumber);
+        if (!Objects.equal(shopId, order.getShopId())) {
+            throw new YamiShopBindException("您没有权限获取该订单信息");
+        }
+        List<OrderItem> orderItems = orderItemService.getOrderItemsByOrderNumber(orderNumber);
+        order.setOrderItems(orderItems);
+        UserAddrOrder userAddrOrder = userAddrOrderService.getById(order.getAddrOrderId());
+        order.setUserAddrOrder(userAddrOrder);
+        return ServerResponseEntity.success(order);
+    }
+
+    /**
+     * 发货
+     * @param deliveryOrderParam 发货订单参数
+     * @return 服务器响应实体
+     */
+    @PutMapping("/delivery")
+    @PreAuthorize("@pms.hasPermission('order:order:delivery')") // 权限检查
+    public ServerResponseEntity<Void> delivery(@RequestBody DeliveryOrderParam deliveryOrderParam) {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        Order order = orderService.getOrderByOrderNumber(deliveryOrderParam.getOrderNumber());
+        if (!Objects.equal(shopId, order.getShopId())) {
+            throw new YamiShopBindException("您没有权限修改该订单信息");
+        }
+
+        Order orderParam = new Order();
+        orderParam.setOrderId(order.getOrderId());
+        orderParam.setDvyId(deliveryOrderParam.getDvyId());
+        orderParam.setDvyFlowId(deliveryOrderParam.getDvyFlowId());
+        orderParam.setDvyTime(new Date());
+        orderParam.setStatus(OrderStatus.CONSIGNMENT.value());
+        orderParam.setUserId(order.getUserId());
+
+        orderService.delivery(orderParam);
+
+        List<OrderItem> orderItems = orderItemService.getOrderItemsByOrderNumber(deliveryOrderParam.getOrderNumber());
+        for (OrderItem orderItem : orderItems) {
+            productService.removeProductCacheByProdId(orderItem.getProdId());
+            skuService.removeSkuCacheBySkuId(orderItem.getSkuId(), orderItem.getProdId());
+        }
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 打印待发货的订单表
+     * @param order 订单对象
+     * @param consignmentName 发件人姓名
+     * @param consignmentMobile 发货人手机号
+     * @param consignmentAddr 发货地址
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @param response HTTP响应对象
+     */
+         * @param order 订单对象
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @param response HTTP响应对象
+     */
+    @GetMapping("/waitingConsignmentExcel")
+    @PreAuthorize("@pms.hasPermission('order:order:waitingConsignmentExcel')") // 权限检查
+    public void waitingConsignmentExcel(Order order, @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date startTime,
+                                        @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date endTime, String consignmentName, String consignmentMobile,
+                                        String consignmentAddr, HttpServletResponse response) {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        order.setShopId(shopId);
+        order.setStatus(OrderStatus.PADYED.value());
+        List<Order> orders = orderService.listOrdersDetailByOrder(order, startTime, endTime);
+
+        // 通过工具类创建ExcelWriter
+        ExcelWriter writer = ExcelUtil.getBigWriter();
+        Sheet sheet = writer.getSheet();
+        sheet.setColumnWidth(0, 20 * 256);
+        sheet.setColumnWidth(1, 20 * 256);
+        sheet.setColumnWidth(2, 20 * 256);
+        sheet.setColumnWidth(3, 60 * 256);
+        sheet.setColumnWidth(4, 60 * 256);
+        sheet.setColumnWidth(7, 60 * 256);
+        sheet.setColumnWidth(8, 60 * 256);
+        sheet.setColumnWidth(9, 60 * 256);
+        // 待发货
+        String[] hearder = {"订单编号", "收件人", "手机", "收货地址", "商品名称", "数量", "发件人姓名", "发件人手机号", "发货地址", "备注"};
+        writer.merge(hearder.length - 1, "发货信息整理");
+        writer.writeRow(Arrays.asList(hearder));
+
+        int row = 1;
+        for (Order dbOrder : orders) {
+            UserAddrOrder addr = dbOrder.getUserAddrOrder();
+            String addrInfo = addr.getProvince() + addr.getCity() + addr.getArea() + addr.getAddr();
+            List<OrderItem> orderItems = dbOrder.getOrderItems();
+            row++;
+            for (OrderItem orderItem : orderItems) {
+                // 第0列开始
+                int col = 0;
+                writer.writeCellValue(col++, row, dbOrder.getOrderNumber());
+                writer.writeCellValue(col++, row, addr.getReceiver());
+                writer.writeCellValue(col++, row, addr.getMobile());
+                writer.writeCellValue(col++, row, addrInfo);
+                writer.writeCellValue(col++, row, orderItem.getProdName());
+                writer.writeCellValue(col++, row, orderItem.getProdCount());
+                writer.writeCellValue(col++, row, consignmentName);
+                writer.writeCellValue(col++, row, consignmentMobile);
+                writer.writeCellValue(col++, row, consignmentAddr);
+                writer.writeCellValue(col++, row, dbOrder.getRemarks());
+            }
+        }
+        writeExcel(response, writer);
+    }
+
+    /**
+     * 已销售订单
+     * @param order 订单对象
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @param response HTTP响应对象
+     */
+
+    @GetMapping("/soldExcel")
+    @PreAuthorize("@pms.hasPermission('order:order:soldExcel')") // 权限检查
+    public void soldExcel(Order order, @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date startTime,
+                          @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date endTime, HttpServletResponse response) {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        order.setShopId(shopId);
+        order.setIsPayed(1);
+        List<Order> orders = orderService.listOrdersDetailByOrder(order, startTime, endTime);
+
+        // 通过工具类创建ExcelWriter
+        ExcelWriter writer = ExcelUtil.getBigWriter();
+        String[] hearder = {"订单编号", "下单时间", "收件人", "手机", "收货地址", "商品名称", "数量", "订单应付", "订单运费", "订单实付"};
+        Sheet sheet = writer.getSheet();
+        sheet.setColumnWidth(0, 20 * 256);
+        sheet.setColumnWidth(1, 20 * 256);
+        sheet.setColumnWidth(3, 20 * 256);
+        sheet.setColumnWidth(4, 60 * 256);
+        sheet.setColumnWidth(5, 60 * 256);
+
+        writer.merge(hearder.length - 1, "销售信息整理");
+        writer.writeRow(Arrays.asList(hearder));
+
+        int row = 1;
+        for (Order dbOrder : orders) {
+            UserAddrOrder addr = dbOrder.getUserAddrOrder();
+            String addrInfo = addr.getProvince() + addr.getCity() + addr.getArea() + addr.getAddr();
+            List<OrderItem> orderItems = dbOrder.getOrderItems();
+            int firstRow = row + 1;
+            int lastRow = row + orderItems.size();
+            int col = -1;
+            // 订单编号
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, dbOrder.getOrderNumber());
+            // 下单时间
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, dbOrder.getCreateTime());
+            // 收件人
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, addr.getReceiver());
+            // 手机
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, addr.getMobile());
+            // 收货地址
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, addrInfo);
+            int prodNameCol = ++col;
+            int prodCountCol = ++col;
+            for (OrderItem orderItem : orderItems) {
+                row++;
+                // 商品名称
+                writer.writeCellValue(prodNameCol, row, orderItem.getProdName());
+                // 数量
+                writer.writeCellValue(prodCountCol, row, orderItem.getProdCount());
+            }
+            // 订单应付
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, dbOrder.getTotal());
+            // 订单运费
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, dbOrder.getFreightAmount());
+            // 订单实付
+            mergeIfNeed(writer, firstRow, lastRow, ++col, col, dbOrder.getActualTotal());
+        }
+        writeExcel(response, writer);
+    }
+
+    /**
+     * 如果需要合并的话，就合并
+     * @param writer ExcelWriter对象
+     * @param firstRow 起始行
+     * @param lastRow 结束行
+     * @param firstColumn 起始列
+     * @param lastColumn 结束列
+     * @param content 合并内容
+     */
+    private void mergeIfNeed(ExcelWriter writer, int firstRow, int lastRow, int firstColumn, int lastColumn, Object content) {
+        if (content instanceof Date) {
+            content = DateUtil.format((Date) content, DatePattern.NORM_DATETIME_PATTERN);
+        }
+        if (lastRow - firstRow > 0 || lastColumn - firstColumn > 0) {
+            writer.merge(firstRow, lastRow, firstColumn, lastColumn, content, false);
+        } else {
+            writer.writeCellValue(firstColumn, firstRow, content);
+        }
+    }
+
+    /**
+     * 写出Excel文件
+     * @param response HTTP响应对象
+     * @param writer ExcelWriter对象
+     */
+    private void writeExcel(HttpServletResponse response, ExcelWriter writer) {
+        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+        response.setHeader("Content-Disposition", "attachment;filename=1.xls");
+
+        ServletOutputStream servletOutputStream = null;
+        try {
+            servletOutputStream = response.getOutputStream();
+            writer.flush(servletOutputStream);
+            servletOutputStream.flush();
+        } catch (IORuntimeException | IOException e) {
+            log.error("写出Excel错误：", e);
+        } finally {
+            IoUtil.close(writer);
+        }
+    }
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/PickAddrController.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import cn.hutool.core.util.StrUtil; // 引入Hutool工具类库中的StrUtil工具类
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; // 引入MyBatis-Plus的条件查询包装器
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入MyBatis-Plus的分页接口
+import com.yami.shop.bean.model.PickAddr; // 引入自提点地址模型类
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.response.ResponseEnum; // 引入响应枚举类
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import com.yami.shop.common.util.PageParam; // 引入分页参数工具类
+import com.yami.shop.security.admin.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.PickAddrService; // 引入自提点地址服务类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import org.springframework.security.access.prepost.PreAuthorize; // 引入Spring Security的PreAuthorize注解
+import org.springframework.web.bind.annotation.*; // 引入Spring Web的注解
+
+import jakarta.validation.Valid; // 引入Jakarta Validation的Valid注解
+import java.util.Arrays; // 引入Java的Arrays工具类
+import java.util.Objects; // 引入Java的Objects工具类
+
+/**
+ * PickAddrController类，用于管理自提点地址。
+ * 该类包含分页获取、获取详细信息、保存、修改和删除自提点地址的方法。
+ * @作者 lgh on 2018/10/17.
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/shop/pickAddr") // 定义请求路径的根地址为/shop/pickAddr
+public class PickAddrController {
+
+	@Autowired
+	private PickAddrService pickAddrService; // 自动注入自提点地址服务类
+
+	/**
+	 * 分页获取自提点地址
+	 * @param pickAddr 自提点地址查询条件
+	 * @param page 分页参数
+	 * @return 服务器响应实体，包含分页后的自提点地址信息
+	 */
+	@GetMapping("/page")
+	@PreAuthorize("@pms.hasPermission('shop:pickAddr:page')") // 权限检查
+	public ServerResponseEntity<IPage<PickAddr>> page(PickAddr pickAddr, PageParam<PickAddr> page) {
+		IPage<PickAddr> pickAddrs = pickAddrService.page(page, new LambdaQueryWrapper<PickAddr>()
+				.like(StrUtil.isNotBlank(pickAddr.getAddrName()), PickAddr::getAddrName, pickAddr.getAddrName())
+				.orderByDesc(PickAddr::getAddrId));
+		return ServerResponseEntity.success(pickAddrs); // 返回分页结果
+	}
+
+	/**
+	 * 获取自提点地址详细信息
+	 * @param id 自提点地址ID
+	 * @return 服务器响应实体，包含自提点地址的详细信息
+	 */
+	@GetMapping("/info/{id}")
+	@PreAuthorize("@pms.hasPermission('shop:pickAddr:info')") // 权限检查
+	public ServerResponseEntity<PickAddr> info(@PathVariable("id") Long id) {
+		PickAddr pickAddr = pickAddrService.getById(id);
+		return ServerResponseEntity.success(pickAddr); // 返回自提点地址信息
+	}
+
+	/**
+	 * 保存自提点地址
+	 * @param pickAddr 自提点地址信息
+	 * @return 服务器响应实体
+	 */
+	@PostMapping
+	@PreAuthorize("@pms.hasPermission('shop:pickAddr:save')") // 权限检查
+	public ServerResponseEntity<Void> save(@Valid @RequestBody PickAddr pickAddr) {
+		pickAddr.setShopId(SecurityUtils.getSysUser().getShopId()); // 设置店铺ID
+		pickAddrService.save(pickAddr); // 保存自提点地址
+		return ServerResponseEntity.success(); // 返回成功响应
+	}
+
+	/**
+	 * 修改自提点地址
+	 * @param pickAddr 自提点地址信息
+	 * @return 服务器响应实体
+	 */
+	@PutMapping
+	@PreAuthorize("@pms.hasPermission('shop:pickAddr:update')") // 权限检查
+	public ServerResponseEntity<Void> update(@Valid @RequestBody PickAddr pickAddr) {
+		PickAddr dbPickAddr = pickAddrService.getById(pickAddr.getAddrId());
+
+		if (!Objects.equals(dbPickAddr.getShopId(), SecurityUtils.getSysUser().getShopId())) {
+			throw new YamiShopBindException(ResponseEnum.UNAUTHORIZED);
+		}
+		pickAddrService.updateById(pickAddr); // 修改自提点地址
+		return ServerResponseEntity.success(); // 返回成功响应
+	}
+
+	/**
+	 * 删除自提点地址
+	 * @param ids 自提点地址ID数组
+	 * @return 服务器响应实体
+	 */
+	@DeleteMapping
+	@PreAuthorize("@pms.hasPermission('shop:pickAddr:delete')") // 权限检查
+	public ServerResponseEntity<Void> delete(@RequestBody Long[] ids) {
+		pickAddrService.removeByIds(Arrays.asList(ids)); // 删除自提点地址
+		return ServerResponseEntity.success(); // 返回成功响应
+	}
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/TransportController.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; // 引入MyBatis-Plus的条件查询包装器
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入MyBatis-Plus的分页接口
+import com.yami.shop.bean.model.Transport; // 引入运费模板模型类
+import com.yami.shop.common.util.PageParam; // 引入分页参数工具类
+import com.yami.shop.security.admin.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.TransportService; // 引入运费模板服务类
+import org.apache.commons.lang3.StringUtils; // 引入Apache Commons的StringUtils工具类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.security.access.prepost.PreAuthorize; // 引入Spring Security的PreAuthorize注解
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Date; // 引入Java的Date类
+import java.util.List; // 引入Java的List接口
+
+/**
+ * 运费模板管理控制器
+ * 该类包含分页获取、获取详细信息、保存、修改和删除运费模板的方法。
+ * @作者 lgh on 2018/11/16.
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/shop/transport") // 定义请求路径的根地址为/shop/transport
+public class TransportController {
+
+    @Autowired
+    private TransportService transportService; // 自动注入运费模板服务类
+
+    /**
+     * 分页获取运费模板
+     * @param transport 运费模板查询条件
+     * @param page 分页参数
+     * @return 服务器响应实体，包含分页后的运费模板信息
+     */
+    @GetMapping("/page")
+    @PreAuthorize("@pms.hasPermission('shop:transport:page')") // 权限检查
+    public ServerResponseEntity<IPage<Transport>> page(Transport transport, PageParam<Transport> page) {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        IPage<Transport> transports = transportService.page(page,
+                new LambdaQueryWrapper<Transport>()
+                        .eq(Transport::getShopId, shopId)
+                        .like(StringUtils.isNotBlank(transport.getTransName()), Transport::getTransName, transport.getTransName()));
+        return ServerResponseEntity.success(transports);
+    }
+
+    /**
+     * 获取运费模板详细信息
+     * @param id 运费模板ID
+     * @return 服务器响应实体，包含运费模板的详细信息
+     */
+    @GetMapping("/info/{id}")
+    @PreAuthorize("@pms.hasPermission('shop:transport:info')") // 权限检查
+    public ServerResponseEntity<Transport> info(@PathVariable("id") Long id) {
+        Transport transport = transportService.getTransportAndAllItems(id);
+        return ServerResponseEntity.success(transport);
+    }
+
+    /**
+     * 保存运费模板
+     * @param transport 运费模板信息
+     * @return 服务器响应实体
+     */
+    @PostMapping
+    @PreAuthorize("@pms.hasPermission('shop:transport:save')") // 权限检查
+    public ServerResponseEntity<Void> save(@RequestBody Transport transport) {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        transport.setShopId(shopId);
+        Date createTime = new Date();
+        transport.setCreateTime(createTime);
+        transportService.insertTransportAndTransfee(transport);
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 修改运费模板
+     * @param transport 运费模板信息
+     * @return 服务器响应实体
+     */
+    @PutMapping
+    @PreAuthorize("@pms.hasPermission('shop:transport:update')") // 权限检查
+    public ServerResponseEntity<Void> update(@RequestBody Transport transport) {
+        transportService.updateTransportAndTransfee(transport);
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 删除运费模板
+     * @param ids 运费模板ID数组
+     * @return 服务器响应实体
+     */
+    @DeleteMapping
+    @PreAuthorize("@pms.hasPermission('shop:transport:delete')") // 权限检查
+    public ServerResponseEntity<Void> delete(@RequestBody Long[] ids) {
+        transportService.deleteTransportAndTransfeeAndTranscity(ids);
+        // 删除运费模板的缓存
+        for (Long id : ids) {
+            transportService.removeTransportAndAllItemsCache(id);
+        }
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 获取运费模板列表
+     * @return 服务器响应实体，包含运费模板列表信息
+     */
+    @GetMapping("/list")
+    public ServerResponseEntity<List<Transport>> list() {
+        Long shopId = SecurityUtils.getSysUser().getShopId();
+        List<Transport> list = transportService.list(new LambdaQueryWrapper<Transport>().eq(Transport::getShopId, shopId));
+        return ServerResponseEntity.success(list);
+    }
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/controller/UserAddrController.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.controller; // 定义类所在的包
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; // 引入MyBatis-Plus的条件查询包装器
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入MyBatis-Plus的分页接口
+import com.yami.shop.common.util.PageParam; // 引入分页参数工具类
+import com.yami.shop.bean.model.UserAddr; // 引入用户地址模型类
+import com.yami.shop.common.annotation.SysLog; // 引入自定义日志注解
+import com.yami.shop.service.UserAddrService; // 引入用户地址服务类
+import lombok.AllArgsConstructor; // 引入Lombok的@AllArgsConstructor注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.security.access.prepost.PreAuthorize; // 引入Spring Security的PreAuthorize注解
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid; // 引入Jakarta Validation的Valid注解
+
+/**
+ * 用户地址管理控制器
+ * 该类包含分页获取、获取详细信息、保存、修改和删除用户地址的方法。
+ * @作者 hzm
+ * @日期 2019-04-15 10:49:40
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@AllArgsConstructor // 使用Lombok注解生成全参构造函数
+@RequestMapping("/user/addr") // 定义请求路径的根地址为/user/addr
+public class UserAddrController {
+
+    private final UserAddrService userAddrService; // 自动注入用户地址服务类
+
+    /**
+     * 分页获取用户地址
+     * @param page 分页对象
+     * @param userAddr 用户地址查询条件
+     * @return 服务器响应实体，包含分页后的用户地址信息
+     */
+    @GetMapping("/page")
+    public ServerResponseEntity<IPage<UserAddr>> getUserAddrPage(PageParam page, UserAddr userAddr) {
+        return ServerResponseEntity.success(userAddrService.page(page, new LambdaQueryWrapper<UserAddr>())); // 返回分页结果
+    }
+
+    /**
+     * 通过ID查询用户地址
+     * @param addrId 用户地址ID
+     * @return 服务器响应实体，包含用户地址的详细信息
+     */
+    @GetMapping("/info/{addrId}")
+    public ServerResponseEntity<UserAddr> getById(@PathVariable("addrId") Long addrId) {
+        return ServerResponseEntity.success(userAddrService.getById(addrId)); // 返回用户地址信息
+    }
+
+    /**
+     * 新增用户地址
+     * @param userAddr 用户地址信息
+     * @return 服务器响应实体，包含新增结果
+     */
+    @SysLog("新增用户地址管理") // 自定义日志注解
+    @PostMapping
+    @PreAuthorize("@pms.hasPermission('user:addr:save')") // 权限检查
+    public ServerResponseEntity<Boolean> save(@RequestBody @Valid UserAddr userAddr) {
+        return ServerResponseEntity.success(userAddrService.save(userAddr)); // 保存用户地址并返回结果
+    }
+
+    /**
+     * 修改用户地址
+     * @param userAddr 用户地址信息
+     * @return 服务器响应实体，包含修改结果
+     */
+    @SysLog("修改用户地址管理") // 自定义日志注解
+    @PutMapping
+    @PreAuthorize("@pms.hasPermission('user:addr:update')") // 权限检查
+    public ServerResponseEntity<Boolean> updateById(@RequestBody @Valid UserAddr userAddr) {
+        return ServerResponseEntity.success(userAddrService.updateById(userAddr)); // 修改用户地址并返回结果
+    }
+
+    /**
+     * 通过ID删除用户地址
+     * @param addrId 用户地址ID
+     * @return 服务器响应实体，包含删除结果
+     */
+    @SysLog("删除用户地址管理") // 自定义日志注解
+    @DeleteMapping("/{addrId}")
+    @PreAuthorize("@pms.hasPermission('user:addr:delete')") // 权限检查
+    public ServerResponseEntity<Boolean> removeById(@PathVariable Long addrId) {
+        return ServerResponseEntity.success(userAddrService.removeById(addrId)); // 删除用户地址并返回结果
+    }
+}

yami-shop-admin/src/main/java/com/yami/shop/admin/task/OrderTask.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.admin.task; // 定义类所在的包
+
+import cn.hutool.core.collection.CollectionUtil; // 引入Hutool工具类库中的CollectionUtil工具类
+import cn.hutool.core.date.DateUtil; // 引入Hutool工具类库中的DateUtil工具类
+import com.xxl.job.core.handler.annotation.XxlJob; // 引入XXL-Job的注解
+import com.yami.shop.bean.enums.OrderStatus; // 引入订单状态枚举类
+import com.yami.shop.bean.model.Order; // 引入订单模型类
+import com.yami.shop.bean.model.OrderItem; // 引入订单项模型类
+import com.yami.shop.service.OrderService; // 引入订单服务类
+import com.yami.shop.service.ProductService; // 引入商品服务类
+import com.yami.shop.service.SkuService; // 引入SKU服务类
+import org.slf4j.Logger; // 引入SLF4J的Logger类
+import org.slf4j.LoggerFactory; // 引入SLF4J的LoggerFactory类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import org.springframework.stereotype.Component; // 引入Spring的@Component注解
+
+import java.util.Date; // 引入Java的Date类
+import java.util.List; // 引入Java的List接口
+
+/**
+ * OrderTask类，用于管理与订单相关的定时任务操作。
+ * 定时任务的配置，请查看xxl-job的java配置文件。
+ * @作者 FrozenWatermelon
+ * @参见 com.yami.shop.admin.config.XxlJobConfig
+ */
+@Component("orderTask") // 标注这是一个Spring组件，并且以orderTask为组件名称
+public class OrderTask {
+
+    private static final Logger logger = LoggerFactory.getLogger(OrderTask.class); // 日志记录器
+
+    @Autowired
+    private OrderService orderService; // 自动注入订单服务类
+    @Autowired
+    private ProductService productService; // 自动注入商品服务类
+    @Autowired
+    private SkuService skuService; // 自动注入SKU服务类
+
+    /**
+     * 取消超时未支付订单
+     */
+    @XxlJob("cancelOrder")
+    public void cancelOrder() {
+        Date now = new Date();
+        logger.info("取消超时未支付订单。。。");
+        // 获取30分钟之前未支付的订单
+        List<Order> orders = orderService.listOrderAndOrderItems(OrderStatus.UNPAY.value(), DateUtil.offsetMinute(now, -30));
+        if (CollectionUtil.isEmpty(orders)) {
+            return;
+        }
+        orderService.cancelOrders(orders);
+        for (Order order : orders) {
+            List<OrderItem> orderItems = order.getOrderItems();
+            for (OrderItem orderItem : orderItems) {
+                productService.removeProductCacheByProdId(orderItem.getProdId());
+                skuService.removeSkuCacheBySkuId(orderItem.getSkuId(), orderItem.getProdId());
+            }
+        }
+    }
+
+    /**
+     * 确认收货
+     */
+    @XxlJob("confirmOrder")
+    public void confirmOrder() {
+        Date now = new Date();
+        logger.info("系统自动确认收货订单。。。");
+        // 获取15天之前未支付的订单
+        List<Order> orders = orderService.listOrderAndOrderItems(OrderStatus.CONSIGNMENT.value(), DateUtil.offsetDay(now, -15));
+        if (CollectionUtil.isEmpty(orders)) {
+            return;
+        }
+        orderService.confirmOrder(orders);
+        for (Order order : orders) {
+            List<OrderItem> orderItems = order.getOrderItems();
+            for (OrderItem orderItem : orderItems) {
+                productService.removeProductCacheByProdId(orderItem.getProdId());
+                skuService.removeSkuCacheBySkuId(orderItem.getSkuId(), orderItem.getProdId());
+            }
+        }
+    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/config/ApiBeanConfig.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.config; // 定义类所在的包
+
+import cn.hutool.core.lang.Snowflake; // 引入Hutool工具包中的Snowflake类，用于生成唯一ID
+import lombok.AllArgsConstructor; // 引入Lombok的@AllArgsConstructor注解，自动生成全参构造函数
+import org.springframework.context.annotation.Bean; // 引入Spring的@Bean注解
+import org.springframework.context.annotation.Configuration; // 引入Spring的@Configuration注解
+
+/**
+ * ApiBeanConfig类，用于配置Snowflake实例，生成唯一ID。
+ * @作者 lanhai
+ */
+@Configuration // 标注这是一个配置类
+@AllArgsConstructor // 使用Lombok注解生成全参构造函数
+public class ApiBeanConfig {
+
+    private final ApiConfig apiConfig; // 自动注入ApiConfig配置类的实例
+
+    @Bean // 标注这是一个Spring Bean，会被Spring容器管理
+    public Snowflake snowflake() {
+        // 创建并返回一个Snowflake实例，用于生成全局唯一ID
+        return new Snowflake(apiConfig.getWorkerId(), apiConfig.getDatacenterId());
+    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/AddrController.java

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.yami.shop.bean.app.dto.UserAddrDto;
+import com.yami.shop.bean.app.param.AddrParam;
+import com.yami.shop.bean.model.UserAddr;
+import com.yami.shop.common.exception.YamiShopBindException;
+import com.yami.shop.common.response.ServerResponseEntity;
+import com.yami.shop.security.api.util.SecurityUtils;
+import com.yami.shop.service.UserAddrService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import cn.hutool.core.bean.BeanUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author lanhai
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/p/address") // 定义请求路径的根地址为/p/address
+@Tag(name = "地址接口") // 给API文档添加标签，描述这个控制器的功能
+@AllArgsConstructor // Lombok注解，用于生成全参构造函数
+public class AddrController {
+
+    @Autowired
+    private UserAddrService userAddrService; // 自动注入用户地址服务类
+
+    /**
+     * 选择订单配送地址
+     */
+    @GetMapping("/list")
+    @Operation(summary = "用户地址列表" , description = "获取用户的所有地址信息")
+    public ServerResponseEntity<List<UserAddrDto>> dvyList() {
+        // 获取当前用户ID
+        String userId = SecurityUtils.getUser().getUserId();
+        // 查询用户的所有地址信息，并按是否常用和更新时间倒序排序
+        List<UserAddr> userAddrs = userAddrService.list(
+                new LambdaQueryWrapper<UserAddr>()
+                        .eq(UserAddr::getUserId, userId)
+                        .orderByDesc(UserAddr::getCommonAddr)
+                        .orderByDesc(UserAddr::getUpdateTime)
+        );
+        // 将地址信息转换成DTO对象并返回
+        return ServerResponseEntity.success(BeanUtil.copyToList(userAddrs, UserAddrDto.class));
+    }
+
+    @PostMapping("/addAddr")
+    @Operation(summary = "新增用户地址" , description = "新增用户地址")
+    public ServerResponseEntity<String> addAddr(@Valid @RequestBody AddrParam addrParam) {
+        String userId = SecurityUtils.getUser().getUserId();
+
+        // 检查地址是否已存在
+        if (addrParam.getAddrId() != null && addrParam.getAddrId() != 0) {
+            return ServerResponseEntity.showFailMsg("该地址已存在");
+        }
+
+        // 统计用户已有的地址数量
+        long addrCount = userAddrService.count(new LambdaQueryWrapper<UserAddr>().eq(UserAddr::getUserId, userId));
+        UserAddr userAddr = BeanUtil.copyProperties(addrParam, UserAddr.class);
+
+        // 如果没有地址，设为常用地址，否则设为非常用
+        if (addrCount == 0) {
+            userAddr.setCommonAddr(1);
+        } else {
+            userAddr.setCommonAddr(0);
+        }
+
+        userAddr.setUserId(userId);
+        userAddr.setStatus(1); // 设置状态为有效
+        userAddr.setCreateTime(new Date()); // 设置创建时间
+        userAddr.setUpdateTime(new Date()); // 设置更新时间
+
+        // 保存地址信息
+        userAddrService.save(userAddr);
+
+        // 如果是常用地址，清除默认地址缓存
+        if (userAddr.getCommonAddr() == 1) {
+            userAddrService.removeUserAddrByUserId(0L, userId);
+        }
+        return ServerResponseEntity.success("添加地址成功");
+    }
+
+    /**
+     * 修改订单配送地址
+     */
+    @PutMapping("/updateAddr")
+    @Operation(summary = "修改订单用户地址" , description = "修改用户地址")
+    public ServerResponseEntity<String> updateAddr(@Valid @RequestBody AddrParam addrParam) {
+        String userId = SecurityUtils.getUser().getUserId();
+
+        // 根据用户ID和地址ID获取地址信息
+        UserAddr dbUserAddr = userAddrService.getUserAddrByUserId(addrParam.getAddrId(), userId);
+        if (dbUserAddr == null) {
+            return ServerResponseEntity.showFailMsg("该地址已被删除");
+        }
+
+        // 更新地址信息
+        UserAddr userAddr = BeanUtil.copyProperties(addrParam, UserAddr.class);
+        userAddr.setUserId(userId);
+        userAddr.setUpdateTime(new Date());
+        userAddrService.updateById(userAddr);
+
+        // 清除缓存
+        userAddrService.removeUserAddrByUserId(addrParam.getAddrId(), userId);
+        userAddrService.removeUserAddrByUserId(0L, userId);
+
+        return ServerResponseEntity.success("修改地址成功");
+    }
+
+    /**
+     * 删除订单配送地址
+     */
+    @DeleteMapping("/deleteAddr/{addrId}")
+    @Operation(summary = "删除订单用户地址" , description = "根据地址id，删除用户地址")
+    @Parameter(name = "addrId", description = "地址ID" , required = true)
+    public ServerResponseEntity<String> deleteDvy(@PathVariable("addrId") Long addrId) {
+        String userId = SecurityUtils.getUser().getUserId();
+
+        // 根据用户ID和地址ID获取地址信息
+        UserAddr userAddr = userAddrService.getUserAddrByUserId(addrId, userId);
+        if (userAddr == null) {
+            return ServerResponseEntity.showFailMsg("该地址已被删除");
+        }
+
+        // 检查是否为默认地址，默认地址无法删除
+        if (userAddr.getCommonAddr() == 1) {
+            return ServerResponseEntity.showFailMsg("默认地址无法删除");
+        }
+
+        // 删除地址信息
+        userAddrService.removeById(addrId);
+        userAddrService.removeUserAddrByUserId(addrId, userId);
+        return ServerResponseEntity.success("删除地址成功");
+    }
+
+    /**
+     * 设置默认地址
+     */
+    @PutMapping("/defaultAddr/{addrId}")
+    @Operation(summary = "设置默认地址" , description = "根据地址id，设置默认地址")
+    public ServerResponseEntity<String> defaultAddr(@PathVariable("addrId") Long addrId) {
+        String userId = SecurityUtils.getUser().getUserId();
+
+        // 更新默认地址
+        userAddrService.updateDefaultUserAddr(addrId, userId);
+
+        // 清除缓存
+        userAddrService.removeUserAddrByUserId(0L, userId);
+        userAddrService.removeUserAddrByUserId(addrId, userId);
+
+        return ServerResponseEntity.success("修改地址成功");
+    }
+
+    /**
+     * 获取地址信息订单配送地址
+     */
+    @GetMapping("/addrInfo/{addrId}")
+    @Operation(summary = "获取地址信息" , description = "根据地址id，获取地址信息")
+    @Parameter(name = "addrId", description = "地址ID" , required = true)
+    public ServerResponseEntity<UserAddrDto> addrInfo(@PathVariable("addrId") Long addrId) {
+        String userId = SecurityUtils.getUser().getUserId();
+
+        // 根据用户ID和地址ID获取地址信息
+        UserAddr userAddr = userAddrService.getUserAddrByUserId(addrId, userId);
+        if (userAddr == null) {
+            throw new YamiShopBindException("该地址已被删除");
+        }
+
+        // 转换为DTO对象并返回
+        return ServerResponseEntity.success(BeanUtil.copyProperties(userAddr, UserAddrDto.class));
+    }
+
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/AreaController.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller; // 定义类所在的包
+
+import java.util.List; // 引入Java的List接口
+
+import com.yami.shop.service.AreaService; // 引入区域服务类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.web.bind.annotation.GetMapping; // 引入Spring的@GetMapping注解
+import org.springframework.web.bind.annotation.RequestMapping; // 引入Spring的@RequestMapping注解
+import org.springframework.web.bind.annotation.RestController; // 引入Spring的@RestController注解
+
+import com.yami.shop.bean.model.Area; // 引入区域模型
+
+import io.swagger.v3.oas.annotations.tags.Tag; // 引入Swagger的Tag注解
+import io.swagger.v3.oas.annotations.Parameter; // 引入Swagger的Parameter注解
+import io.swagger.v3.oas.annotations.Operation; // 引入Swagger的Operation注解
+
+/**
+ * AreaController类，负责处理省市区信息的获取请求。
+ * 该类包含一个根据父级ID获取省市区信息的方法。
+ * @作者 lgh on 2018/10/26.
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/p/area") // 定义请求路径的根地址为/p/area
+@Tag(name = "省市区接口") // 给API文档添加标签，描述这个控制器的功能
+public class AreaController {
+
+    @Autowired
+    private AreaService areaService; // 自动注入区域服务类
+
+    /**
+     * 根据省市区的父级ID获取地址信息
+     * @param pid 省市区的父级ID(pid为0获取所有省份)
+     * @return 服务器响应实体，包含查询到的省市区信息
+     */
+    @GetMapping("/listByPid")
+    @Operation(summary = "获取省市区信息" , description = "根据省市区的pid获取地址信息")
+    @Parameter(name = "pid", description = "省市区的pid(pid为0获取所有省份)" , required = true)
+    public ServerResponseEntity<List<Area>> listByPid(Long pid) {
+        List<Area> list = areaService.listByPid(pid);
+        return ServerResponseEntity.success(list);
+    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/CategoryController.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller; // 定义类所在的包
+
+import java.util.List; // 引入Java的List接口
+
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.web.bind.annotation.*; // 引入Spring Web的注解
+
+import com.yami.shop.bean.app.dto.CategoryDto; // 引入分类DTO类
+import com.yami.shop.bean.model.Category; // 引入分类模型类
+import com.yami.shop.service.CategoryService; // 引入分类服务类
+
+import io.swagger.v3.oas.annotations.tags.Tag; // 引入Swagger的Tag注解
+import io.swagger.v3.oas.annotations.Parameter; // 引入Swagger的Parameter注解
+import io.swagger.v3.oas.annotations.Operation; // 引入Swagger的Operation注解
+import cn.hutool.core.bean.BeanUtil; // 引入Hutool工具类库中的BeanUtil工具类
+
+/**
+ * CategoryController类，用于管理商品分类。
+ * 该类包含获取分类信息列表的方法。
+ * @作者 lanhai
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/category") // 定义请求路径的根地址为/category
+@Tag(name = "分类接口") // 给API文档添加标签，描述这个控制器的功能
+public class CategoryController {
+
+    @Autowired
+    private CategoryService categoryService; // 自动注入分类服务类
+
+    /**
+     * 分类信息列表接口
+     * @param parentId 分类ID，默认值为0
+     * @return 服务器响应实体，包含分类信息列表
+     */
+    @GetMapping("/categoryInfo")
+    @Operation(summary = "分类信息列表", description = "获取所有的产品分类信息，顶级分类的parentId为0,默认为顶级分类")
+    @Parameter(name = "parentId", description = "分类ID", required = false)
+    public ServerResponseEntity<List<CategoryDto>> categoryInfo(@RequestParam(value = "parentId", defaultValue = "0") Long parentId) {
+        List<Category> categories = categoryService.listByParentId(parentId);
+        List<CategoryDto> categoryDtos = BeanUtil.copyToList(categories, CategoryDto.class);
+        return ServerResponseEntity.success(categoryDtos);
+    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/DeliveryController.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller; // 定义类所在的包
+
+import com.yami.shop.service.OrderService; // 引入订单服务类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.web.bind.annotation.GetMapping; // 引入Spring的@GetMapping注解
+import org.springframework.web.bind.annotation.RequestMapping; // 引入Spring的@RequestMapping注解
+import org.springframework.web.bind.annotation.RestController; // 引入Spring的@RestController注解
+
+import com.yami.shop.bean.app.dto.DeliveryDto; // 引入物流DTO
+import com.yami.shop.bean.model.Delivery; // 引入配送模型
+import com.yami.shop.bean.model.Order; // 引入订单模型
+import com.yami.shop.common.util.Json; // 引入JSON工具类
+import com.yami.shop.service.DeliveryService; // 引入配送服务类
+
+import cn.hutool.http.HttpUtil; // 引入Hutool工具类库中的HttpUtil工具类
+import io.swagger.v3.oas.annotations.tags.Tag; // 引入Swagger的Tag注解
+import io.swagger.v3.oas.annotations.Parameter; // 引入Swagger的Parameter注解
+import io.swagger.v3.oas.annotations.Operation; // 引入Swagger的Operation注解
+
+/**
+ * DeliveryController类，负责查看物流信息。
+ * 该类包含一个查看物流信息的方法，根据订单号查看物流详情。
+ * @作者 lanhai
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/delivery") // 定义请求路径的根地址为/delivery
+@Tag(name = "查看物流接口") // 给API文档添加标签，描述这个控制器的功能
+public class DeliveryController {
+
+	@Autowired
+	private DeliveryService deliveryService; // 自动注入配送服务类
+	@Autowired
+	private OrderService orderService; // 自动注入订单服务类
+
+	/**
+	 * 查看物流接口
+	 * @param orderNumber 订单号
+	 * @return 服务器响应实体，包含物流信息
+	 */
+	@GetMapping("/check")
+	@Operation(summary = "查看物流" , description = "根据订单号查看物流")
+	@Parameter(name = "orderNumber", description = "订单号" , required = true)
+	public ServerResponseEntity<DeliveryDto> checkDelivery(String orderNumber) {
+
+		Order order = orderService.getOrderByOrderNumber(orderNumber); // 根据订单号获取订单信息
+		Delivery delivery = deliveryService.getById(order.getDvyId()); // 根据配送ID获取配送信息
+		String url = delivery.getQueryUrl().replace("{dvyFlowId}", order.getDvyFlowId()); // 构建查询物流信息的URL
+		String deliveryJson = HttpUtil.get(url); // 发送HTTP GET请求获取物流信息
+
+		DeliveryDto deliveryDto = Json.parseObject(deliveryJson, DeliveryDto.class); // 将JSON格式的物流信息转换为DTO对象
+		deliveryDto.setDvyFlowId(order.getDvyFlowId()); // 设置物流流水号
+		deliveryDto.setCompanyHomeUrl(delivery.getCompanyHomeUrl()); // 设置物流公司主页URL
+		deliveryDto.setCompanyName(delivery.getDvyName()); // 设置物流公司名称
+		return ServerResponseEntity.success(deliveryDto); // 返回物流信息
+	}
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/MyOrderController.java

@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller; // 定义类所在的包
+
+import cn.hutool.core.bean.BeanUtil; // 引入Hutool工具类库中的BeanUtil工具类
+import com.baomidou.mybatisplus.core.metadata.IPage; // 引入MyBatis-Plus的分页接口
+import com.yami.shop.bean.app.dto.*; // 引入各种DTO类
+import com.yami.shop.bean.enums.OrderStatus; // 引入订单状态枚举
+import com.yami.shop.bean.model.Order; // 引入订单模型
+import com.yami.shop.bean.model.OrderItem; // 引入订单项模型
+import com.yami.shop.bean.model.ShopDetail; // 引入店铺详情模型
+import com.yami.shop.bean.model.UserAddrOrder; // 引入用户地址订单模型
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import com.yami.shop.common.util.Arith; // 引入算术工具类
+import com.yami.shop.common.util.PageParam; // 引入分页参数工具类
+import com.yami.shop.security.api.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.*; // 引入各种服务类
+import io.swagger.v3.oas.annotations.Operation; // 引入Swagger的Operation注解
+import io.swagger.v3.oas.annotations.Parameter; // 引入Swagger的Parameter注解
+import io.swagger.v3.oas.annotations.Parameters; // 引入Swagger的Parameters注解
+import io.swagger.v3.oas.annotations.tags.Tag; // 引入Swagger的Tag注解
+import lombok.AllArgsConstructor; // 引入Lombok的@AllArgsConstructor注解
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Collections; // 引入Java的Collections工具类
+import java.util.List; // 引入Java的List接口
+import java.util.Objects; // 引入Java的Objects工具类
+
+/**
+ * MyOrderController类，用于管理用户的订单操作。
+ * 该类包含获取订单详情、获取订单列表、取消订单、确认收货、删除订单和获取订单数量的方法。
+ * @作者 lanhai
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/p/myOrder") // 定义请求路径的根地址为/p/myOrder
+@Tag(name = "我的订单接口") // 给API文档添加标签，描述这个控制器的功能
+@AllArgsConstructor // 使用Lombok注解生成全参构造函数
+public class MyOrderController {
+
+    private final OrderService orderService; // 注入订单服务类
+
+    private final UserAddrOrderService userAddrOrderService; // 注入用户地址订单服务类
+
+    private final ProductService productService; // 注入商品服务类
+
+    private final SkuService skuService; // 注入SKU服务类
+
+    private final MyOrderService myOrderService; // 注入我的订单服务类
+
+    private final ShopDetailService shopDetailService; // 注入店铺详情服务类
+
+    private final OrderItemService orderItemService; // 注入订单项服务类
+
+    /**
+     * 订单详情信息接口
+     * @param orderNumber 订单号
+     * @return 服务器响应实体，包含订单详情信息
+     */
+    @GetMapping("/orderDetail")
+    @Operation(summary = "订单详情信息", description = "根据订单号获取订单详情信息")
+    @Parameter(name = "orderNumber", description = "订单号", required = true)
+    public ServerResponseEntity<OrderShopDto> orderDetail(@RequestParam(value = "orderNumber") String orderNumber) {
+
+        String userId = SecurityUtils.getUser().getUserId();
+        OrderShopDto orderShopDto = new OrderShopDto();
+
+        Order order = orderService.getOrderByOrderNumber(orderNumber);
+
+        if (order == null) {
+            throw new RuntimeException("该订单不存在");
+        }
+        if (!Objects.equals(order.getUserId(), userId)) {
+            throw new RuntimeException("你没有权限获取该订单信息");
+        }
+
+        ShopDetail shopDetail = shopDetailService.getShopDetailByShopId(order.getShopId());
+        UserAddrOrder userAddrOrder = userAddrOrderService.getById(order.getAddrOrderId());
+        UserAddrDto userAddrDto = BeanUtil.copyProperties(userAddrOrder, UserAddrDto.class);
+        List<OrderItem> orderItems = orderItemService.getOrderItemsByOrderNumber(orderNumber);
+        List<OrderItemDto> orderItemList = BeanUtil.copyToList(orderItems, OrderItemDto.class);
+
+        orderShopDto.setShopId(shopDetail.getShopId());
+        orderShopDto.setShopName(shopDetail.getShopName());
+        orderShopDto.setActualTotal(order.getActualTotal());
+        orderShopDto.setUserAddrDto(userAddrDto);
+        orderShopDto.setOrderItemDtos(orderItemList);
+        orderShopDto.setTransfee(order.getFreightAmount());
+        orderShopDto.setReduceAmount(order.getReduceAmount());
+        orderShopDto.setCreateTime(order.getCreateTime());
+        orderShopDto.setRemarks(order.getRemarks());
+        orderShopDto.setStatus(order.getStatus());
+
+        double total = 0.0;
+        Integer totalNum = 0;
+        for (OrderItemDto orderItem : orderShopDto.getOrderItemDtos()) {
+            total = Arith.add(total, orderItem.getProductTotalAmount());
+            totalNum += orderItem.getProdCount();
+        }
+        orderShopDto.setTotal(total);
+        orderShopDto.setTotalNum(totalNum);
+
+        return ServerResponseEntity.success(orderShopDto);
+    }
+
+    /**
+     * 订单列表接口
+     * @param status 订单状态
+     * @param page 分页参数
+     * @return 服务器响应实体，包含订单列表信息
+     */
+    @GetMapping("/myOrder")
+    @Operation(summary = "订单列表信息", description = "根据订单状态获取订单列表信息，状态为0时获取所有订单")
+    @Parameters({
+            @Parameter(name = "status", description = "订单状态 1:待付款 2:待发货 3:待收货 4:待评价 5:成功 6:失败")
+    })
+    public ServerResponseEntity<IPage<MyOrderDto>> myOrder(@RequestParam(value = "status") Integer status, PageParam<MyOrderDto> page) {
+        String userId = SecurityUtils.getUser().getUserId();
+        IPage<MyOrderDto> myOrderDtoIpage = myOrderService.pageMyOrderByUserIdAndStatus(page, userId, status);
+        return ServerResponseEntity.success(myOrderDtoIpage);
+    }
+
+    /**
+     * 取消订单
+     * @param orderNumber 订单号
+     * @return 服务器响应实体
+     */
+    @PutMapping("/cancel/{orderNumber}")
+    @Operation(summary = "根据订单号取消订单", description = "根据订单号取消订单")
+    @Parameter(name = "orderNumber", description = "订单号", required = true)
+    public ServerResponseEntity<String> cancel(@PathVariable("orderNumber") String orderNumber) {
+        String userId = SecurityUtils.getUser().getUserId();
+        Order order = orderService.getOrderByOrderNumber(orderNumber);
+        if (!Objects.equals(order.getUserId(), userId)) {
+            throw new YamiShopBindException("你没有权限获取该订单信息");
+        }
+        if (!Objects.equals(order.getStatus(), OrderStatus.UNPAY.value())) {
+            throw new YamiShopBindException("订单已支付，无法取消订单");
+        }
+        List<OrderItem> orderItems = orderItemService.getOrderItemsByOrderNumber(orderNumber);
+        order.setOrderItems(orderItems);
+        // 取消订单
+        orderService.cancelOrders(Collections.singletonList(order));
+
+        // 清除缓存
+        for (OrderItem orderItem : orderItems) {
+            productService.removeProductCacheByProdId(orderItem.getProdId());
+            skuService.removeSkuCacheBySkuId(orderItem.getSkuId(), orderItem.getProdId());
+        }
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 确认收货
+     * @param orderNumber 订单号
+     * @return 服务器响应实体
+     */
+    @PutMapping("/receipt/{orderNumber}")
+    @Operation(summary = "根据订单号确认收货", description = "根据订单号确认收货")
+    public ServerResponseEntity<String> receipt(@PathVariable("orderNumber") String orderNumber) {
+        String userId = SecurityUtils.getUser().getUserId();
+        Order order = orderService.getOrderByOrderNumber(orderNumber);
+        if (!Objects.equals(order.getUserId(), userId)) {
+            throw new YamiShopBindException("你没有权限获取该订单信息");
+        }
+        if (!Objects.equals(order.getStatus(), OrderStatus.CONSIGNMENT.value())) {
+            throw new YamiShopBindException("订单未发货，无法确认收货");
+        }
+        List<OrderItem> orderItems = orderItemService.getOrderItemsByOrderNumber(orderNumber);
+        order.setOrderItems(orderItems);
+        // 确认收货
+        orderService.confirmOrder(Collections.singletonList(order));
+
+        for (OrderItem orderItem : orderItems) {
+            productService.removeProductCacheByProdId(orderItem.getProdId());
+            skuService.removeSkuCacheBySkuId(orderItem.getSkuId(), orderItem.getProdId());
+        }
+        return ServerResponseEntity.success();
+    }
+
+    /**
+     * 删除订单
+     * @param orderNumber 订单号
+     * @return 服务器响应实体
+     */
+    @DeleteMapping("/{orderNumber}")
+    @Operation(summary = "根据订单号删除订单", description = "根据订单号删除订单")
+    @Parameter(name = "orderNumber", description = "订单号", required = true)
+    public ServerResponseEntity<String> delete(@PathVariable("orderNumber") String orderNumber) {
+        String userId = SecurityUtils.getUser().getUserId();
+
+        Order order = orderService.getOrderByOrderNumber(orderNumber);
+        if (order == null) {
+            throw new YamiShopBindException("该订单不存在");
+        }
+        if (!Objects.equals(order.getUserId(), userId)) {
+            throw new YamiShopBindException("你没有权限获取该订单信息");
+        }
+        if (!Objects.equals(order.getStatus(), OrderStatus.SUCCESS.value()) && !Objects.equals(order.getStatus(), OrderStatus.CLOSE.value())) {
+            throw new YamiShopBindException("订单未完成或未关闭，无法删除订单");
+        }
+
+        // 删除订单
+        orderService.deleteOrders(Collections.singletonList(order));
+
+        return ServerResponseEntity.success("删除成功");
+    }
+
+    /**
+     * 获取我的订单订单数量
+     */
+    @GetMapping("/orderCount")
+    @Operation(summary = "获取我的订单订单数量", description = "获取我的订单订单数量")
+    public ServerResponseEntity<OrderCountData> getOrderCount() {
+        String userId = SecurityUtils.getUser().getUserId();
+        OrderCountData orderCountMap = orderService.getOrderCount(userId);
+        return ServerResponseEntity.success(orderCountMap);
+    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/OrderController.java

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller; // 定义类所在的包
+
+import cn.hutool.core.collection.CollectionUtil; // 引入Hutool工具类库中的CollectionUtil工具类
+import com.yami.shop.bean.app.dto.*; // 引入各种DTO类
+import com.yami.shop.bean.app.param.OrderParam; // 引入订单参数类
+import com.yami.shop.bean.app.param.OrderShopParam; // 引入订单店铺参数类
+import com.yami.shop.bean.app.param.SubmitOrderParam; // 引入提交订单参数类
+import com.yami.shop.bean.event.ConfirmOrderEvent; // 引入确认订单事件类
+import com.yami.shop.bean.model.Order; // 引入订单模型类
+import com.yami.shop.bean.model.UserAddr; // 引入用户地址模型类
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.util.Arith; // 引入算术工具类
+import com.yami.shop.security.api.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.*; // 引入各种服务类
+import io.swagger.v3.oas.annotations.tags.Tag; // 引入Swagger的Tag注解
+import io.swagger.v3.oas.annotations.Operation; // 引入Swagger的Operation注解
+import cn.hutool.core.bean.BeanUtil; // 引入Hutool工具类库中的BeanUtil工具类
+import org.springframework.beans.factory.annotation.Autowired; // 引入Spring的@Autowired注解
+import org.springframework.context.ApplicationContext; // 引入Spring的ApplicationContext类
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.web.bind.annotation.*; // 引入Spring Web的注解
+
+import jakarta.validation.Valid; // 引入Jakarta Validation的Valid注解
+import java.util.ArrayList; // 引入Java的ArrayList类
+import java.util.List; // 引入Java的List接口
+import java.util.Objects; // 引入Java的Objects工具类
+
+/**
+ * OrderController类，用于管理订单操作，包括生成订单和提交订单等功能。
+ * @作者 lanhai
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/p/order") // 定义请求路径的根地址为/p/order
+@Tag(name = "订单接口") // 给API文档添加标签，描述这个控制器的功能
+public class OrderController {
+
+    @Autowired
+    private OrderService orderService; // 自动注入订单服务类
+    @Autowired
+    private SkuService skuService; // 自动注入SKU服务类
+    @Autowired
+    private ProductService productService; // 自动注入商品服务类
+    @Autowired
+    private UserAddrService userAddrService; // 自动注入用户地址服务类
+    @Autowired
+    private BasketService basketService; // 自动注入购物车服务类
+    @Autowired
+    private ApplicationContext applicationContext; // 自动注入Spring应用上下文
+
+    /**
+     * 生成订单
+     * @param orderParam 订单参数
+     * @return 服务器响应实体，包含生成的订单信息
+     */
+    @PostMapping("/confirm")
+    @Operation(summary = "结算，生成订单信息" , description = "传入下单所需要的参数进行下单")
+    public ServerResponseEntity<ShopCartOrderMergerDto> confirm(@Valid @RequestBody OrderParam orderParam) {
+        String userId = SecurityUtils.getUser().getUserId();
+
+        // 获取订单的地址信息
+        UserAddr userAddr = userAddrService.getUserAddrByUserId(orderParam.getAddrId(), userId);
+        UserAddrDto userAddrDto = BeanUtil.copyProperties(userAddr, UserAddrDto.class);
+
+        // 获取用户提交的购物车商品项
+        List<ShopCartItemDto> shopCartItems = basketService.getShopCartItemsByOrderItems(orderParam.getBasketIds(), orderParam.getOrderItem(), userId);
+        if (CollectionUtil.isEmpty(shopCartItems)) {
+            throw new YamiShopBindException("请选择您需要的商品加入购物车");
+        }
+
+        // 根据店铺组装购物车中的商品信息
+        List<ShopCartDto> shopCarts = basketService.getShopCarts(shopCartItems);
+
+        // 生成完整的订单信息
+        ShopCartOrderMergerDto shopCartOrderMergerDto = new ShopCartOrderMergerDto();
+        shopCartOrderMergerDto.setUserAddr(userAddrDto);
+        List<ShopCartOrderDto> shopCartOrders = new ArrayList<>();
+        double actualTotal = 0.0;
+        double total = 0.0;
+        int totalCount = 0;
+        double orderReduce = 0.0;
+
+        for (ShopCartDto shopCart : shopCarts) {
+            ShopCartOrderDto shopCartOrder = new ShopCartOrderDto();
+            shopCartOrder.setShopId(shopCart.getShopId());
+            shopCartOrder.setShopName(shopCart.getShopName());
+
+            List<ShopCartItemDiscountDto> shopCartItemDiscounts = shopCart.getShopCartItemDiscounts();
+            List<ShopCartItemDto> shopAllShopCartItems = new ArrayList<>();
+            for (ShopCartItemDiscountDto shopCartItemDiscount : shopCartItemDiscounts) {
+                List<ShopCartItemDto> discountShopCartItems = shopCartItemDiscount.getShopCartItems();
+                shopAllShopCartItems.addAll(discountShopCartItems);
+            }
+
+            shopCartOrder.setShopCartItemDiscounts(shopCartItemDiscounts);
+            applicationContext.publishEvent(new ConfirmOrderEvent(shopCartOrder, orderParam, shopAllShopCartItems));
+
+            actualTotal = Arith.add(actualTotal, shopCartOrder.getActualTotal());
+            total = Arith.add(total, shopCartOrder.getTotal());
+            totalCount += shopCartOrder.getTotalCount();
+            orderReduce = Arith.add(orderReduce, shopCartOrder.getShopReduce());
+            shopCartOrders.add(shopCartOrder);
+        }
+
+        shopCartOrderMergerDto.setActualTotal(actualTotal);
+        shopCartOrderMergerDto.setTotal(total);
+        shopCartOrderMergerDto.setTotalCount(totalCount);
+        shopCartOrderMergerDto.setShopCartOrders(shopCartOrders);
+        shopCartOrderMergerDto.setOrderReduce(orderReduce);
+
+        shopCartOrderMergerDto = orderService.putConfirmOrderCache(userId, shopCartOrderMergerDto);
+
+        return ServerResponseEntity.success(shopCartOrderMergerDto);
+    }
+
+    /**
+     * 提交订单，根据店铺拆单
+     * @param submitOrderParam 提交订单参数
+     * @return 服务器响应实体，包含支付流水号
+     */
+    @PostMapping("/submit")
+    @Operation(summary = "提交订单，返回支付流水号" , description = "根据传入的参数判断是否为购物车提交订单，同时对购物车进行删除，用户开始进行支付")
+    public ServerResponseEntity<OrderNumbersDto> submitOrders(@Valid @RequestBody SubmitOrderParam submitOrderParam) {
+        String userId = SecurityUtils.getUser().getUserId();
+        ShopCartOrderMergerDto mergerOrder = orderService.getConfirmOrderCache(userId);
+        if (mergerOrder == null) {
+            throw new YamiShopBindException("订单已过期，请重新下单");
+        }
+
+        List<OrderShopParam> orderShopParams = submitOrderParam.getOrderShopParam();
+        List<ShopCartOrderDto> shopCartOrders = mergerOrder.getShopCartOrders();
+
+        // 设置备注
+        if (CollectionUtil.isNotEmpty(orderShopParams)) {
+            for (ShopCartOrderDto shopCartOrder : shopCartOrders) {
+                for (OrderShopParam orderShopParam : orderShopParams) {
+                    if (Objects.equals(shopCartOrder.getShopId(), orderShopParam.getShopId())) {
+                        shopCartOrder.setRemarks(orderShopParam.getRemarks());
+                    }
+                }
+            }
+        }
+
+        List<Order> orders = orderService.submit(userId, mergerOrder);
+
+        StringBuilder orderNumbers = new StringBuilder();
+        for (Order order : orders) {
+            orderNumbers.append(order.getOrderNumber()).append(",");
+        }
+        orderNumbers.deleteCharAt(orderNumbers.length() - 1);
+
+        boolean isShopCartOrder = false;
+        // 移除缓存
+        for (ShopCartOrderDto shopCartOrder : shopCartOrders) {
+            for (ShopCartItemDiscountDto shopCartItemDiscount : shopCartOrder.getShopCartItemDiscounts()) {
+                for (ShopCartItemDto shopCartItem : shopCartItemDiscount.getShopCartItems()) {
+                    Long basketId = shopCartItem.getBasketId();
+                    if (basketId != null && basketId != 0) {
+                        isShopCartOrder = true;
+                    }
+                    skuService.removeSkuCacheBySkuId(shopCartItem.getSkuId(), shopCartItem.getProdId());
+                    productService.removeProductCacheByProdId(shopCartItem.getProdId());
+                }
+            }
+        }
+        // 购物车提交订单时(即有购物车ID时)
+        if (isShopCartOrder) {
+            basketService.removeShopCartItemsCacheByUserId(userId);
+        }
+        orderService.removeConfirmOrderCache(userId);
+        return ServerResponseEntity.success(new OrderNumbersDto(orderNumbers.toString()));
+    }
+
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/PayController.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller; // 定义类所在的包
+
+import com.yami.shop.bean.app.param.PayParam; // 引入支付参数类
+import com.yami.shop.bean.pay.PayInfoDto; // 引入支付信息DTO类
+import com.yami.shop.security.api.model.YamiUser; // 引入用户模型类
+import com.yami.shop.security.api.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.PayService; // 引入支付服务类
+import io.swagger.v3.oas.annotations.tags.Tag; // 引入Swagger的Tag注解
+import io.swagger.v3.oas.annotations.Operation; // 引入Swagger的Operation注解
+import lombok.AllArgsConstructor; // 引入Lombok的@AllArgsConstructor注解
+import com.yami.shop.common.response.ServerResponseEntity; // 引入服务器响应实体类
+import org.springframework.web.bind.annotation.*; // 引入Spring Web的注解
+
+/**
+ * PayController类，用于处理支付相关的操作。
+ * @作者 lanhai
+ */
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/p/order") // 定义请求路径的根地址为/p/order
+@Tag(name = "订单接口") // 给API文档添加标签，描述这个控制器的功能
+@AllArgsConstructor // 使用Lombok注解生成全参构造函数
+public class PayController {
+
+    private final PayService payService; // 自动注入支付服务类
+
+    /**
+     * 支付接口
+     * @param payParam 支付参数
+     * @return 服务器响应实体
+     */
+    @PostMapping("/pay")
+    @Operation(summary = "根据订单号进行支付", description = "根据订单号进行支付")
+    public ServerResponseEntity<Void> pay(@RequestBody PayParam payParam) {
+        YamiUser user = SecurityUtils.getUser();
+        String userId = user.getUserId();
+
+        PayInfoDto payInfo = payService.pay(userId, payParam); // 调用支付服务进行支付
+        payService.paySuccess(payInfo.getPayNo(), ""); // 调用支付成功处理
+        return ServerResponseEntity.success(); // 返回成功响应
+    }
+
+    /**
+     * 普通支付接口
+     * @param payParam 支付参数
+     * @return 服务器响应实体
+     */
+    @PostMapping("/normalPay")
+    @Operation(summary = "根据订单号进行支付", description = "根据订单号进行支付")
+    public ServerResponseEntity<Boolean> normalPay(@RequestBody PayParam payParam) {
+        YamiUser user = SecurityUtils.getUser();
+        String userId = user.getUserId();
+        PayInfoDto pay = payService.pay(userId, payParam); // 调用支付服务进行支付
+
+        // 根据内部订单号更新订单结算信息
+        payService.paySuccess(pay.getPayNo(), "");
+
+        return ServerResponseEntity.success(true); // 返回成功响应
+    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/controller/PayNoticeController.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.controller; // 定义类所在的包
+
+import lombok.AllArgsConstructor; // 引入Lombok的@AllArgsConstructor注解
+import org.springframework.web.bind.annotation.RequestMapping; // 引入Spring的@RequestMapping注解
+import org.springframework.web.bind.annotation.RestController; // 引入Spring的@RestController注解
+import io.swagger.v3.oas.annotations.Hidden; // 引入Swagger的Hidden注解
+
+/**
+ * PayNoticeController类，用于处理支付通知。
+ * @作者 lanhai
+ */
+@Hidden // 隐藏这个控制器，不在Swagger文档中展示
+@RestController // 标注这是一个控制器类，并且其返回结果直接写入HTTP响应体中，而不是视图名称
+@RequestMapping("/notice/pay") // 定义请求路径的根地址为/notice/pay
+@AllArgsConstructor // 使用Lombok注解生成全参构造函数
+public class PayNoticeController {
+// 模拟支付不需要回调
+//    /**
+//     * 小程序支付
+//     */
+//    private final WxPayService wxMiniPayService;
+//
+//    private final PayService payService;
+//
+//    @RequestMapping("/order")
+//    public ServerResponseEntity<Void> submit(@RequestBody String xmlData) throws WxPayException {
+//        WxPayOrderNotifyResult parseOrderNotifyResult = wxMiniPayService.parseOrderNotifyResult(xmlData);
+//
+//        String payNo = parseOrderNotifyResult.getOutTradeNo();
+//        String bizPayNo = parseOrderNotifyResult.getTransactionId();
+//
+//        // 根据内部订单号更新order settlement
+//        payService.paySuccess(payNo, bizPayNo);
+//
+//        return ServerResponseEntity.success();
+//    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/listener/ConfirmOrderListener.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.listener; // 定义类所在的包
+
+import com.yami.shop.bean.app.dto.ShopCartItemDto; // 引入购物车项目DTO
+import com.yami.shop.bean.app.dto.ShopCartOrderDto; // 引入购物车订单DTO
+import com.yami.shop.bean.app.param.OrderParam; // 引入订单参数
+import com.yami.shop.bean.event.ConfirmOrderEvent; // 引入确认订单事件
+import com.yami.shop.bean.model.Product; // 引入商品模型
+import com.yami.shop.bean.model.Sku; // 引入SKU模型
+import com.yami.shop.bean.model.UserAddr; // 引入用户地址模型
+import com.yami.shop.bean.order.ConfirmOrderOrder; // 引入确认订单顺序
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.util.Arith; // 引入算术工具类
+import com.yami.shop.security.api.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.ProductService; // 引入商品服务类
+import com.yami.shop.service.SkuService; // 引入SKU服务类
+import com.yami.shop.service.TransportManagerService; // 引入运输管理服务类
+import com.yami.shop.service.UserAddrService; // 引入用户地址服务类
+import lombok.AllArgsConstructor; // 引入Lombok的@AllArgsConstructor注解
+import org.springframework.context.event.EventListener; // 引入Spring的事件监听注解
+import org.springframework.core.annotation.Order; // 引入Spring的Order注解
+import org.springframework.stereotype.Component; // 引入Spring的Component注解
+
+/**
+ * 确认订单信息时的默认操作
+ * ConfirmOrderListener类处理确认订单时的默认操作，包括计算订单金额、商品检查和运费计算等。
+ * @作者 LGH
+ */
+@Component("defaultConfirmOrderListener") // 标注这是一个Spring组件，并且以defaultConfirmOrderListener为组件名称
+@AllArgsConstructor // 使用Lombok注解生成全参构造函数
+public class ConfirmOrderListener {
+
+    private final UserAddrService userAddrService; // 自动注入用户地址服务类
+
+    private final TransportManagerService transportManagerService; // 自动注入运输管理服务类
+
+    private final ProductService productService; // 自动注入商品服务类
+
+    private final SkuService skuService; // 自动注入SKU服务类
+
+    /**
+     * 计算订单金额
+     * @param event 确认订单事件
+     */
+    @EventListener(ConfirmOrderEvent.class) // 标注这是一个事件监听器，监听ConfirmOrderEvent事件
+    @Order(ConfirmOrderOrder.DEFAULT) // 设置事件监听的顺序
+    public void defaultConfirmOrderEvent(ConfirmOrderEvent event) {
+
+        ShopCartOrderDto shopCartOrderDto = event.getShopCartOrderDto(); // 获取购物车订单DTO
+
+        OrderParam orderParam = event.getOrderParam(); // 获取订单参数
+
+        String userId = SecurityUtils.getUser().getUserId(); // 获取当前用户ID
+
+        // 订单的地址信息
+        UserAddr userAddr = userAddrService.getUserAddrByUserId(orderParam.getAddrId(), userId);
+
+        double total = 0.0; // 总金额
+
+        int totalCount = 0; // 总商品数量
+
+        double transfee = 0.0; // 总运费
+
+        for (ShopCartItemDto shopCartItem : event.getShopCartItems()) {
+            // 获取商品信息
+            Product product = productService.getProductByProdId(shopCartItem.getProdId());
+            // 获取sku信息
+            Sku sku = skuService.getSkuBySkuId(shopCartItem.getSkuId());
+            if (product == null || sku == null) {
+                throw new YamiShopBindException("购物车包含无法识别的商品"); // 商品或SKU为空，抛出异常
+            }
+            if (product.getStatus() != 1 || sku.getStatus() != 1) {
+                throw new YamiShopBindException("商品[" + sku.getProdName() + "]已下架"); // 商品或SKU已下架，抛出异常
+            }
+
+            totalCount = shopCartItem.getProdCount() + totalCount; // 累加商品数量
+            total = Arith.add(shopCartItem.getProductTotalAmount(), total); // 累加商品总金额
+            // 用户地址如果为空，则表示该用户从未设置过任何地址相关信息
+            if (userAddr != null) {
+                // 每个产品的运费相加
+                transfee = Arith.add(transfee, transportManagerService.calculateTransfee(shopCartItem, userAddr));
+            }
+
+            shopCartItem.setActualTotal(shopCartItem.getProductTotalAmount()); // 设置实际总金额
+            shopCartOrderDto.setActualTotal(Arith.add(total, transfee)); // 设置订单实际总金额
+            shopCartOrderDto.setTotal(total); // 设置订单总金额
+            shopCartOrderDto.setTotalCount(totalCount); // 设置订单总商品数量
+            shopCartOrderDto.setTransfee(transfee); // 设置订单总运费
+        }
+    }
+}

yami-shop-api/src/main/java/com/yami/shop/api/listener/SubmitOrderListener.java

@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.api.listener; // 定义类所在的包
+
+import cn.hutool.core.lang.Snowflake; // 引入Hutool工具类库中的Snowflake工具类
+import cn.hutool.core.util.StrUtil; // 引入Hutool工具类库中的StrUtil工具类
+import com.yami.shop.bean.app.dto.*; // 引入各种DTO类
+import com.yami.shop.bean.enums.OrderStatus; // 引入订单状态枚举类
+import com.yami.shop.bean.event.SubmitOrderEvent; // 引入提交订单事件类
+import com.yami.shop.bean.model.*; // 引入各种模型类
+import com.yami.shop.bean.order.SubmitOrderOrder; // 引入提交订单顺序类
+import com.yami.shop.common.constants.Constant; // 引入常量类
+import com.yami.shop.common.exception.YamiShopBindException; // 引入自定义异常类
+import com.yami.shop.common.util.Arith; // 引入算术工具类
+import com.yami.shop.dao.*; // 引入各种数据访问对象
+import com.yami.shop.security.api.util.SecurityUtils; // 引入安全工具类
+import com.yami.shop.service.*; // 引入各种服务类
+import lombok.AllArgsConstructor; // 引入Lombok的@AllArgsConstructor注解
+import cn.hutool.core.bean.BeanUtil; // 引入Hutool工具类库中的BeanUtil工具类
+import org.springframework.context.event.EventListener; // 引入Spring的EventListener注解
+import org.springframework.core.annotation.Order; // 引入Spring的Order注解
+import org.springframework.stereotype.Component; // 引入Spring的Component注解
+
+import java.util.*; // 引入Java的各种集合类
+
+/**
+ * 确认订单信息时的默认操作
+ * 该类包含处理提交订单事件的逻辑，包括订单的创建和库存的更新。
+ * @作者 LGH
+ */
+@Component("defaultSubmitOrderListener") // 标注这是一个Spring组件，并且以defaultSubmitOrderListener为组件名称
+@AllArgsConstructor // 使用Lombok注解生成全参构造函数
+public class SubmitOrderListener {
+
+    private final UserAddrOrderService userAddrOrderService; // 自动注入用户地址订单服务类
+    private final ProductService productService; // 自动注入商品服务类
+    private final SkuService skuService; // 自动注入SKU服务类
+    private final Snowflake snowflake; // 自动注入雪花算法实例
+    private final OrderItemMapper orderItemMapper; // 自动注入订单项数据访问对象
+    private final SkuMapper skuMapper; // 自动注入SKU数据访问对象
+    private final ProductMapper productMapper; // 自动注入商品数据访问对象
+    private final OrderMapper orderMapper; // 自动注入订单数据访问对象
+    private final OrderSettlementMapper orderSettlementMapper; // 自动注入订单结算数据访问对象
+    private final BasketMapper basketMapper; // 自动注入购物车数据访问对象
+
+    /**
+     * 计算订单金额
+     * @param event 提交订单事件
+     */
+    @EventListener(SubmitOrderEvent.class)
+    @Order(SubmitOrderOrder.DEFAULT)
+    public void defaultSubmitOrderListener(SubmitOrderEvent event) {
+        Date now = new Date();
+        String userId = SecurityUtils.getUser().getUserId();
+
+        ShopCartOrderMergerDto mergerOrder = event.getMergerOrder();
+
+        // 订单商品参数
+        List<ShopCartOrderDto> shopCartOrders = mergerOrder.getShopCartOrders();
+
+        List<Long> basketIds = new ArrayList<>();
+        // 商品skuId为key，需要更新的sku为value的map
+        Map<Long, Sku> skuStocksMap = new HashMap<>(16);
+        // 商品productId为key，需要更新的product为value的map
+        Map<Long, Product> prodStocksMap = new HashMap<>(16);
+
+        // 把订单地址保存到数据库
+        UserAddrOrder userAddrOrder = BeanUtil.copyProperties(mergerOrder.getUserAddr(), UserAddrOrder.class);
+        if (userAddrOrder == null) {
+            throw new YamiShopBindException("请填写收货地址");
+        }
+        userAddrOrder.setUserId(userId);
+        userAddrOrder.setCreateTime(now);
+        userAddrOrderService.save(userAddrOrder);
+
+        // 订单地址id
+        Long addrOrderId = userAddrOrder.getAddrOrderId();
+
+        // 每个店铺生成一个订单
+        for (ShopCartOrderDto shopCartOrderDto : shopCartOrders) {
+            createOrder(event, now, userId, basketIds, skuStocksMap, prodStocksMap, addrOrderId, shopCartOrderDto);
+        }
+
+        // 删除购物车的商品信息
+        if (!basketIds.isEmpty()) {
+            basketMapper.deleteShopCartItemsByBasketIds(userId, basketIds);
+        }
+
+        // 更新sku库存
+        skuStocksMap.forEach((key, sku) -> {
+            if (skuMapper.updateStocks(sku) == 0) {
+                skuService.removeSkuCacheBySkuId(key, sku.getProdId());
+                throw new YamiShopBindException("商品：[" + sku.getProdName() + "]库存不足");
+            }
+        });
+
+        // 更新商品库存
+        prodStocksMap.forEach((prodId, prod) -> {
+            if (productMapper.updateStocks(prod) == 0) {
+                productService.removeProductCacheByProdId(prodId);
+                throw new YamiShopBindException("商品：[" + prod.getProdName() + "]库存不足");
+            }
+        });
+    }
+
+    private void createOrder(SubmitOrderEvent event, Date now, String userId, List<Long> basketIds, Map<Long, Sku> skuStocksMap, Map<Long, Product> prodStocksMap, Long addrOrderId, ShopCartOrderDto shopCartOrderDto) {
+        // 使用雪花算法生成的订单号
+        String orderNumber = String.valueOf(snowflake.nextId());
+        shopCartOrderDto.setOrderNumber(orderNumber);
+
+        Long shopId = shopCartOrderDto.getShopId();
+
+        // 订单商品名称
+        StringBuilder orderProdName = new StringBuilder(100);
+
+        List<OrderItem> orderItems = new ArrayList<>();
+
+        List<ShopCartItemDiscountDto> shopCartItemDiscounts = shopCartOrderDto.getShopCartItemDiscounts();
+        for (ShopCartItemDiscountDto shopCartItemDiscount : shopCartItemDiscounts) {
+            List<ShopCartItemDto> shopCartItems = shopCartItemDiscount.getShopCartItems();
+            for (ShopCartItemDto shopCartItem : shopCartItems) {
+                Sku sku = checkAndGetSku(shopCartItem.getSkuId(), shopCartItem, skuStocksMap);
+                Product product = checkAndGetProd(shopCartItem.getProdId(), shopCartItem, prodStocksMap);
+
+                OrderItem orderItem = getOrderItem(now, userId, orderNumber, shopId, orderProdName, shopCartItem, sku, product);
+
+                orderItems.add(orderItem);
+
+                if (shopCartItem.getBasketId() != null && shopCartItem.getBasketId() != 0) {
+                    basketIds.add(shopCartItem.getBasketId());
+                }
+            }
+        }
+
+        orderProdName.subSequence(0, Math.min(orderProdName.length() - 1, 100));
+        if (orderProdName.lastIndexOf(Constant.COMMA) == orderProdName.length() - 1) {
+            orderProdName.deleteCharAt(orderProdName.length() - 1);
+        }
+
+        // 订单信息
+        com.yami.shop.bean.model.Order order = getOrder(now, userId, addrOrderId, shopCartOrderDto, orderNumber, shopId, orderProdName, orderItems);
+        event.getOrders().add(order);
+        // 插入订单结算表
+        OrderSettlement orderSettlement = new OrderSettlement();
+        orderSettlement.setUserId(userId);
+        orderSettlement.setIsClearing(0);
+        orderSettlement.setCreateTime(now);
+        orderSettlement.setOrderNumber(orderNumber);
+        orderSettlement.setPayAmount(order.getActualTotal());
+        orderSettlement.setPayStatus(0);
+        orderSettlement.setVersion(0);
+        orderSettlementMapper.insert(orderSettlement);
+    }
+
+    private com.yami.shop.bean.model.Order getOrder(Date now, String userId, Long addrOrderId, ShopCartOrderDto shopCartOrderDto, String orderNumber, Long shopId, StringBuilder orderProdName, List<OrderItem> orderItems) {
+        com.yami.shop.bean.model.Order order = new com.yami.shop.bean.model.Order();
+
+        order.setShopId(shopId);
+        order.setOrderNumber(orderNumber);
+        order.setProdName(orderProdName.toString()); // 订单商品名称
+        order.setUserId(userId); // 用户ID
+        order.setTotal(shopCartOrderDto.getTotal()); // 商品总额
+        order.setActualTotal(shopCartOrderDto.getActualTotal()); // 实际总额
+        order.setStatus(OrderStatus.UNPAY.value()); // 订单状态为未支付
+        order.setUpdateTime(now);
+        order.setCreateTime(now);
+        order.setIsPayed(0);
+        order.setDeleteStatus(0);
+        order.setProductNums(shopCartOrderDto.getTotalCount());
+        order.setAddrOrderId(addrOrderId);
+        order.setReduceAmount(Arith.sub(Arith.add(shopCartOrderDto.getTotal(), shopCartOrderDto.getTransfee()), shopCartOrderDto.getActualTotal()));
+        order.setFreightAmount(shopCartOrderDto.getTransfee());
+        order.setRemarks(shopCartOrderDto.getRemarks());
+
+        order.setOrderItems(orderItems);
+        return order;
+    }
+
+    private OrderItem getOrderItem(Date now, String userId, String orderNumber, Long shopId, StringBuilder orderProdName, ShopCartItemDto shopCartItem, Sku sku, Product product) {
+        OrderItem orderItem = new OrderItem();
+        orderItem.setShopId(shopId);
+        orderItem.setOrderNumber(orderNumber);
+        orderItem.setProdId(sku.getProdId());
+        orderItem.setSkuId(sku.getSkuId());
+        orderItem.setSkuName(sku.getSkuName());
+        orderItem.setProdCount(shopCartItem.getProdCount());
+        orderItem.setProdName(sku.getProdName());
+        orderItem.setPic(StrUtil.isBlank(sku.getPic()) ? product.getPic() : sku.getPic());
+        orderItem.setPrice(shopCartItem.getPrice());
+        orderItem.setUserId(userId);
+        orderItem.setProductTotalAmount(shopCartItem.getProductTotalAmount());
+        orderItem.setRecTime(now);
+        orderItem.setCommSts(0);
+        orderItem.setBasketDate(shopCartItem.getBasketDate());
+        orderProdName.append(orderItem.getProdName()).append(",");
+        //推广员卡号
+        orderItem.setDistributionCardNo(shopCartItem.getDistributionCardNo());
+        return orderItem;
+    }
+
+    @SuppressWarnings({"Duplicates"})
+    private Product checkAndGetProd(Long prodId, ShopCartItemDto shopCartItem, Map<Long, Product> prodStocksMap) {
+        Product product = productService.getProductByProdId(prodId);
+        if (product == null) {
+            throw new YamiShopBindException("购物车包含无法识别的商品");
+        }
+
+        if (product.getStatus() != 1) {
+            throw new YamiShopBindException("商品[" + product.getProdName() + "]已下架");
+        }
+
+        // 商品需要改变的库存
+        Product mapProduct = prodStocksMap.get(prodId);
+
+        if (mapProduct == null) {
+            mapProduct = new Product();
+            mapProduct.setTotalStocks(0);
+            mapProduct.setProdId(prodId);
+            mapProduct.setProdName(product.getProdName());
+        }
+
+        if (product.getTotalStocks() != -1) {
+            mapProduct.setTotalStocks(mapProduct.getTotalStocks() + shopCartItem.getProdCount());
+            prodStocksMap.put(product.getProdId(), mapProduct);
+        }
+
+        // -1为无限库存
+        if (product.getTotalStocks() != -1 && mapProduct.getTotalStocks() > product.getTotalStocks()) {
+            throw new YamiShopBindException("商品：[" + product.getProdName() + "]库存不足");
+        }
+
+        return product;
+    }
+
+    @SuppressWarnings({"Duplicates"})
+    private Sku checkAndGetSku(Long skuId, ShopCartItemDto shopCartItem, Map<Long, Sku> skuStocksMap) {
+        // 获取sku信息
+        Sku sku = skuService.getSkuBySkuId(skuId);
+        if (sku == null) {
+            throw new YamiShopBindException("购物车包含无法识别的商品");
+        }
+
+        if (sku.getStatus() != 1) {
+            throw new YamiShopBindException("商品[" + sku.getProdName() + "]已下架");
+        }
+        // -1为无限库存
+        if (sku.getStocks() != -1 && shopCartItem.getProdCount() > sku.getStocks()) {
+            throw new YamiShopBindException("商品：[" + sku.getProdName() + "]库存不足");
+        }
+
+        if (sku.getStocks() != -1) {
+            Sku mapSku = new Sku();
+            mapSku.setProdId(sku.getProdId());
+            // 这里的库存是改变的库存
+            mapSku.setStocks(shopCartItem.getProdCount());
+            mapSku.setSkuId(sku.getSkuId());
+            mapSku.setProdName(sku.getProdName());
+            skuStocksMap.put(sku.getSkuId(), mapSku);
+        }
+        return sku;
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/bean/AliDaYu.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.bean;
+// 导入lombok的Data注解，使用该注解可以自动生成类的一些常规方法，比如getter、setter、toString等方法，简化代码编写
+import lombok.Data;
+
+/**
+ * 阿里大鱼配置信息
+ * 这个类用于存放与阿里大鱼相关的配置信息，比如访问密钥ID、访问密钥密码以及签名名称等。
+ * 通过这个类可以方便地对阿里大鱼相关配置进行统一管理和传递。
+ * @author LGH
+ */
+@Data
+// 定义名为AliDaYu的公共类，用于封装阿里大鱼配置相关的属性
+public class AliDaYu {
+	// 以下是类的私有属性，用于存储具体的配置信息
+
+	// 用于存储阿里大鱼的访问密钥ID，通过该ID来标识访问阿里大鱼服务的身份凭证之一
+	private String accessKeyId;
+
+	// 用于存储阿里大鱼的访问密钥密码，与访问密钥ID配合使用，用于进行安全验证等操作，确保对阿里大鱼服务的合法访问
+	private String accessKeySecret;
+
+	// 用于存储阿里大鱼的签名名称，在涉及到一些需要签名验证的业务场景中会用到该名称
+	private String signName;
+}

yami-shop-common/src/main/java/com/yami/shop/common/bean/ImgUpload.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.bean;
+
+// 引入Lombok的Data注解，通过该注解，编译器会自动帮我们生成类的常用方法，
+// 比如各属性的Getter、Setter方法，以及toString、equals、hashCode方法等，简化代码编写
+import lombok.Data;
+
+/**
+ * ImgUpload类用于封装本地存储相关的配置信息，主要包含了本地文件上传过程中涉及到的关键配置项，
+ * 方便在项目中统一管理和获取这些配置，以根据不同的配置情况来执行相应的文件上传逻辑，例如选择本地上传还是使用七牛云等外部存储服务上传。
+ *
+ * @author lgh
+ */
+@Data
+public class ImgUpload {
+
+	/**
+	 * 用于指定本地文件上传时，文件存储的文件夹路径，
+	 * 通过设置该属性，可以明确文件上传后在本地服务器存储的具体位置，便于后续的文件管理和访问操作。
+	 */
+	private String imagePath;
+
+	/**
+	 * 用于标识文件上传的方式，是一个整数类型的枚举值（这里虽然没用枚举类严格定义，但约定了取值的含义），
+	 * 取值为1时表示采用本地文件上传方式，也就是将文件存储到由imagePath指定的本地文件夹中；
+	 * 取值为2时表示使用七牛云存储服务进行文件上传，此时会结合其他相关配置与七牛云进行交互来完成上传操作。
+	 */
+	private Integer uploadType;
+
+	/**
+	 * 用于指定网站相关资源的访问URL，在文件上传的场景下，可能用于构建完整的文件访问链接，
+	 * 比如当通过某种方式获取到文件在本地或者云端存储的相对路径后，结合该resourceUrl就能生成完整的可访问的文件URL，提供给前端等进行访问展示。
+	 */
+	private String resourceUrl;
+}

yami-shop-common/src/main/java/com/yami/shop/common/config/DefaultExceptionHandlerConfig.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.config;
+
+// 导入相关的自定义异常类、响应相关的枚举、响应实体类等
+import com.yami.shop.common.exception.YamiShopBindException;
+import com.yami.shop.common.response.ResponseEnum;
+import com.yami.shop.common.response.ServerResponseEntity;
+// 导入日志相关的Lombok注解，用于简化日志记录代码
+import lombok.extern.slf4j.Slf4j;
+// 导入Spring的HTTP状态码相关枚举类
+import org.springframework.http.HttpStatus;
+// 导入Spring用于构建HTTP响应实体的类
+import org.springframework.http.ResponseEntity;
+// 导入Spring用于标记控制器类的注解（此处结合异常处理相关特性使用）
+import org.springframework.stereotype.Controller;
+// 导入Spring在数据校验场景下的异常类以及表示字段错误的类
+import org.springframework.validation.BindException;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+// 导入Spring用于定义异常处理方法的注解以及标记全局异常处理类的注解
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+// 导入Spring用于处理资源未找到异常的类
+import org.springframework.web.servlet.resource.NoResourceFoundException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 自定义错误处理器，用于统一处理项目中的各类异常情况，
+ * 并将异常信息按照一定格式封装到响应实体中返回给客户端。
+ * @author LGH
+ */
+@Slf4j
+@Controller
+@RestControllerAdvice
+public class DefaultExceptionHandlerConfig {
+
+    /**
+     * 处理MethodArgumentNotValidException和BindException这两种参数校验相关异常的方法。
+     * 当在Spring的参数校验过程中出现这两种异常时，会进入此方法进行处理，
+     * 将异常中的字段错误信息提取出来，封装到响应实体中返回给客户端。
+     *
+     * @param e 捕获到的异常对象，可能是MethodArgumentNotValidException或者BindException类型
+     * @return ResponseEntity<ServerResponseEntity<List<String>>> 包含了处理后的响应实体的HTTP响应实体，
+     * 响应实体中包含了参数校验失败的具体字段错误信息列表（如果有）以及对应的响应状态等信息。
+     */
+    @ExceptionHandler({ MethodArgumentNotValidException.class, BindException.class })
+    public ResponseEntity<ServerResponseEntity<List<String>>> methodArgumentNotValidExceptionHandler(Exception e) {
+        // 记录异常信息，方便后续查看出现异常的具体情况，用于调试和问题排查
+        log.error("methodArgumentNotValidExceptionHandler", e);
+        List<FieldError> fieldErrors = null;
+        // 判断异常类型是否是MethodArgumentNotValidException，如果是则获取对应的字段错误列表
+        if (e instanceof MethodArgumentNotValidException) {
+            fieldErrors = ((MethodArgumentNotValidException) e).getBindingResult().getFieldErrors();
+        }
+        // 判断异常类型是否是BindException，如果是则获取对应的字段错误列表
+        if (e instanceof BindException) {
+            fieldErrors = ((BindException) e).getBindingResult().getFieldErrors();
+        }
+        // 如果没有获取到字段错误列表（可能出现不符合预期的异常情况等）
+        if (fieldErrors == null) {
+            // 返回一个包含特定失败响应枚举（表示参数校验不通过）的响应实体，没有具体字段错误信息
+            return ResponseEntity.status(HttpStatus.OK)
+                    .body(ServerResponseEntity.fail(ResponseEnum.METHOD_ARGUMENT_NOT_VALID));
+        }
+
+        // 用于存放每个字段的错误信息字符串（格式为：字段名:默认错误消息）
+        List<String> defaultMessages = new ArrayList<>(fieldErrors.size());
+        // 遍历字段错误列表，拼接每个字段的错误信息字符串并添加到defaultMessages列表中
+        for (FieldError fieldError : fieldErrors) {
+            defaultMessages.add(fieldError.getField() + ":" + fieldError.getDefaultMessage());
+        }
+        // 返回一个包含具体字段错误信息列表的失败响应实体，使用参数校验不通过的响应枚举标识
+        return ResponseEntity.status(HttpStatus.OK)
+                .body(ServerResponseEntity.fail(ResponseEnum.METHOD_ARGUMENT_NOT_VALID, defaultMessages));
+    }
+
+    /**
+     * 处理YamiShopBindException这种自定义异常的方法。
+     * 当项目中抛出YamiShopBindException异常时，会进入此方法进行处理，
+     * 根据异常中封装的响应实体（如果有）或者异常本身的错误码和错误消息构建响应实体返回给客户端。
+     *
+     * @param e 捕获到的YamiShopBindException异常对象
+     * @return ResponseEntity<ServerResponseEntity<?>> 包含了处理后的响应实体的HTTP响应实体，
+     * 响应实体中包含了对应业务逻辑异常的相关信息以及响应状态等。
+     */
+    @ExceptionHandler(YamiShopBindException.class)
+    public ResponseEntity<ServerResponseEntity<?>> unauthorizedExceptionHandler(YamiShopBindException e){
+        // 记录异常信息，方便后续排查问题，了解异常出现的具体情况
+        log.error("mall4jExceptionHandler", e);
+
+        ServerResponseEntity<?> serverResponseEntity = e.getServerResponseEntity();
+        // 如果异常中已经封装好了响应实体（在抛出异常时可能已经构建好了特定的响应内容）
+        if (serverResponseEntity!=null) {
+            // 直接将其作为响应内容返回给客户端，设置状态码为OK
+            return ResponseEntity.status(HttpStatus.OK).body(serverResponseEntity);
+        }
+        // 失败返回消息，状态码固定为直接显示消息的状态码，根据异常的错误码和错误消息构建失败响应实体并返回
+        return ResponseEntity.status(HttpStatus.OK).body(ServerResponseEntity.fail(e.getCode(),e.getMessage()));
+    }
+
+    /**
+     * 兜底的异常处理方法，处理所有未被其他异常处理方法处理的Exception类型异常。
+     * 对于不同类型的通用异常进行相应处理，如资源未找到异常返回特定消息的响应实体，
+     * 其他异常则返回默认的异常响应实体告知客户端出现了未预期的异常情况。
+     *
+     * @param e 捕获到的异常对象，是Exception类型
+     * @return ResponseEntity<ServerResponseEntity<Object>> 包含了处理后的响应实体的HTTP响应实体，
+     * 响应实体中包含了对应异常的相关信息以及响应状态等。
+     */
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ServerResponseEntity<Object>> exceptionHandler(Exception e){
+        // 判断异常是否是资源未找到异常类型
+        if (e instanceof NoResourceFoundException) {
+            // 如果是，则返回一个包含异常消息的失败响应实体，告知客户端资源未找到相关错误信息，状态码设为OK
+            return ResponseEntity.status(HttpStatus.OK).body(ServerResponseEntity.showFailMsg(e.getMessage()));
+        }
+        // 记录异常信息，方便后续排查问题，知道出现异常的具体情况
+        log.error("exceptionHandler", e);
+        // 返回一个使用默认的异常响应枚举构建的失败响应实体，告知客户端出现了未预期的通用异常情况
+        return ResponseEntity.status(HttpStatus.OK).body(ServerResponseEntity.fail(ResponseEnum.EXCEPTION));
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/config/FileUploadConfig.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.config;
+
+// 导入相关的自定义类，可能用于存储图片上传相关的配置、枚举等信息
+import com.yami.shop.common.bean.ImgUpload;
+import com.yami.shop.common.enums.QiniuZone;
+// 导入Spring的注解相关类，用于实现依赖注入和配置相关功能
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+// 导入七牛云相关的类，用于与七牛云存储服务进行交互，涉及区域、上传管理、认证等功能
+import com.qiniu.common.Zone;
+import com.qiniu.storage.BucketManager;
+import com.qiniu.storage.UploadManager;
+import com.qiniu.util.Auth;
+import com.yami.shop.common.bean.Qiniu;
+
+import java.util.Objects;
+
+/**
+ * 文件上传配置类，主要用于整合七牛云存储相关的配置与实例创建，
+ * 通过依赖注入获取配置信息，并根据配置来构建七牛云存储操作所需的各种实例，
+ * 如存储配置、上传管理实例、认证实例以及空间管理实例等，方便在项目中进行文件上传等操作。
+ * @author lgh
+ */
+@Configuration
+public class FileUploadConfig {
+
+    // 通过Spring的依赖注入，获取Qiniu类型的配置对象，该对象应该包含了七牛云相关的配置信息，如密钥、机房区域等
+    @Autowired
+    private Qiniu qiniu;
+
+    /**
+     * 根据配置文件选择机房，创建七牛云存储的配置实例（com.qiniu.storage.Configuration）。
+     * 会根据注入的Qiniu对象中的机房区域配置（QiniuZone枚举类型）来确定对应的七牛云机房区域（Zone），
+     * 并以此构建七牛云存储配置实例，该实例后续会被其他七牛云相关操作的实例所使用。
+     *
+     * @return com.qiniu.storage.Configuration 返回构建好的七牛云存储配置实例，包含了指定的机房区域信息。
+     */
+    @Bean
+    public com.qiniu.storage.Configuration qiniuConfig() {
+        Zone zone = null;
+        // 判断配置中的机房区域是否为华北区，如果是则设置对应的七牛云机房区域为华北区（Zone.huabei()）
+        if (Objects.equals(qiniu.getZone(), QiniuZone.HUA_BEI)) {
+            zone = Zone.huabei();
+        }
+        // 判断是否为华东区，若是则设置对应的七牛云机房区域为华东区（Zone.huadong()）
+        else if (Objects.equals(qiniu.getZone(), QiniuZone.HUA_DONG)) {
+            zone = Zone.huadong();
+        }
+        // 判断是否为华南区，若是则设置对应的七牛云机房区域为华南区（Zone.huanan()）
+        else if (Objects.equals(qiniu.getZone(), QiniuZone.HUA_NAN)) {
+            zone = Zone.huanan();
+        }
+        // 判断是否为北美区，若是则设置对应的七牛云机房区域为北美区（Zone.beimei()）
+        else if (Objects.equals(qiniu.getZone(), QiniuZone.BEI_MEI)) {
+            zone = Zone.beimei();
+        }
+        // 判断是否为新加坡区，若是则设置对应的七牛云机房区域为新加坡区（Zone.xinjiapo()）
+        else if (Objects.equals(qiniu.getZone(), QiniuZone.XIN_JIA_PO)) {
+            zone = Zone.xinjiapo();
+        }
+        // 使用确定好的机房区域（zone）构建七牛云存储配置实例并返回
+        return new com.qiniu.storage.Configuration(zone);
+    }
+
+    /**
+     * 构建一个七牛上传工具实例（UploadManager），
+     * 该实例依赖于前面创建的七牛云存储配置实例（qiniuConfig方法创建的com.qiniu.storage.Configuration实例），
+     * 用于在项目中执行文件上传到七牛云存储的操作。
+     *
+     * @return UploadManager 返回构建好的七牛上传工具实例，可用于文件上传操作。
+     */
+    @Bean
+    public UploadManager uploadManager() {
+        return new UploadManager(qiniuConfig());
+    }
+
+    /**
+     * 构建七牛云认证信息实例（Auth），
+     * 通过获取注入的Qiniu对象中的访问密钥（accessKey）和秘密密钥（secretKey）来创建认证实例，
+     * 该认证实例在后续与七牛云服务进行交互时（如上传、管理空间等操作）用于验证身份，确保操作的合法性。
+     *
+     * @return Auth 返回构建好的七牛云认证信息实例，包含了访问密钥和秘密密钥信息用于认证。
+     */
+    @Bean
+    public Auth auth() {
+        return Auth.create(qiniu.getAccessKey(), qiniu.getSecretKey());
+    }
+
+    /**
+     * 构建七牛空间管理实例（BucketManager），
+     * 该实例依赖于前面创建的认证信息实例（auth方法创建的Auth实例）和七牛云存储配置实例（qiniuConfig方法创建的实例），
+     * 用于在七牛云存储中进行空间相关的管理操作，比如查看、删除、移动文件等操作。
+     *
+     * @return BucketManager 返回构建好的七牛空间管理实例，可用于七牛云存储空间的管理操作。
+     */
+    @Bean
+    public BucketManager bucketManager() {
+        return new BucketManager(auth(), qiniuConfig());
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/constants/Constant.java

@@ -0,0 +1,26 @@
+package com.yami.shop.common.constants;
+
+/**
+ * Constant类用于集中定义项目中常用的一些常量。
+ * 将常量统一放在此类中进行管理，有助于提高代码的可维护性和可读性，
+ * 方便在项目的不同地方引用这些常量，避免了硬编码具体的值，
+ * 当需要修改常量的值时，只需在此类中进行更改即可，减少了代码改动的范围。
+ *
+ * @author TRACK
+ */
+public class Constant {
+
+    /**
+     * PERIOD常量用于表示句号（英文符号）。
+     * 在需要使用英文句号的场景中（例如文件路径的拼接、字符串格式的规范等情况），
+     * 可以直接引用此常量，确保整个项目中对于英文句号的使用保持一致性。
+     */
+    public static final String PERIOD = ".";
+
+    /**
+     * COMMA常量用于表示逗号。
+     * 常用于在构造需要以逗号分隔的字符串（比如CSV格式的数据组装、多个元素的列举表示等场景），
+     * 或者在解析以逗号分隔的字符串时作为分隔标识等操作中，方便统一使用逗号的表示形式。
+     */
+    public static final String COMMA = ",";
+}

yami-shop-common/src/main/java/com/yami/shop/common/handler/HttpHandler.java

@@ -0,0 +1,131 @@
+package com.yami.shop.common.handler;
+
+// 导入 Hutool 工具库中处理字符集相关的工具类，用于设置响应的字符编码
+import cn.hutool.core.util.CharsetUtil;
+// 导入 Jackson 库中用于将对象转换为 JSON 字符串以及反序列化等操作的核心类
+import com.fasterxml.jackson.databind.ObjectMapper;
+// 导入自定义的业务异常类，可能在项目中用于处理特定业务逻辑出错的情况
+import com.yami.shop.common.exception.YamiShopBindException;
+// 导入自定义的用于封装服务器响应信息的实体类，包含响应状态码、消息、数据等内容
+import com.yami.shop.common.response.ServerResponseEntity;
+// 导入 Slf4j 框架的日志记录相关类，用于创建日志记录器来记录不同情况的日志信息
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+// 导入 Spring 框架用于实现依赖注入的注解，表明某个属性需要由 Spring 容器进行注入
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入 Spring 框架中定义媒体类型的枚举类，用于设置响应的内容类型为 JSON 格式
+import org.springframework.http.MediaType;
+// 导入 Spring 框架用于将类标记为组件的注解，表明该类是一个 Spring 管理的组件，可被自动扫描并注入到其他需要的地方
+import org.springframework.stereotype.Component;
+// 导入 Spring 框架中用于获取请求上下文相关信息的类和接口
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+// 导入 Servlet 相关的用于操作 HTTP 响应的类，用于设置响应的各种属性以及向客户端输出内容
+import jakarta.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Objects;
+
+/**
+ * HttpHandler 类主要用于处理将服务器响应信息输出到 Web 端（客户端）的相关操作，
+ * 它能够根据不同的输入参数（如服务器响应实体或特定业务异常），将对应的响应信息以 JSON 格式正确地写入到 HTTP 响应中，
+ * 同时进行了必要的日志记录以及异常处理，确保响应输出过程的可靠性和稳定性。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/28 14:15
+ */
+@Component
+public class HttpHandler {
+
+    // 创建一个日志记录器，用于记录该类中不同操作阶段的日志信息，方便后续进行问题排查和调试
+    private static final Logger logger = LoggerFactory.getLogger(HttpHandler.class);
+
+    // 通过 Spring 的依赖注入机制，注入一个 ObjectMapper 对象，用于将对象转换为 JSON 字符串以便输出到客户端
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    /**
+     * 将服务器响应实体（ServerResponseEntity）的内容以 JSON 格式输出到 Web 端（客户端）的 HTTP 响应中。
+     * 如果传入的服务器响应实体为 null，则仅记录相应日志并直接返回，不进行实际的输出操作。
+     * 同时会进行一系列的有效性检查，确保能够获取到正确的 HTTP 响应对象，并设置响应的字符编码和内容类型等属性，
+     * 若在输出过程中出现 I/O 异常，则抛出自定义的业务异常（YamiShopBindException）。
+     *
+     * @param serverResponseEntity 要输出到客户端的服务器响应实体，包含了响应的各种信息，如状态码、消息、数据等
+     * @param <T> 泛型参数，用于表示服务器响应实体中携带的数据的具体类型，具有通用性，可以适应不同类型的数据返回情况
+     */
+    public <T> void printServerResponseToWeb(ServerResponseEntity<T> serverResponseEntity) {
+        // 如果传入的服务器响应实体为 null，记录日志提示信息，并直接返回，不进行后续操作
+        if (serverResponseEntity == null) {
+            logger.info("print obj is null");
+            return;
+        }
+
+        // 从 Spring 的请求上下文中获取 ServletRequestAttributes 对象，它包含了与当前请求相关的信息，如请求和响应对象等
+        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
+                .getRequestAttributes();
+        // 如果获取到的 ServletRequestAttributes 对象为 null，说明无法获取到请求上下文相关信息，记录错误日志并返回，无法进行响应输出操作
+        if (requestAttributes == null) {
+            logger.error("requestAttributes is null, can not print to web");
+            return;
+        }
+
+        // 从 ServletRequestAttributes 对象中获取 HttpServletResponse 对象，用于后续设置响应属性和向客户端输出内容
+        HttpServletResponse response = requestAttributes.getResponse();
+        // 如果获取到的 HttpServletResponse 对象为 null，说明无法获取到有效的 HTTP 响应对象，记录错误日志并返回，无法进行响应输出操作
+        if (response == null) {
+            logger.error("httpServletResponse is null, can not print to web");
+            return;
+        }
+
+        // 记录响应的错误消息（这里假设 getMsg 方法获取的是错误相关信息，实际情况可能根据 ServerResponseEntity 的具体实现而定）到日志中，方便排查问题
+        logger.error("response error: " + serverResponseEntity.getMsg());
+
+        // 设置 HTTP 响应的字符编码为 UTF-8，确保输出的内容能够正确地被客户端解析，尤其是包含中文等多字节字符的情况
+        response.setCharacterEncoding(CharsetUtil.UTF_8);
+        // 设置 HTTP 响应的内容类型为 application/json，表明响应的内容是 JSON 格式的数据，让客户端能够正确识别并解析
+        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
+
+        // 用于向 HTTP 响应中写入字符数据的对象，初始化为 null，后续通过获取响应的输出流来实例化
+        PrintWriter printWriter = null;
+        try {
+            // 获取 HttpServletResponse 的输出流对象，用于向客户端写入响应内容（这里是将服务器响应实体转换后的 JSON 字符串写入）
+            printWriter = response.getWriter();
+            // 使用注入的 ObjectMapper 对象将服务器响应实体转换为 JSON 字符串，并写入到 HTTP 响应的输出流中，从而输出到客户端
+            printWriter.write(objectMapper.writeValueAsString(serverResponseEntity));
+        } catch (IOException e) {
+            // 如果在写入过程中出现 I/O 异常，抛出自定义的业务异常（YamiShopBindException），并将原始的 I/O 异常作为原因传递，方便上层进行统一的异常处理和日志记录
+            throw new YamiShopBindException("io 异常", e);
+        }
+    }
+
+    /**
+     * 针对 YamiShopBindException 类型的异常进行处理，将其相关的响应信息以 JSON 格式输出到 Web 端（客户端）的 HTTP 响应中。
+     * 如果传入的异常对象为 null，则仅记录相应日志并直接返回，不进行实际的输出操作。
+     * 如果异常对象中已经包含了服务器响应实体（ServerResponseEntity），则调用 printServerResponseToWeb 方法直接输出该实体内容。
+     * 否则，会根据异常对象中的错误码和错误消息构建一个新的服务器响应实体，并调用 printServerResponseToWeb 方法输出到客户端。
+     *
+     * @param yamiShopBindException 要处理并输出响应信息的 YamiShopBindException 异常对象，包含了业务异常相关的错误码、消息等信息
+     * @param <T> 泛型参数，用于表示服务器响应实体中携带的数据的具体类型（虽然此处构建新实体时可能没有实际数据，但保持与其他方法的通用性）
+     */
+    public <T> void printServerResponseToWeb(YamiShopBindException yamiShopBindException) {
+        // 如果传入的 YamiShopBindException 异常对象为 null，记录日志提示信息，并直接返回，不进行后续操作
+        if (yamiShopBindException == null) {
+            logger.info("print obj is null");
+            return;
+        }
+
+        // 判断异常对象中是否包含了服务器响应实体（ServerResponseEntity），如果包含则直接调用 printServerResponseToWeb 方法输出该实体内容到客户端
+        if (Objects.nonNull(yamiShopBindException.getServerResponseEntity())) {
+            printServerResponseToWeb(yamiShopBindException.getServerResponseEntity());
+            return;
+        }
+
+        // 如果异常对象中没有包含服务器响应实体，则创建一个新的 ServerResponseEntity 对象，用于封装异常中的错误码和错误消息等信息
+        ServerResponseEntity<T> serverResponseEntity = new ServerResponseEntity<>();
+        serverResponseEntity.setCode(yamiShopBindException.getCode());
+        serverResponseEntity.setMsg(yamiShopBindException.getMessage());
+        // 调用 printServerResponseToWeb 方法将构建好的服务器响应实体输出到客户端，完成响应信息的输出操作
+        printServerResponseToWeb(serverResponseEntity);
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/serializer/json/ImgJsonSerializer.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.serializer.json;
+
+// 导入Hutool工具库中用于字符串操作的工具类，例如判断字符串是否为空、处理字符串拼接等操作
+import cn.hutool.core.util.StrUtil;
+// 导入Jackson库中用于自定义JSON序列化相关的核心类，用于定义如何将Java对象序列化为JSON格式
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+// 导入自定义的类，Qiniu类可能包含了七牛云相关的配置信息，如资源访问地址等
+import com.yami.shop.common.bean.Qiniu;
+// 导入自定义的图片上传工具类，可能用于获取图片上传相关的配置信息，比如上传类型、资源地址等
+import com.yami.shop.common.util.ImgUploadUtil;
+// 导入Spring框架用于实现依赖注入的注解以及将类标记为组件的注解，表明该类是受Spring管理的组件，可被自动注入到需要的地方
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * ImgJsonSerializer类是一个自定义的JSON序列化器，用于处理将特定格式的字符串（可能是图片相关的路径字符串）序列化为JSON格式时的逻辑定制。
+ * 它主要根据图片上传的类型以及图片路径本身的格式（是否以http或https开头），来对图片路径进行处理，添加相应的资源访问地址前缀，
+ * 最终将处理后的图片路径以合适的格式序列化为JSON字符串输出，适用于在将包含图片路径信息的对象转换为JSON时进行特定的路径格式调整需求。
+ *
+ * @author lanhai
+ */
+@Component
+public class ImgJsonSerializer extends JsonSerializer<String> {
+
+    // 通过Spring的依赖注入机制，注入一个Qiniu对象，该对象可能包含了七牛云存储相关的配置信息，比如七牛云资源的访问地址等
+    @Autowired
+    private Qiniu qiniu;
+    // 注入一个ImgUploadUtil对象，用于获取图片上传相关的配置信息，例如图片上传类型等，辅助对图片路径进行处理
+    @Autowired
+    private ImgUploadUtil imgUploadUtil;
+
+    /**
+     * 重写了Jackson库中的serialize方法，用于定义具体的序列化逻辑，也就是将传入的字符串（此处假设与图片路径相关）按照特定规则转换为JSON格式的字符串输出。
+     *
+     * @param value 要进行序列化的字符串，在这里可能表示图片的路径信息，可能是单个图片路径或者多个图片路径用逗号分隔的形式
+     * @param gen Jackson库中的JsonGenerator对象，用于生成JSON输出内容，通过它可以将处理后的字符串写入到最终的JSON输出中
+     * @param serializers Jackson库中的SerializerProvider对象，提供了序列化相关的上下文信息，比如配置等，但在这个方法中通常不需要直接操作它
+     * @throws IOException 如果在向JsonGenerator写入内容过程中出现I/O异常，会抛出此异常，需要上层调用者进行相应处理
+     */
+    @Override
+    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+        // 判断传入的要序列化的字符串是否为空（空白字符串，包括null、空字符串以及只包含空格等不可见字符的字符串）
+        if (StrUtil.isBlank(value)) {
+            // 如果为空，则向JsonGenerator写入一个空字符串，保持JSON格式的一致性，然后直接返回，不再进行后续处理
+            gen.writeString(StrUtil.EMPTY);
+            return;
+        }
+
+        // 将传入的字符串按照逗号进行分割，得到一个字符串数组，假设这里的字符串表示多个图片路径，以逗号分隔开，每个元素就是一个单独的图片路径
+        String[] imgs = value.split(StrUtil.COMMA);
+        // 创建一个可变的字符串构建器，用于拼接处理后的图片路径，方便后续构建最终的序列化字符串
+        StringBuilder sb = new StringBuilder();
+        // 用于存储资源访问地址，根据不同的上传类型来确定具体的值，后续会将其添加到图片路径前面（如果图片路径本身不符合要求的话）
+        String resourceUrl = "";
+        // 定义一个正则表达式字符串，用于匹配以"http"或"https"开头的字符串，目的是判断图片路径是否已经是完整的网络访问地址形式
+        String rule = "^((http[s]{0,1})://)";
+        // 使用定义好的正则表达式创建一个Pattern对象，用于后续进行正则匹配操作
+        Pattern pattern = Pattern.compile(rule);
+
+        // 根据ImgUploadUtil对象获取的上传类型来确定资源访问地址（resourceUrl）的值
+        if (Objects.equals(imgUploadUtil.getUploadType(), 2)) {
+            // 如果上传类型为2，从注入的Qiniu对象中获取资源访问地址，可能是七牛云存储资源的访问地址，用于构建完整的图片访问路径
+            resourceUrl = qiniu.getResourcesUrl();
+        } else if (Objects.equals(imgUploadUtil.getUploadType(), 1)) {
+            // 如果上传类型为1，从ImgUploadUtil对象中获取资源访问地址，可能是其他存储方式对应的资源访问地址
+            resourceUrl = imgUploadUtil.getResourceUrl();
+        }
+
+        // 遍历分割后的每个图片路径字符串
+        for (String img : imgs) {
+            // 使用创建的Pattern对象对当前图片路径字符串进行正则匹配，得到一个Matcher对象，用于查看是否匹配成功
+            Matcher matcher = pattern.matcher(img);
+            // 如果匹配成功，说明图片路径已经是以"http"或"https"开头的完整网络访问地址形式，直接将其添加到字符串构建器中，并添加逗号（保持与传入格式的一致性，后续会处理末尾多余的逗号）
+            if (matcher.find()) {
+                sb.append(img).append(StrUtil.COMMA);
+            } else {
+                // 如果图片路径不是完整的网络访问地址形式，则将前面确定的资源访问地址（resourceUrl）、当前图片路径以及逗号依次添加到字符串构建器中，构建完整的图片访问路径格式
+                sb.append(resourceUrl).append(img).append(StrUtil.COMMA);
+            }
+        }
+
+        // 删除字符串构建器中最后一个字符（末尾多余的逗号），得到最终处理好的图片路径字符串
+        sb.deleteCharAt(sb.length() - 1);
+        // 将处理好的图片路径字符串通过JsonGenerator写入到最终的JSON输出中，完成序列化操作
+        gen.writeString(sb.toString());
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/Arith.java

@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+/**
+ * 算术运算工具类，用于提供精确的数值计算功能，避免浮点数计算时因精度问题产生误差。
+ * 该类主要针对double类型以及BigDecimal类型的数值进行加、减、乘、除和四舍五入等常见算术运算操作。
+ * @author lanhai
+ */
+public class Arith {
+    /**
+     * 默认除法运算精度，即当调用无指定精度的div方法时，除法运算结果将精确到小数点后2位，
+     * 后续的数字按照相应的舍入规则进行处理（此处为HALF_EVEN舍入模式）。
+     */
+    private static final int DEF_DIV_SCALE = 2;
+
+    /**
+     * 将构造函数私有化，防止外部实例化该类，因为这个类的设计目的是作为工具类，提供静态方法供调用，
+     * 不需要创建类的实例对象，所以禁止外部实例化它。
+     */
+    private Arith() {
+    }
+
+    /**
+     * 提供精确的加法运算。
+     * 该方法接收两个double类型的参数，将它们转换为BigDecimal类型后进行精确加法运算，
+     * 最后返回计算结果的double值，这样可以避免直接使用double进行加法运算时可能出现的精度丢失问题。
+     *
+     * @param v1 被加数，即参与加法运算的第一个数值。
+     * @param v2 加数，即参与加法运算的第二个数值。
+     * @return 两个参数的和，以double类型返回精确计算后的结果。
+     */
+    public static double add(double v1, double v2) {
+        // 必须转换成String，因为BigDecimal的构造函数建议使用基于字符串的构造方式来避免精度问题，
+        // 如果直接使用double类型传入构造函数，在某些情况下可能会出现精度丢失。
+        String s1 = Double.toString(v1);
+        String s2 = Double.toString(v2);
+        BigDecimal b1 = new BigDecimal(s1);
+        BigDecimal b2 = new BigDecimal(s2);
+        return b1.add(b2).doubleValue();
+    }
+
+    /**
+     * 提供精确的减法运算。
+     * 与加法运算类似，接收两个double类型的参数，先转换为BigDecimal类型，再进行精确的减法操作，
+     * 最后返回结果的double值，确保减法运算的精度准确性。
+     *
+     * @param v1 被减数，参与减法运算的第一个数值，从中减去另一个数值。
+     * @param v2 减数，参与减法运算的第二个数值，用于从被减数中减去。
+     * @return 两个参数的差，以double类型返回精确计算后的结果。
+     */
+    public static double sub(double v1, double v2) {
+        String s1 = Double.toString(v1);
+        String s2 = Double.toString(v2);
+        BigDecimal b1 = new BigDecimal(s1);
+        BigDecimal b2 = new BigDecimal(s2);
+        return b1.subtract(b2).doubleValue();
+    }
+
+    /**
+     * 提供精确的乘法运算。
+     * 同样，把传入的两个double类型参数转换为BigDecimal类型后进行乘法运算，
+     * 以保证乘法计算结果的精度符合预期，最后返回double类型的结果值。
+     *
+     * @param v1 被乘数，参与乘法运算的第一个数值，与另一个数值相乘。
+     * @param v2 乘数，参与乘法运算的第二个数值，用于和被乘数相乘。
+     * @return 两个参数的积，以double类型返回精确计算后的结果。
+     */
+    public static double mul(double v1, double v2) {
+        String s1 = Double.toString(v1);
+        String s2 = Double.toString(v2);
+        BigDecimal b1 = new BigDecimal(s1);
+        BigDecimal b2 = new BigDecimal(s2);
+        return b1.multiply(b2).doubleValue();
+    }
+
+    /**
+     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到小数点以后10位，以后的数字四舍五入。
+     * 这里实际调用了另一个带有精度参数的div方法，并传入默认的精度值（DEF_DIV_SCALE），
+     * 以实现默认精度下的除法运算功能。
+     *
+     * @param v1 被除数，参与除法运算的第一个数值，作为被除的对象。
+     * @param v2 除数，参与除法运算的第二个数值，用于除被除数。
+     * @return 两个参数的商，以double类型返回按照默认精度进行四舍五入后的结果。
+     */
+    public static double div(double v1, double v2) {
+        return div(v1, v2, DEF_DIV_SCALE);
+    }
+
+    /**
+     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。
+     * 首先会对传入的参数进行合法性校验，如果指定的精度scale小于0，则抛出异常，
+     * 因为精度应该是正整数或者0，表示小数点后的保留位数。然后将传入的double类型参数转换为BigDecimal类型，
+     * 使用指定的精度和HALF_EVEN舍入模式进行除法运算，最后返回double类型的商。
+     *
+     * @param v1    被除数，参与除法运算的第一个数值，作为被除的对象。
+     * @param v2    除数，参与除法运算的第二个数值，用于除被除数。
+     * @param scale 表示需要精确到小数点以后几位，用于指定除法运算结果的精度。
+     * @return 两个参数的商，以double类型返回按照指定精度进行四舍五入后的结果。
+     */
+    public static double div(double v1, double v2, int scale) {
+        if (scale < 0) {
+            throw new IllegalArgumentException("The scale must be a positive integer or zero");
+        }
+        String s1 = Double.toString(v1);
+        String s2 = Double.toString(v2);
+        BigDecimal b1 = new BigDecimal(s1);
+        BigDecimal b2 = new BigDecimal(s2);
+        return b1.divide(b2, scale, RoundingMode.HALF_EVEN).doubleValue();
+    }
+
+    /**
+     * 提供精确的小数位四舍五入处理。
+     * 先对传入的参数进行合法性校验，要求scale（小数点后保留位数）不能小于0，
+     * 然后将需要四舍五入的数字转换为BigDecimal类型，再通过与表示数值1的BigDecimal对象进行除法运算，
+     * 按照指定的scale和HALF_EVEN舍入模式进行四舍五入，最后返回处理后的double类型结果。
+     *
+     * @param v     需要四舍五入的数字，以double类型传入。
+     * @param scale 小数点后保留几位，用于指定四舍五入的精度要求。
+     * @return 四舍五入后的结果，以double类型返回经过处理后的数值。
+     */
+    public static double round(double v, int scale) {
+        if (scale < 0) {
+            throw new IllegalArgumentException("The scale must be a positive integer or zero");
+        }
+        String s = Double.toString(v);
+        BigDecimal b = new BigDecimal(s);
+        BigDecimal one = new BigDecimal("1");
+        return b.divide(one, scale, RoundingMode.HALF_EVEN).doubleValue();
+    }
+
+
+    /**
+     * 重载的加法运算方法，用于对三个BigDecimal类型的数值进行相加操作，
+     * 最后返回相加结果的double值，方便在需要对多个BigDecimal数值求和时使用。
+     *
+     * @param bigDecimal  参与加法运算的第一个BigDecimal数值。
+     * @param bigDecimal2 参与加法运算的第二个BigDecimal数值。
+     * @param bigDecimal3 参与加法运算的第三个BigDecimal数值。
+     * @return 三个参数的和，以double类型返回精确计算后的结果。
+     */
+    public static double add(BigDecimal bigDecimal, BigDecimal bigDecimal2, BigDecimal bigDecimal3) {
+        return bigDecimal.add(bigDecimal2).add(bigDecimal3).doubleValue();
+    }
+
+    /**
+     * 另一个重载的加法运算方法，用于对两个BigDecimal类型的数值进行相加操作，
+     * 并返回相加结果的double值，满足不同场景下对两个BigDecimal数值求和的需求。
+     *
+     * @param preDepositPrice 参与加法运算的第一个BigDecimal数值，通常可以理解为预存金额之类的数值（具体含义取决于业务场景）。
+     * @param finalPrice      参与加法运算的第二个BigDecimal数值，通常可以理解为最终金额之类的数值（具体含义取决于业务场景）。
+     * @return 两个参数的和，以double类型返回精确计算后的结果。
+     */
+    public static double add(BigDecimal preDepositPrice, BigDecimal finalPrice) {
+        return preDepositPrice.add(finalPrice).doubleValue();
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/CacheManagerUtil.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+import lombok.AllArgsConstructor;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.stereotype.Component;
+
+/**
+ * CacheManagerUtil类用于方便地操作Spring的缓存机制。
+ * 它依赖于Spring的CacheManager来获取、设置和清除缓存中的数据，
+ * 提供了对缓存数据进行增删查操作的便捷方法。
+ * 该类被声明为Spring的一个组件（@Component注解），可以被自动注入到其他需要使用缓存操作功能的类中。
+ *
+ * @author lanhai
+ */
+@Component
+@AllArgsConstructor
+public class CacheManagerUtil {
+
+    // Spring的缓存管理器，用于获取具体的缓存对象等操作，通过构造注入的方式获取
+    private CacheManager cacheManager;
+
+    /**
+     * 从指定名称的缓存中根据给定的键获取缓存值。
+     *
+     * @param <T> 泛型参数，表示期望获取的缓存值的类型。
+     * @param cacheName 缓存的名称，用于通过CacheManager定位到具体的缓存对象。
+     * @param key 缓存中数据对应的键，用于在具体缓存对象里查找对应的值。
+     * @return 如果缓存中存在对应键的值，则返回该值（转换为指定的泛型类型T），若缓存不存在或者对应键的值不存在，则返回null。
+     */
+    @SuppressWarnings({"unchecked"})
+    public <T> T getCache(String cacheName, String key) {
+        // 通过缓存管理器获取指定名称的缓存对象
+        Cache cache = cacheManager.getCache(cacheName);
+        if (cache == null) {
+            return null;
+        }
+        // 从缓存对象中尝试获取对应键的值的包装对象
+        Cache.ValueWrapper valueWrapper = cache.get(key);
+        if (valueWrapper == null) {
+            return null;
+        }
+        // 从包装对象中获取实际的值，并转换为指定的泛型类型T返回
+        return (T) valueWrapper.get();
+    }
+
+    /**
+     * 将给定的值存入指定名称的缓存中，对应给定的键。
+     *
+     * @param cacheName 缓存的名称，用于通过CacheManager定位到要操作的具体缓存对象。
+     * @param key 缓存中数据对应的键，用于标识存入的值在缓存中的位置。
+     * @param value 要存入缓存的值，其类型可以是任意符合缓存要求的Java对象。
+     */
+    public void putCache(String cacheName, String key, Object value) {
+        // 通过缓存管理器获取指定名称的缓存对象
+        Cache cache = cacheManager.getCache(cacheName);
+        if (cache!= null) {
+            // 如果缓存对象存在，则将键值对存入该缓存对象中
+            cache.put(key, value);
+        }
+    }
+
+    /**
+     * 从指定名称的缓存中清除对应给定键的缓存数据。
+     *
+     * @param cacheName 缓存的名称，用于通过CacheManager定位到要操作的具体缓存对象。
+     * @param key 缓存中数据对应的键，用于确定要清除的缓存数据。
+     */
+    public void evictCache(String cacheName, String key) {
+        // 通过缓存管理器获取指定名称的缓存对象
+        Cache cache = cacheManager.getCache(cacheName);
+        if (cache!= null) {
+            // 如果缓存对象存在，则清除对应键的缓存数据
+            cache.evict(key);
+        }
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/HttpContextUtils.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+// 导入Spring相关的类，用于获取请求相关的上下文信息，基于请求上下文来获取HttpServletRequest对象
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+// 导入Servlet相关的类，用于操作HTTP请求，这里主要是HttpServletRequest，它包含了请求相关的各种信息
+import jakarta.servlet.http.HttpServletRequest;
+
+/**
+ * HttpContextUtils工具类，主要提供了一些与HTTP请求上下文相关的便捷获取方法，
+ * 通过Spring的请求上下文机制来获取HttpServletRequest对象，并基于该对象进一步获取如请求域名、请求来源等相关信息，
+ * 方便在项目的其他地方使用这些信息进行业务逻辑处理，例如跨域处理、链接构建等场景。
+ *
+ * @author lanhai
+ */
+public class HttpContextUtils {
+
+	/**
+	 * 获取当前线程绑定的HttpServletRequest对象。
+	 * 通过Spring的RequestContextHolder从请求上下文中获取ServletRequestAttributes对象，
+	 * 再从中提取出HttpServletRequest对象。该方法是后续获取其他请求相关信息的基础。
+	 *
+	 * @return HttpServletRequest 返回当前请求对应的HttpServletRequest对象，
+	 * 如果不存在绑定的请求上下文则会抛出异常（运行时异常），调用者需要进行相应处理。
+	 */
+	public static HttpServletRequest getHttpServletRequest() {
+		return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
+	}
+
+	/**
+	 * 获取当前请求的域名信息。
+	 * 首先调用getHttpServletRequest方法获取当前的HttpServletRequest对象，
+	 * 然后通过该对象的getRequestURL方法获取完整的请求URL（包含协议、域名、端口、路径等），
+	 * 再利用getRequestURI方法获取请求的路径部分，通过删除URL中路径及后面的部分来得到域名相关信息（包含协议、域名、端口）。
+	 *
+	 * @return String 返回当前请求的域名信息（格式类似：http://example.com:8080，具体取决于实际请求情况）。
+	 */
+	public static String getDomain() {
+		HttpServletRequest request = getHttpServletRequest();
+		StringBuffer url = request.getRequestURL();
+		return url.delete(url.length() - request.getRequestURI().length(), url.length()).toString();
+	}
+
+	/**
+	 * 获取当前请求的来源（Origin）信息，通常用于处理跨域相关场景。
+	 * 先获取当前的HttpServletRequest对象，然后通过该对象的getHeader方法获取名为"Origin"的请求头信息，
+	 * 该请求头一般由浏览器自动添加，标识了请求的来源域名等信息，在跨域请求等场景中有重要作用。
+	 *
+	 * @return String 返回当前请求的Origin信息（格式类似：http://example.com，如果有Origin请求头的话，否则返回null等情况）。
+	 */
+	public static String getOrigin() {
+		HttpServletRequest request = getHttpServletRequest();
+		return request.getHeader("Origin");
+	}
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/IdUtil.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+// 导入 Hutool 库中用于生成分布式唯一ID的 Snowflake 类，通常基于雪花算法实现
+import cn.hutool.core.lang.Snowflake;
+// 导入 Spring 框架用于实现依赖注入的注解以及将类标记为组件的注解，表明该类是受 Spring 管理的组件
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * IdUtil 是一个进制转换相关的工具类，主要提供了以下功能：
+ * 1. 支持在十进制和基于特定字符集（DICT）定义的进制之间进行转换，最大支持十进制和 DICT.length() 进制的相互转换操作。
+ * 2. 能够根据从数据库中获取的记录 ID（通常是较大范围的数值）生成对应的短网址编码，便于在一些场景下使用更简短的编码来表示较长的 ID。
+ * 3. 可以依据给定的短网址编码解析出其在数据库中对应的原始记录 ID，实现编码与原始 ID 的相互转换。
+ * 4. 借助注入的 Snowflake 实例，还能生成下一个短 ID（基于雪花算法生成唯一 ID 并转换为短网址编码形式）。
+ *
+ * @author xuliugen
+ * @date 2018/04/23
+ */
+@Component
+public class IdUtil {
+
+    // 通过 Spring 的依赖注入机制，注入一个 Snowflake 实例，用于生成分布式唯一 ID（可能用于生成短 ID 的基础）
+    @Autowired
+    private Snowflake snowflake;
+
+    // 定义了一个包含数字和大小写字母（去除了容易混淆的部分字母）的字符串，作为自定义进制的字符集，用于进制转换操作
+    private static final String DICT = "0123456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ";
+    // 计算出基于 DICT 字符集的进制数，即字符集的长度，用于进制转换过程中的计算
+    private static final int SEED = DICT.length();
+    // 定义了短网址编码的最小长度，用于在生成短网址编码时，如果长度不足则进行补位操作，保证编码长度符合一定要求
+    private static final int ID_MIN_LENGTH = 6;
+    /**
+     * 将 DICT 字符串转换为字符数组，方便在进制转换过程中通过索引快速获取对应字符，用于数字到字符的映射操作。
+     */
+    private static final char[] CHARS = DICT.toCharArray();
+    /**
+     * 创建一个字符到数字的映射关系的 Map，用于在解析短网址编码时，根据字符快速获取对应的数字（在自定义进制下的数字表示），实现字符到数字的转换操作。
+     */
+    private static final Map<Character, Integer> NUMBERS = new HashMap<>();
+
+    // 静态代码块，用于初始化 NUMBERS 这个字符到数字的映射 Map，遍历 CHARS 字符数组，将每个字符与其对应的索引（在自定义进制下的数字）存入 Map 中
+    static {
+        int len = CHARS.length;
+        for (int i = 0; i < len; i++) {
+            NUMBERS.put(CHARS[i], i);
+        }
+    }
+
+    /**
+     * 将给定的十进制数字（通常是较大范围的数值，如数据库记录 ID）转换为基于自定义进制（由 DICT 定义）的短网址编码字符串。
+     * 转换过程采用除基取余法，不断将十进制数除以自定义进制数（SEED），取余数作为对应字符在 DICT 中的索引，构建短网址编码字符串，
+     * 并且如果生成的编码长度小于最小长度要求（ID_MIN_LENGTH），会在前面补位（添加 DICT 中的第一个字符）以达到最小长度。
+     *
+     * @param id 要转换的十进制数字，通常表示数据库中记录的 ID，范围大致在 (1 - 56.8 billion)，不过实际范围取决于具体业务场景
+     * @return 转换后的基于自定义进制的短网址编码字符串，例如可能返回类似 "RwTji8"、"GijT7Y" 等形式的字符串
+     */
+    public static String encode(long id) {
+        // 创建一个可变的字符串构建器，用于逐步构建短网址编码字符串
+        StringBuilder shortUrl = new StringBuilder();
+        // 当传入的十进制数字大于 0 时，进行进制转换操作，采用除基取余法
+        while (id > 0) {
+            // 计算当前十进制数除以自定义进制数（SEED）的余数，将其转换为整数类型，该余数将作为在 DICT 中查找对应字符的索引
+            int r = (int) (id % SEED);
+            // 将根据余数获取到的对应字符插入到短网址编码字符串的开头（逆序构建编码字符串）
+            shortUrl.insert(0, CHARS[r]);
+            // 更新十进制数，将其除以自定义进制数，得到下一轮循环要处理的数字
+            id = id / SEED;
+        }
+        // 获取当前已经构建好的短网址编码字符串的长度
+        int len = shortUrl.length();
+        // 如果长度小于最小长度要求（ID_MIN_LENGTH），进行补位操作
+        while (len < ID_MIN_LENGTH) {
+            // 在短网址编码字符串的开头插入 DICT 中的第一个字符（通常是 '0'）进行补位
+            shortUrl.insert(0, CHARS[0]);
+            // 更新长度
+            len++;
+        }
+        // 返回最终构建好的短网址编码字符串
+        return shortUrl.toString();
+    }
+
+    /**
+     * 根据给定的短网址编码字符串（基于自定义进制）解析出其对应的十进制数字，该十进制数字通常对应数据库中的记录 ID。
+     * 解析过程是将短网址编码中的每个字符按照其在自定义进制下的权重（通过幂运算计算）转换为十进制数，再累加起来得到最终的十进制结果。
+     *
+     * @param key 要解析的短网址编码字符串，例如 "RwTji8"、"GijT7Y" 等形式的字符串，每个字符都代表自定义进制下的一位数字
+     * @return 解析出的十进制数字，对应数据库中记录的 ID
+     */
+    public static long decode(String key) {
+        // 将传入的短网址编码字符串转换为字符数组，方便逐个字符进行处理
+        char[] shorts = key.toCharArray();
+        // 获取字符数组的长度，即短网址编码的长度
+        int len = shorts.length;
+        // 初始化用于累加计算的十进制数字为 0
+        long id = 0L;
+        // 遍历短网址编码的每个字符，从左到右（按照权重从高到低）进行解析计算
+        for (int i = 0; i < len; i++) {
+            // 根据当前字符在 NUMBERS 映射 Map 中获取其对应的数字（在自定义进制下的数字表示），并乘以当前位置对应的权重（SEED 的幂次方），然后累加到结果中
+            id = id + (long) (NUMBERS.get(shorts[i]) * Math.pow(SEED, len - i - 1));
+        }
+        // 返回解析得到的十进制数字（数据库记录 ID）
+        return id;
+    }
+
+    /**
+     * 借助注入的 Snowflake 实例生成一个分布式唯一 ID（基于雪花算法），然后将该唯一 ID 转换为基于自定义进制的短网址编码形式，
+     * 作为下一个短 ID 返回，可用于在业务中生成具有唯一性且简短的标识符，例如用于短链接、短编号等场景。
+     *
+     * @return 基于雪花算法生成唯一 ID 并转换后的短网址编码字符串，作为下一个短 ID
+     */
+    public String nextShortId() {
+        return encode(snowflake.nextId());
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/ImgUploadUtil.java

@@ -0,0 +1,127 @@
+package com.yami.shop.common.util;
+
+// 导入Hutool工具库中用于字符串操作的工具类，可用于判断字符串是否为空等操作
+import cn.hutool.core.util.StrUtil;
+// 导入自定义的用于封装图片上传相关配置信息的类，包含存储路径、上传类型、资源访问URL等属性
+import com.yami.shop.common.bean.ImgUpload;
+// 导入自定义的业务异常类，用于在特定业务逻辑出现问题时抛出相应的异常信息，方便统一处理
+import com.yami.shop.common.exception.YamiShopBindException;
+// 导入Spring框架用于实现依赖注入的注解以及将类标记为组件的注解，表明该类是受Spring管理的组件，可在项目中被自动注入和使用
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+// 导入Spring用于处理文件上传的核心类，代表上传的文件对象，包含文件内容、文件名等信息
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * ImgUploadUtil类是一个工具类，主要提供了本地文件上传与删除相关的功能方法，同时也能获取与文件上传配置相关的一些关键信息，
+ * 例如上传类型、上传路径、资源访问URL等，并且在配置信息不完整或者文件操作出现异常等情况下会抛出相应的业务异常，
+ * 便于在项目中进行统一的异常处理以及基于配置进行可靠的本地文件管理操作。
+ *
+ * @author TRACK
+ */
+@Component
+public class ImgUploadUtil {
+
+    // 通过Spring的依赖注入机制，注入一个ImgUpload对象，该对象包含了本地文件上传相关的配置信息，如存储路径、上传方式等
+    @Autowired
+    private ImgUpload imgUpload;
+
+    /**
+     * 获取文件上传类型的方法，从注入的ImgUpload对象中获取上传类型属性值。
+     * 如果获取到的值为null，说明没有配置图片存储方式，此时会抛出自定义的业务异常（YamiShopBindException），
+     * 提醒调用者需要进行相应的配置，否则返回获取到的上传类型值。
+     *
+     * @return Integer 返回表示文件上传类型的整数值，1通常表示本地文件上传，2可能表示使用其他云存储等方式（具体由业务定义）
+     */
+    public Integer getUploadType() {
+        Integer uploadType = imgUpload.getUploadType();
+        if (Objects.isNull(uploadType)) {
+            throw new YamiShopBindException("请配置图片存储方式");
+        }
+        return uploadType;
+    }
+
+    /**
+     * 获取文件上传路径的方法，从注入的ImgUpload对象中获取图片存储的路径属性值（imagePath）。
+     * 如果获取到的值为null或者是空字符串，说明没有配置图片存储路径，此时会抛出自定义的业务异常（YamiShopBindException），
+     * 提醒调用者需要进行相应的配置，否则返回获取到的图片存储路径字符串。
+     *
+     * @return String 返回表示本地文件上传存储路径的字符串，用于确定文件上传后在本地服务器存储的具体位置
+     */
+    public String getUploadPath() {
+        String imagePath = imgUpload.getImagePath();
+        if (Objects.isNull(imagePath) || StrUtil.isBlank(imagePath)) {
+            throw new YamiShopBindException("请配置图片存储路径");
+        }
+        return imagePath;
+    }
+
+    /**
+     * 获取图片资源访问URL的方法，从注入的ImgUpload对象中获取资源访问URL属性值（resourceUrl）。
+     * 如果获取到的值为null或者是空字符串，说明没有配置图片路径相关的资源访问URL，此时会抛出自定义的业务异常（YamiShopBindException），
+     * 提醒调用者需要进行相应的配置，否则返回获取到的资源访问URL字符串，该URL可用于构建完整的图片访问链接等场景。
+     *
+     * @return String 返回表示图片资源访问URL的字符串，用于生成可对外访问的图片链接
+     */
+    public String getResourceUrl() {
+        String resourceUrl = imgUpload.getResourceUrl();
+        if (Objects.isNull(resourceUrl) || StrUtil.isBlank(resourceUrl)) {
+            throw new YamiShopBindException("请配置图片路径");
+        }
+        return resourceUrl;
+    }
+
+    /**
+     * 执行本地文件上传的方法，将传入的MultipartFile类型的文件（代表上传的文件对象）保存到本地指定的路径下。
+     * 首先获取配置的本地文件上传路径，然后根据传入的文件名构建目标文件对象，若目标文件所在目录不存在，则尝试创建目录，
+     * 如果目录创建失败会抛出自定义的业务异常；接着将上传的文件内容转移到目标文件中，如果出现I/O异常则同样抛出自定义的业务异常，
+     * 若文件上传成功则返回上传后的文件名。
+     *
+     * @param img 代表要上传的文件对象，包含了文件的内容、原始文件名等信息，是Spring在处理文件上传时封装的对象
+     * @param fileName 要保存的文件名，通常可以是基于一定规则生成或者获取自上传文件的原始文件名等情况
+     * @return String 返回上传后的文件名，可用于后续的业务逻辑中，比如记录文件上传情况、构建文件访问链接等
+     */
+    public String upload(MultipartFile img, String fileName) {
+        // 获取配置的本地文件上传路径（存储文件夹路径）
+        String filePath = imgUpload.getImagePath();
+        // 根据文件上传路径和传入的文件名构建一个File对象，代表要保存的目标文件
+        File file = new File(filePath + fileName);
+        // 判断目标文件所在的目录是否存在，如果不存在则尝试创建目录
+        if (!file.exists()) {
+            boolean result = file.mkdirs();
+            // 如果目录创建失败（返回false），抛出自定义的业务异常，提示创建目录失败的具体路径信息
+            if (!result) {
+                throw new YamiShopBindException("创建目录：" + filePath + "失败");
+            }
+        }
+        try {
+            // 将上传的文件内容转移到目标文件中，即将MultipartFile中的文件数据写入到本地创建好的目标文件里
+            img.transferTo(file);
+        } catch (IOException e) {
+            // 如果在文件转移（写入）过程中出现I/O异常，抛出自定义的业务异常，提示图片上传失败
+            throw new YamiShopBindException("图片上传失败");
+        }
+        // 文件上传成功后，返回上传后的文件名，方便后续业务使用
+        return fileName;
+    }
+
+    /**
+     * 执行本地文件删除的方法，根据传入的文件名尝试删除本地指定路径下对应的文件。
+     * 通过获取配置的本地文件上传路径和传入的文件名构建目标文件对象，然后调用其deleteOnExit方法标记文件在JVM退出时删除，
+     * 不过要注意这种删除方式只是标记，实际的删除操作可能会在JVM正常退出时执行。
+     *
+     * @param fileName 要删除的文件名，需对应本地文件上传路径下实际存在的文件
+     */
+    public void delete(String fileName) {
+        // 获取配置的本地文件上传路径（存储文件夹路径）
+        String filePath = imgUpload.getImagePath();
+        // 根据文件上传路径和传入的文件名构建一个File对象，代表要删除的目标文件
+        File file = new File(filePath + fileName);
+        // 标记文件在JVM退出时删除，注意这并不一定会立即删除文件，而是在JVM正常退出时执行删除操作（如果文件存在且可删除的话）
+        file.deleteOnExit();
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/IpHelper.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+// 导入Servlet相关的用于操作HTTP请求的类，后续用于获取请求头以及客户端IP地址等信息
+import jakarta.servlet.http.HttpServletRequest;
+
+/**
+ * IpHelper类是一个工具类，主要用于获取客户端（用户）的真实IP地址。
+ * 在网络环境中，由于可能存在代理服务器等情况，获取IP地址的方式会有所不同，
+ * 该类通过依次检查不同的请求头信息以及直接获取远程地址的方式来尝试获取客户端真实IP地址，
+ * 并且如果获取到多个IP地址（例如经过多层代理的情况），则取第一个作为客户端的真实IP地址返回。
+ *
+ * @author lanhai
+ */
+public class IpHelper {
+
+    // 定义一个表示未知IP地址的常量字符串，用于后续判断请求头中获取到的IP地址是否有效
+    private static final String UNKNOWN = "unknown";
+
+    /**
+     * 获取用户真实IP地址的方法，按照一定的顺序检查不同的请求头以及直接获取远程地址来确定客户端的IP地址。
+     * 首先尝试从"x-forwarded-for"请求头获取IP地址，因为在经过代理服务器转发时，该请求头可能包含了客户端的真实IP地址；
+     * 如果该请求头获取到的IP地址为空、长度为0或者是表示未知的字符串（"unknown"），则接着尝试从"Proxy-Client-IP"请求头获取；
+     * 若还是不符合要求，再尝试从"WL-Proxy-Client-IP"请求头获取；
+     * 若以上请求头都无法获取到有效IP地址，则直接获取请求的远程地址（RemoteAddr）作为IP地址；
+     * 最后，如果获取到的IP地址字符串包含多个IP（以逗号分隔，可能经过多层代理的情况），则取第一个IP作为最终的客户端真实IP地址返回。
+     *
+     * @return String 返回获取到的客户端真实IP地址，如果由于各种原因无法获取到（例如没有有效的请求上下文等）则返回null
+     */
+    public static String getIpAddr() {
+        // 通过HttpContextUtils工具类获取当前线程绑定的HttpServletRequest对象，该对象包含了请求相关的各种信息
+        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
+        // 如果获取到的HttpServletRequest对象为null，说明无法获取到请求上下文相关信息，直接返回null，无法获取IP地址
+        if (request == null) {
+            return null;
+        }
+
+        // 首先尝试从"x-forwarded-for"请求头获取IP地址，该请求头在经过代理服务器转发时可能包含客户端真实IP
+        String ip = request.getHeader("x-forwarded-for");
+        // 如果获取到的IP地址为空、长度为0或者等于表示未知的字符串（不区分大小写比较），则继续尝试从其他请求头获取
+        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
+            ip = request.getHeader("Proxy-Client-IP");
+        }
+        // 如果从"Proxy-Client-IP"请求头获取到的IP地址仍不符合要求（为空、长度为0或者是未知字符串），则再尝试从"WL-Proxy-Client-IP"请求头获取
+        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
+            ip = request.getHeader("WL-Proxy-Client-IP");
+        }
+        // 如果经过前面的尝试还是没有获取到有效IP地址，则直接获取请求的远程地址（RemoteAddr）作为IP地址，这是最基本的获取客户端IP的方式
+        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
+            ip = request.getRemoteAddr();
+        }
+
+        // 将获取到的IP地址字符串按照逗号进行分割，因为可能存在经过多层代理，IP地址有多个的情况（以逗号分隔）
+        String[] ips = ip.split(",");
+        // 返回分割后的第一个IP地址（去除两端的空白字符）作为客户端的真实IP地址，如果只有一个IP则就是该IP本身
+        return ips[0].trim();
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/Json.java

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+// 导入Jackson相关的注解和类，用于配置JSON序列化和反序列化过程中的一些行为，比如包含哪些属性、如何处理未知属性等
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.json.JsonWriteFeature;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+// 导入Lombok的日志记录相关注解，用于简化日志记录代码，自动生成名为log的日志记录对象
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Json工具类，主要基于Jackson库提供了一系列便捷的JSON处理方法，
+ * 包括将Java对象转换为JSON字符串、将JSON字符串反序列化为Java对象（单个对象、对象数组、JSON节点等多种形式），
+ * 同时在类初始化时对Jackson的ObjectMapper进行了一些常用的配置，以满足特定的JSON处理需求，例如处理空值、未知属性、日期格式等情况。
+ *
+ * @author lanhai
+ */
+@Slf4j
+public class Json {
+
+	// 创建一个静态的ObjectMapper实例，ObjectMapper是Jackson库中用于进行JSON序列化和反序列化的核心类，后续所有的JSON操作都基于它来实现
+	private static ObjectMapper objectMapper = new ObjectMapper();
+
+	// 静态代码块，用于对ObjectMapper实例进行一系列的配置，这些配置会影响JSON序列化和反序列化的行为。
+	static {
+		// 设置序列化时的包含规则，这里配置为JsonInclude.Include.NON_EMPTY，表示如果属性值为空（比如null、空字符串、空集合等）则不输出该属性到JSON字符串中，减少不必要的JSON数据量。
+		objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
+		// 配置在序列化时，对于空的Java对象（没有任何属性值的对象）转JSON的时候不抛出错误，而是正常返回一个空的JSON对象（如 {}），增强程序的健壮性，避免因空对象序列化失败导致整个操作中断。
+		objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
+		// 禁用将日期类型属性序列化为时间戳的功能，这样在处理日期类型数据时可以按照更符合业务需求的日期格式（比如特定的字符串格式）进行序列化，而不是默认的时间戳形式。
+		objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+		// 禁用在反序列化时遇到未知属性（即JSON字符串中的属性在对应的Java类中不存在定义）抛出异常的功能，这样即使JSON数据有额外的属性，也能尽量解析出已知的属性值，避免因未知属性导致整个反序列化失败。
+		objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+		// 取消对非ASCII字符的转码操作，使得JSON字符串中可以直接包含如中文等非ASCII字符，而不需要进行转义编码，方便查看和处理，更符合实际业务场景中对中文等字符的使用需求。
+		objectMapper.configure(JsonWriteFeature.ESCAPE_NON_ASCII.mappedFeature(), false);
+
+	}
+
+	/**
+	 * 将给定的Java对象转换为JSON字符串的方法。
+	 * 通过调用ObjectMapper的writeValueAsString方法来实现转换，如果在转换过程中出现JSON处理异常（如对象的属性类型不支持序列化等情况），
+	 * 则会记录错误日志，并返回null，由调用者根据实际情况进行后续处理。
+	 *
+	 * @param object 要转换为JSON字符串的Java对象，可以是任意符合Jackson序列化规则的对象，如POJO、集合、基本数据类型包装类等。
+	 * @return String 返回转换后的JSON字符串，如果转换过程出现异常则返回null。
+	 */
+	public static String toJsonString(Object object) {
+		try {
+			return objectMapper.writeValueAsString(object);
+		} catch (JsonProcessingException e) {
+			// 记录对象转JSON时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
+			log.error("对象转json错误：", e);
+		}
+		return null;
+	}
+
+	/**
+	 * 将给定的JSON字符串反序列化为指定类型的Java对象的方法。
+	 * 通过调用ObjectMapper的readValue方法，按照传入的目标类类型（clazz）信息将JSON字符串解析为对应的Java对象，
+	 * 如果在反序列化过程中出现异常（如JSON格式不符合要求、属性类型不匹配等情况），则会记录错误日志，并返回null，
+	 * 由调用者根据实际情况进行后续处理。
+	 *
+	 * @param json 要反序列化的JSON字符串，需要符合对应Java类的结构和Jackson的解析规则。
+	 * @param clazz 目标Java类的类型，用于告诉ObjectMapper将JSON字符串解析成什么类型的对象，必须是具体的类类型，不能是接口或抽象类等无法实例化的类型。
+	 * @return <T> 返回反序列化后的Java对象，类型与传入的clazz参数指定的类型一致，如果反序列化过程出现异常则返回null。
+	 */
+	public static <T> T parseObject(String json, Class<T> clazz) {
+		T result = null;
+		try {
+			result = objectMapper.readValue(json, clazz);
+		} catch (Exception e) {
+			// 记录JSON转对象时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
+			log.error("对象转json错误：", e);
+		}
+		return result;
+	}
+
+	/**
+	 * 获取配置好的ObjectMapper实例的方法，外部代码可以通过获取该实例来进行更复杂、自定义的JSON序列化和反序列化操作，
+	 * 利用已有的配置来满足一些特殊的JSON处理需求，比如使用不同的JSON格式、自定义序列化器和反序列化器等情况。
+	 *
+	 * @return ObjectMapper 返回配置好的ObjectMapper实例，供外部调用进行JSON相关操作。
+	 */
+	public static ObjectMapper getObjectMapper() {
+		return objectMapper;
+	}
+
+	/**
+	 * 将给定的JSON字符串反序列化为指定类型的Java对象数组，并将其转换为对应的List集合的方法。
+	 * 先通过ObjectMapper的readValue方法将JSON字符串按照传入的对象数组类型（clazz）解析为对象数组，
+	 * 如果解析成功，则将对象数组转换为List集合返回；如果解析过程出现异常或者解析结果为null，则返回一个空的List集合，
+	 * 保证方法的返回结果具有一定的稳定性，方便调用者进行后续操作而不用担心空指针等问题。
+	 * 此方法相较于使用TypeReference来处理数组反序列化，在特定情况下（如文档中提到的，最多可快10倍）性能更好。
+	 *
+	 * @param json 要反序列化的JSON字符串，其结构需要符合对应Java对象数组的格式要求，即包含多个符合指定类型的JSON对象表示。
+	 * @param clazz 目标Java对象数组的类型，用于告诉ObjectMapper将JSON字符串解析成什么类型的对象数组，必须是具体的类数组类型，如MyClass[].class。
+	 * @return <T> 返回反序列化后的Java对象列表，类型与传入的clazz参数指定的对象数组中的元素类型一致，如果反序列化出现异常则返回空的List集合。
+	 */
+	public static <T> List<T> parseArray(String json, Class<T[]> clazz) {
+		T[] result = null;
+		try {
+			result = objectMapper.readValue(json, clazz);
+		} catch (Exception e) {
+			// 记录JSON转换时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
+			log.error("Json转换错误：", e);
+		}
+		if (result == null) {
+			return Collections.emptyList();
+		}
+		return Arrays.asList(result);
+	}
+
+	/**
+	 * 将给定的JSON字符串转换为JsonNode对象的方法，JsonNode类似于JSON数据的树形结构表示，可以方便地对JSON数据进行灵活的遍历、查询和操作，
+	 * 相当于将JSON字符串解析为一个通用的、可以灵活处理的JSON节点对象（类似Map结构，可以按节点层次获取属性值等）。
+	 * 如果在转换过程中出现异常，则会记录错误日志，并返回null，由调用者根据实际情况进行后续处理。
+	 *
+	 * @param jsonStr 要转换为JsonNode对象的JSON字符串，格式需符合JSON语法规范。
+	 * @return JsonNode 返回解析后的JsonNode对象，如果转换过程出现异常则返回null，通过该对象可以进一步操作JSON数据的各个节点和属性。
+	 */
+	public static JsonNode parseJson(String jsonStr) {
+		JsonNode jsonNode = null;
+		try {
+			jsonNode = objectMapper.readTree(jsonStr);
+		} catch (Exception e) {
+			// 记录JSON转换时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
+			log.error("Json转换错误：", e);
+		}
+		return jsonNode;
+	}
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/PageAdapter.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+// 导入Hutool工具库中用于分页相关操作的工具类，这里主要用于将页码、每页数量等信息转换为数据库查询中起始位置和结束位置的相关操作
+import cn.hutool.core.util.PageUtil;
+// 导入MyBatis Plus框架中用于表示分页信息的核心类，包含了当前页码、每页显示数量等分页相关的属性和方法
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 引入Lombok的Data注解，通过该注解，编译器会自动帮我们生成类的常用方法，比如各属性的Getter、Setter方法，以及toString、equals、hashCode方法等，简化代码编写
+import lombok.Data;
+
+/**
+ * PageAdapter类主要起到了一个适配的作用，用于将MyBatis Plus框架中的分页对象（Page）的相关信息，
+ * 转换为适用于其他分页逻辑或者数据库查询中分页参数的表示形式，
+ * 具体是将基于页码和每页数量的分页信息转换为起始位置（begin）和每页数量（size）的形式，方便后续在数据库查询等场景中使用，
+ * 借助Hutool工具库的分页相关功能来实现这种转换操作。
+ *
+ * @author lh
+ */
+@Data
+public class PageAdapter {
+
+    // 用于表示分页查询时的起始位置（通常对应数据库查询中的偏移量，从第几条记录开始查询）
+    private int begin;
+
+    // 用于表示分页查询时每页的记录数量，即每页显示多少条数据
+    private int size;
+
+    /**
+     * 构造方法，接收一个MyBatis Plus框架中的Page对象作为参数，
+     * 通过调用Hutool工具库的PageUtil工具类的transToStartEnd方法，
+     * 将Page对象中的当前页码和每页数量信息转换为对应的起始位置和每页数量信息，分别赋值给类中的begin和size属性，完成适配转换操作。
+     *
+     * @param page MyBatis Plus框架中的Page对象，包含了当前页码、每页显示数量等分页相关的属性信息，通过这些信息来计算出合适的begin和size值
+     */
+    public PageAdapter(Page page) {
+        // 调用Hutool的PageUtil工具类的transToStartEnd方法，将当前页码（需要减1，因为数据库查询中页码通常从0开始计数）和每页数量转换为起始位置和结束位置的数组，这里取数组的第一个元素作为起始位置（begin）
+        int[] startEnd = PageUtil.transToStartEnd((int) page.getCurrent() - 1, (int) page.getSize());
+        this.begin = startEnd[0];
+        // 将传入的Page对象中的每页数量赋值给size属性，作为每页的记录数量
+        this.size = (int) page.getSize();
+    }
+}

yami-shop-common/src/main/java/com/yami/shop/common/util/PageParam.java

@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.common.util;
+
+// 导入MyBatis Plus框架中用于表示分页信息的核心类，包含了分页相关的属性（如当前页、每页大小等）以及操作方法（如获取记录列表、设置总数等）
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入Jackson相关的注解，用于在JSON序列化和反序列化过程中忽略指定的属性，这里用于标记某些属性在转换为JSON时不进行处理
+import com.fasterxml.jackson.annotation.JsonIgnore;
+// 导入Swagger相关的注解，用于在生成API文档时隐藏某些属性，使得这些属性不在文档中展示出来，一般用于内部使用或不需要对外暴露的属性
+import io.swagger.v3.oas.annotations.Hidden;
+// 导入Swagger相关的注解，用于在生成API文档时为类、属性等添加描述信息，方便前端开发人员等查看其含义和作用
+import io.swagger.v3.oas.annotations.media.Schema;
+// 导入SpringDoc相关的注解，用于标记该类作为参数对象，在生成API文档以及进行参数校验等场景下可以被识别和处理
+import org.springdoc.core.annotations.ParameterObject;
+
+import java.util.List;
+
+/**
+ * PageParam类是一个泛型类，继承自MyBatis Plus的Page类，主要用于扩展和定制分页相关的功能及属性。
+ * 它在原有Page类的基础上，重新定义了一些分页属性（如每页显示条数、当前页等）的默认值，并对部分属性添加了文档注释以及JSON序列化相关的控制，
+ * 同时重写了Page类中的一些获取和设置属性的方法，以满足特定业务场景下对分页参数更灵活的控制和处理需求，
+ * 例如限制每页最大显示条数、根据总数情况判断是否进行count查询等功能。
+ *
+ * @author lanhai
+ */
+@Schema
+@ParameterObject
+public class PageParam<T> extends Page<T> {
+
+    /**
+     * 每页显示条数属性，用于指定每页展示的数据记录数量，默认值设置为10。
+     * 通过@Schema注解添加了描述信息，在生成API文档时可以展示该属性的含义，方便使用者了解其作用。
+     */
+    @Schema(description = "每页大小，默认10")
+    private long size = 10;
+
+    /**
+     * 当前页属性，用于表示当前所处的页码，默认值设置为1，同样通过@Schema注解添加了描述信息以便在API文档中展示其含义。
+     */
+    @Schema(description = "当前页，默认1")
+    private long current = 1;
+
+    /**
+     * 用于存储查询到的数据记录列表，通过@Hidden注解标记该属性在生成API文档时隐藏起来，因为该属性通常是内部使用，不需要对外展示具体的数据内容。
+     */
+    @Hidden
+    private List<T> records;
+
+    /**
+     * 用于记录符合查询条件的数据总条数，通过@Hidden注解在生成API文档时隐藏该属性，它主要在内部用于分页相关的计算和判断等操作。
+     */
+    @Hidden
+    private long total = 0;
+
+    /**
+     * 是否进行count查询的标志属性，用于控制在分页查询时是否需要统计符合条件的数据总条数，默认值为true，表示默认进行count查询。
+     * 通过@JsonIgnore注解标记该属性，在将对象转换为JSON时忽略该属性，因为它通常不需要在对外传输的数据中体现。
+     */
+    @JsonIgnore
+    private boolean isSearchCount = true;
+
+    /**
+     * 一个用于特定场景的属性（具体功能可能根据业务而定），通过@JsonIgnore注解标记在JSON序列化时忽略该属性，一般是内部使用的标识信息等情况。
+     */
+    @JsonIgnore
+    private String countId;
+
+    /**
+     * 用于限制每页最大显示条数的属性（具体值在这里设置为100），通过@JsonIgnore注解在JSON序列化时忽略它，主要在内部用于对每页大小进行限制调整。
+     */
+    @JsonIgnore
+    private Long maxLimit;
+
+    /**
+     * 用于优化count查询SQL语句相关的属性（具体优化逻辑取决于具体业务实现），通过@JsonIgnore注解在JSON序列化时忽略它，也是内部使用的一个标识属性。
+     */
+    @JsonIgnore
+    private boolean optimizeCountSql;
+
+    /**
+     * 重写了父类Page中获取记录列表的方法，返回当前对象中存储的记录列表（records属性），用于在业务逻辑中获取查询到的数据内容。
+     *
+     * @return List<T> 返回存储的数据记录列表，类型与泛型参数T一致，包含了符合查询条件的具体数据记录。
+     */
+    @Override
+    public List<T> getRecords() {
+        return this.records;
+    }
+
+    /**
+     * 重写了父类Page中设置记录列表的方法，将传入的记录列表赋值给当前对象的records属性，并返回当前对象（this），方便进行链式调用，
+     * 用于在查询到数据后更新对象中的记录列表信息，以便后续进行分页相关的处理和展示等操作。
+     *
+     * @param records 要设置的数据记录列表，类型与泛型参数T一致，通常是从数据库查询得到的符合条件的数据集合。
+     * @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
+     */
+    @Override
+    public Page<T> setRecords(List<T> records) {
+        this.records = records;
+        return this;
+    }
+
+    /**
+     * 重写了父类Page中获取数据总条数的方法，返回当前对象中存储的总条数（total属性），用于在分页相关的计算（如计算总页数等）以及业务判断中使用。
+     *
+     * @return long 返回符合查询条件的数据总条数，用于后续的分页逻辑处理。
+     */
+    @Override
+    public long getTotal() {
+        return this.total;
+    }
+
+    /**
+     * 重写了父类Page中设置数据总条数的方法，将传入的总条数赋值给当前对象的total属性，并返回当前对象（this），方便进行链式调用，
+     * 用于在获取到准确的总条数后更新对象中的相关信息，例如在执行完count查询后更新总条数用于后续的分页展示等操作。
+     *
+     * @param total 要设置的数据总条数，通过数据库查询或其他方式统计得到的符合条件的数据记录总数。
+     * @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
+     */
+    @Override
+    public Page<T> setTotal(long total) {
+        this.total = total;
+        return this;
+    }
+
+    /**
+     * 获取是否进行count查询的方法，在原有的isSearchCount属性基础上进行了额外的判断逻辑。
+     * 如果数据总条数（total属性）小于0，则返回false，表示不进行count查询（可能是因为数据不符合要求等情况）；
+     * 否则返回isSearchCount属性的值，即按照默认或之前设置的值来确定是否进行count查询，用于在分页查询前根据实际情况灵活决定是否需要统计总数。
+     *
+     * @return boolean 返回是否进行count查询的结果，true表示进行count查询，false表示不进行，根据具体情况判断。
+     */
+    @JsonIgnore
+    public boolean getSearchCount() {
+        if (total < 0) {
+            return false;
+        }
+        return isSearchCount;
+    }
+
+    /**
+     * 重写了父类Page中设置是否进行count查询的方法，将传入的布尔值赋值给当前对象的isSearchCount属性，并返回当前对象（this），方便进行链式调用，
+     * 用于在业务逻辑中根据不同需求动态设置是否需要进行count查询操作，例如在某些特定条件下不需要统计总数时可以通过该方法进行设置。
+     *
+     * @param isSearchCount 要设置的是否进行count查询的布尔值，true表示进行，false表示不进行。
+     * @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
+     */
+    @Override
+    public Page<T> setSearchCount(boolean isSearchCount) {
+        this.isSearchCount = isSearchCount;
+        return this;
+    }
+
+    /**
+     * 重写了父类Page中获取每页显示条数的方法，返回当前对象中存储的每页显示条数（size属性），用于在分页相关的计算（如计算偏移量等）以及业务判断中使用。
+     *
+     * @return long 返回每页显示的数据记录数量，按照默认值或之前设置的值来确定，可用于后续的分页逻辑处理。
+     */
+    @Override
+    public long getSize() {
+        return this.size;
+    }
+
+    /**
+     * 重写了父类Page中设置每页显示条数的方法，对传入的每页显示条数进行了限制处理。
+     * 如果传入的每页显示条数（size参数）大于预先设定的最大限制值（这里设置为100），则将当前对象的size属性设置为最大限制值（100），避免每页显示过多数据；
+     * 否则将传入的size值赋值给当前对象的size属性，用于在业务逻辑中根据实际需求动态设置每页显示的合理数量，然后返回当前对象（this）方便进行链式调用。
+     *
+     * @param size 要设置的每页显示条数，通过前端传入或业务逻辑指定的每页希望展示的数据记录数量。
+     * @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
+     */
+    @Override
+    public Page<T> setSize(long size) {
+        int maxSize = 100;
+        if (size > maxSize) {
+            this.size = maxSize;
+        } else {
+            this.size = size;
+        }
+        return this;
+    }
+
+    /**
+     * 重写了父类Page中获取当前页的方法，返回当前对象中存储的当前页（current属性），用于在分页相关的计算（如计算偏移量等）以及业务判断中使用。
+     *
+     * @return long 返回当前所处的页码，按照默认值或之前设置的值来确定，可用于后续的分页逻辑处理。
+     */
+    @Override
+    public long getCurrent() {
+        return this.current;
+    }
+
+    /**
+     * 重写了父类Page中设置当前页的方法，将传入的当前页数值赋值给当前对象的current属性，并返回当前对象（this），方便进行链式调用，
+     * 用于在业务逻辑中根据实际需求动态设置当前所处的页码，例如响应前端传入的页码切换请求等操作。
+     *
+     * @param current 要设置的当前页数值，通过前端传入或业务逻辑指定的当前希望展示的页码。
+     * @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
+     */
+    @Override
+    public Page<T> setCurrent(long current) {
+        this.current = current;
+        return this;
+    }
+}

yami-shop-security/yami-shop-security-admin/src/main/java/com/yami/shop/security/admin/dto/CaptchaAuthenticationDTO.java

@@ -0,0 +1,27 @@
+package com.yami.shop.security.admin.dto;
+
+import com.yami.shop.security.common.dto.AuthenticationDTO;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+/**
+ * CaptchaAuthenticationDTO类用于表示验证码登录相关的数据传输对象（DTO）。
+ * 它继承自AuthenticationDTO类，意味着会继承其原有的一些与认证相关的通用属性和方法等。
+ * 此类专门用于在涉及验证码登录的场景中，传递包含验证码信息在内的登录相关数据，
+ * 比如从前端接收用户输入的验证码以及其他必要的认证信息，再传递到后端进行相应的登录验证处理等操作。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/28 14:57
+ */
+@Data
+public class CaptchaAuthenticationDTO extends AuthenticationDTO {
+
+    /**
+     * captchaVerification属性用于存储用户输入的验证码信息。
+     * 通过@Schema注解对该属性在Swagger文档中的展示进行了描述说明，
+     * 指明此属性的描述为“验证码”，并且在相关的请求等场景中是必须提供的（required = true），
+     * 以便后端服务可以获取该验证码并与系统生成的验证码进行比对等验证操作。
+     */
+    @Schema(description = "验证码", required = true)
+    private String captchaVerification;
+}

yami-shop-security/yami-shop-security-api/src/main/java/com/yami/shop/security/api/controller/LoginController.java

@@ -0,0 +1,136 @@
+package com.yami.shop.security.api.controller;
+
+// 导入MyBatis Plus框架中用于构建条件查询的核心类，方便编写数据库查询条件，此处用于查询用户信息
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+// 导入项目中自定义的用户实体类，代表数据库中存储的用户相关信息，包含各种用户属性，如用户名、手机号、密码等
+import com.yami.shop.bean.model.User;
+// 导入项目自定义的业务异常类，用于在业务逻辑出现特定错误情况时抛出异常，方便统一处理和向客户端返回错误信息
+import com.yami.shop.common.exception.YamiShopBindException;
+// 导入项目自定义的工具类，可能包含一些通用的业务逻辑处理方法，此处具体功能需看其内部实现（从名字推测和主体逻辑相关）
+import com.yami.shop.common.util.PrincipalUtil;
+// 导入项目中定义的用于操作数据库中用户表的Mapper接口，通过它可以调用数据库相关的查询、插入等操作方法（由MyBatis框架生成实现类来具体执行SQL操作）
+import com.yami.shop.dao.UserMapper;
+// 导入与安全相关的业务对象类，用于封装在Token中存储的用户信息，方便在不同模块间传递和使用用户相关数据
+import com.yami.shop.security.common.bo.UserInfoInTokenBO;
+// 导入与安全相关的用于接收登录认证信息的数据传输对象（DTO）类，包含用户名、密码以及用户所属系统类型等信息，用于接收前端传入的登录数据
+import com.yami.shop.security.common.dto.AuthenticationDTO;
+// 导入与安全相关的枚举类，用于区分不同的系统类型，此处有个普通用户类型（ORDINARY），可能还有其他类型用于不同业务场景下的用户分类
+import com.yami.shop.security.common.enums.SysTypeEnum;
+// 导入与安全相关的用于密码检查的管理类，可能包含验证密码是否符合规则、检查密码错误次数等逻辑，保障登录密码的安全性
+import com.yami.shop.security.common.manager.PasswordCheckManager;
+// 导入与安全相关的用于密码管理的类，可能包含密码加密、解密等相关操作方法，确保密码在存储和传输过程中的安全性
+import com.yami.shop.security.common.manager.PasswordManager;
+// 导入与安全相关的用于管理Token存储和操作的类，负责生成、存储Token以及基于用户信息获取相应的Token相关信息等功能
+import com.yami.shop.security.common.manager.TokenStore;
+// 导入与安全相关的用于返回给前端包含Token信息的视图对象（VO）类，将后端处理后的Token相关数据以合适的格式返回给前端展示和后续使用
+import com.yami.shop.security.common.vo.TokenInfoVO;
+// 导入Swagger相关的注解，用于生成API文档，@Tag注解用于给接口分类添加标签，方便文档中进行分组展示和说明
+import io.swagger.v3.oas.annotations.tags.Tag;
+// 导入Swagger相关的注解，用于在API文档中描述接口的功能摘要和详细信息，方便前端开发人员等查看接口的作用和使用方式
+import io.swagger.v3.oas.annotations.Operation;
+// 导入Spring框架用于实现依赖注入的注解，表明后续的属性需要由Spring容器进行注入实例化
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入项目自定义的用于封装服务器响应信息的实体类，包含响应状态码、消息、数据等内容，用于统一向客户端返回响应结果
+import com.yami.shop.common.response.ServerResponseEntity;
+// 导入Spring框架用于定义处理POST请求的注解，将下面的方法映射为一个接收POST请求的接口，处理对应的业务逻辑
+import org.springframework.web.bind.annotation.PostMapping;
+// 导入Spring框架用于接收请求体数据并将其绑定到方法参数的注解，确保前端传入的JSON等格式的数据能正确映射到对应的参数对象上
+import org.springframework.web.bind.annotation.RequestBody;
+// 导入Spring框架用于将类标记为RESTful风格的控制器的注解，表明该类中的方法主要用于处理HTTP请求并返回JSON等格式的响应数据
+import org.springframework.web.bind.annotation.RestController;
+
+// 导入Jakarta验证相关的注解，用于对传入的参数对象进行数据校验，确保参数符合一定的规则，比如非空等要求
+import jakarta.validation.Valid;
+
+/**
+ * LoginController类是一个Spring RESTful风格的控制器类，主要负责处理用户登录相关的业务逻辑，
+ * 通过接收前端传入的登录认证信息（用户名、密码以及用户所属系统类型等），验证用户信息的合法性，
+ * 包括检查用户是否存在、密码是否正确以及密码错误次数是否超限等情况，若验证通过则生成并返回对应的Token信息给前端，
+ * 方便后续的用户鉴权以及其他需要身份验证的业务操作，同时使用Swagger注解生成相关的API文档，便于接口的查看和使用说明。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/28 15:20
+ */
+@RestController
+@Tag(name = "登录")
+public class LoginController {
+
+    // 通过Spring的依赖注入机制，注入一个TokenStore实例，用于管理Token的存储、生成以及获取相关信息等操作
+    @Autowired
+    private TokenStore tokenStore;
+
+    // 注入一个UserMapper实例，用于调用数据库中用户表相关的查询、操作方法，以便获取用户信息进行登录验证等操作
+    @Autowired
+    private UserMapper userMapper;
+
+    // 注入一个PasswordCheckManager实例，用于对用户输入的密码进行各种检查，如密码错误次数限制等安全相关的验证操作
+    @Autowired
+    private PasswordCheckManager passwordCheckManager;
+
+    // 注入一个PasswordManager实例，用于对密码进行加密、解密等管理操作，此处主要用于解密前端传入的密码进行后续验证
+    @Autowired
+    private PasswordManager passwordManager;
+
+    /**
+     * 处理用户登录请求的接口方法，接收前端传入的经过验证的登录认证信息（通过@Valid注解确保数据格式符合要求），
+     * 首先根据传入的用户名（可能是手机号或者用户名）查找对应的用户信息，然后解密前端传入的密码，
+     * 接着检查密码是否正确以及是否达到密码错误次数限制，若一切验证通过，则构建用户在Token中存储的信息对象，
+     * 通过TokenStore生成并存储Token，获取相应的Token信息视图对象（TokenInfoVO）返回给前端，告知登录成功以及返回Token相关信息。
+     *
+     * @param authenticationDTO 经过验证的登录认证信息对象，包含用户名、密码以及用户所属系统类型等信息，由前端传入，通过请求体（@RequestBody）接收并绑定到该参数上
+     * @return ServerResponseEntity<TokenInfoVO> 返回一个包含Token信息视图对象（TokenInfoVO）的服务器响应实体，若登录成功则状态码为成功状态，包含有效的Token信息返回给前端；若出现异常则返回相应的错误状态和提示信息
+     */
+    @PostMapping("/login")
+    @Operation(summary = "账号密码(用于前端登录)", description = "通过账号/手机号/用户名密码登录，还要携带用户的类型，也就是用户所在的系统")
+    public ServerResponseEntity<TokenInfoVO> login(
+            @Valid @RequestBody AuthenticationDTO authenticationDTO) {
+
+        // 从登录认证信息对象中获取用户名（可能是手机号或者普通用户名形式），用于后续查找用户信息
+        String mobileOrUserName = authenticationDTO.getUserName();
+        // 根据获取到的用户名查找对应的用户信息，若找不到则会抛出异常告知账号或密码不正确
+        User user = getUser(mobileOrUserName);
+
+        // 通过PasswordManager对前端传入的密码进行解密操作，获取解密后的密码，以便后续和数据库中存储的密码进行比对验证
+        String decryptPassword = passwordManager.decryptPassword(authenticationDTO.getPassWord());
+
+        // 通过PasswordCheckManager检查密码是否正确以及是否达到密码错误次数限制（半小时内密码输入错误十次，已限制登录30分钟），若不符合要求会抛出相应异常进行处理
+        passwordCheckManager.checkPassword(SysTypeEnum.ORDINARY, authenticationDTO.getUserName(), decryptPassword, user.getLoginPassword());
+
+        // 创建一个用于在Token中存储用户信息的业务对象，将用户的ID、所属系统类型以及是否启用等信息设置进去，用于后续生成Token以及存储相关用户标识信息
+        UserInfoInTokenBO userInfoInToken = new UserInfoInTokenBO();
+        userInfoInToken.setUserId(user.getUserId());
+        userInfoInToken.setSysType(SysTypeEnum.ORDINARY.value());
+        userInfoInToken.setEnabled(user.getStatus() == 1);
+
+        // 通过TokenStore存储用户信息并生成Token，同时获取包含Token相关信息的视图对象（TokenInfoVO），用于返回给前端告知登录成功以及提供后续鉴权等所需的Token信息
+        TokenInfoVO tokenInfoVO = tokenStore.storeAndGetVo(userInfoInToken);
+        return ServerResponseEntity.success(tokenInfoVO);
+    }
+
+    /**
+     * 根据传入的用户名（可能是手机号或者用户名）查找对应的用户信息的私有方法，
+     * 首先判断传入的用户名是否符合手机号格式，如果是则通过手机号在数据库中查找用户信息；
+     * 如果通过手机号没找到用户，则再尝试通过用户名在数据库中查找用户；
+     * 如果最终还是没找到对应的用户，则抛出自定义的业务异常（YamiShopBindException）告知账号或密码不正确。
+     *
+     * @param mobileOrUserName 要查找用户信息对应的用户名，可能是手机号或者普通用户名形式
+     * @return User 返回查找到的用户信息对象，如果没找到则抛出异常，不会返回null
+     */
+    private User getUser(String mobileOrUserName) {
+        User user = null;
+        // 通过PrincipalUtil工具类判断传入的用户名是否符合手机号格式，如果是则进行下一步操作（通过手机号查找用户）
+        if (PrincipalUtil.isMobile(mobileOrUserName)) {
+            // 使用MyBatis Plus构建的条件查询对象（LambdaQueryWrapper），根据手机号在数据库中查找对应的用户信息，通过UserMapper调用数据库查询方法
+            user = userMapper.selectOne(new LambdaQueryWrapper<User>().eq(User::getUserMobile, mobileOrUserName));
+        }
+        // 如果通过手机号没找到用户（即user为null），则尝试通过用户名在数据库中查找用户
+        if (user == null) {
+            user = userMapper.selectOneByUserName(mobileOrUserName);
+        }
+        // 如果最终还是没找到对应的用户，则抛出自定义的业务异常，告知账号或密码不正确
+        if (user == null) {
+            throw new YamiShopBindException("账号或密码不正确");
+        }
+        return user;
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/AuthConfigAdapter.java

@@ -0,0 +1,37 @@
+package com.yami.shop.security.common.adapter;
+
+import java.util.List;
+
+/**
+ * 该接口用于配置授权相关的路径信息，实现此接口后，能够方便地修改需要授权登录的路径以及不需要授权登录的路径。
+ * 它为应用的权限控制中关于路径的授权配置提供了一种规范和扩展点，使得不同的应用场景可以根据自身需求灵活定义哪些路径需要授权，哪些不需要。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:31
+ */
+public interface AuthConfigAdapter {
+
+    /**
+     * 定义了一个字符串常量，表示可能需要登录才可用的URL的路径匹配模式。
+     * 这里的 "/**/ma/**" 是一种通配符形式的路径表达式，意味着以任意多级目录开始，中间包含 "ma" 子目录的路径都可能需要登录才能访问。
+     * 实际应用中可根据具体的业务逻辑和权限控制需求对该通配符表达式进行调整或替换。
+     */
+    String MAYBE_AUTH_URI = "/**/ma/**";
+
+    /**
+     * 获取需要授权登录的路径列表。
+     * 实现该接口的类需要通过具体的逻辑来确定并返回哪些路径是要求用户必须进行授权登录后才能访问的。
+     * 例如，可能会根据业务模块、功能权限等因素来收集相应的路径集合。
+     *
+     * @return 需要授权登陆的路径列表，列表中的每个元素为一个具体的路径表达式（通常采用类似通配符等格式来表示一批路径）
+     */
+    List<String> pathPatterns();
+
+    /**
+     * 获取不需要授权登录的路径列表。
+     * 同样，实现此接口的类要依据业务规则来明确哪些路径是无需用户授权登录就能直接访问的，比如一些公开的页面（如登录页面、注册页面、网站首页等常规对外公开的资源路径）。
+     *
+     * @return 不需要授权登陆的路径列表，列表中的元素为具体的不需要授权的路径表达式
+     */
+    List<String> excludePathPatterns();
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/CaptchaCacheServiceRedisImpl.java

@@ -0,0 +1,79 @@
+package com.yami.shop.security.common.adapter;
+
+import com.anji.captcha.service.CaptchaCacheService;
+import com.yami.shop.common.util.RedisUtil;
+
+/**
+ * CaptchaCacheServiceRedisImpl类的主要作用是将验证码相关的数据存储适配到Redis中。
+ * 它实现了CaptchaCacheService接口，意味着需要按照该接口定义的方法规范来实现具体的功能，
+ * 从而为验证码服务提供基于Redis的缓存操作功能，例如存储验证码、判断验证码是否存在、删除验证码以及获取验证码等操作，
+ * 使得验证码相关的数据可以在Redis中进行有效的管理和操作。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+public class CaptchaCacheServiceRedisImpl implements CaptchaCacheService {
+
+    /**
+     * 此方法用于将指定的键值对存储到Redis中，并设置过期时间（以秒为单位）。
+     * 它调用了RedisUtil工具类中的set方法来实际执行向Redis存储数据的操作，
+     * 将传入的键（key）、值（value）以及过期时间（expiresInSeconds）传递给RedisUtil的对应方法进行处理。
+     *
+     * @param key 要存储到Redis中的键，用于唯一标识验证码相关的数据。
+     * @param value 要存储到Redis中的值，通常为验证码的具体内容等相关信息。
+     * @param expiresInSeconds 数据在Redis中的过期时间，单位为秒，超过这个时间后数据将自动从Redis中删除。
+     */
+    @Override
+    public void set(String key, String value, long expiresInSeconds) {
+        RedisUtil.set(key, value, expiresInSeconds);
+    }
+
+    /**
+     * 此方法用于判断在Redis中是否存在指定的键对应的验证码数据。
+     * 通过调用RedisUtil工具类中的hasKey方法来实现判断逻辑，
+     * 如果Redis中存在该键，则表示对应的验证码数据存在，返回true；否则返回false。
+     *
+     * @param key 要检查其是否存在的键，对应着可能存储在Redis中的验证码相关数据的标识。
+     * @return 如果Redis中存在该键对应的验证码数据，则返回true；否则返回false。
+     */
+    @Override
+    public boolean exists(String key) {
+        return RedisUtil.hasKey(key);
+    }
+
+    /**
+     * 此方法用于从Redis中删除指定键对应的验证码数据。
+     * 调用RedisUtil工具类中的del方法来执行从Redis中删除数据的实际操作，
+     * 使得对应的验证码相关信息在Redis中被移除，不再占用存储空间。
+     *
+     * @param key 要从Redis中删除其对应数据的键，即要删除的验证码相关数据在Redis中的标识。
+     */
+    @Override
+    public void delete(String key) {
+        RedisUtil.del(key);
+    }
+
+    /**
+     * 此方法用于从Redis中获取指定键对应的验证码数据的值（通常就是验证码的具体内容）。
+     * 借助RedisUtil工具类中的get方法来实现从Redis中查找并返回对应值的功能，
+     * 如果键存在，则返回对应的验证码数据的值；如果不存在，则返回相应的默认值（根据RedisUtil的实现来确定）。
+     *
+     * @param key 要从Redis中获取其对应值的键，即要获取的验证码相关数据在Redis中的标识。
+     * @return 从Redis中获取到的指定键对应的验证码数据的值，如果键不存在则返回相应结果（由RedisUtil决定）。
+     */
+    @Override
+    public String get(String key) {
+        return RedisUtil.get(key);
+    }
+
+    /**
+     * 此方法用于返回当前缓存服务所使用的存储类型，在这里明确返回“redis”，
+     * 表明本实现类是将验证码相关数据存储在Redis中的，方便外部代码知晓和区分不同的缓存存储实现方式。
+     *
+     * @return 始终返回“redis”，表示该缓存服务基于Redis进行数据存储。
+     */
+    @Override
+    public String type() {
+        return "redis";
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/DefaultAuthConfigAdapter.java

@@ -0,0 +1,53 @@
+package com.yami.shop.security.common.adapter;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * DefaultAuthConfigAdapter类实现了AuthConfigAdapter接口，主要用于配置认证相关的路径规则。
+ * 它定义了哪些路径需要进行认证（通过pathPatterns方法）以及哪些路径不需要进行认证（通过excludePathPatterns方法），
+ * 在整个应用的安全认证体系中起着路径筛选和配置的作用。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+public class DefaultAuthConfigAdapter implements AuthConfigAdapter {
+    // 创建一个日志记录器，用于记录与该类相关的日志信息，方便在运行时排查问题、了解类的执行情况等，这里记录器的名称为DefaultAuthConfigAdapter类的全限定名
+    private static final Logger logger = LoggerFactory.getLogger(DefaultAuthConfigAdapter.class);
+
+    /**
+     * 构造方法，在实例化DefaultAuthConfigAdapter对象时会被调用。
+     * 此构造方法中主要通过日志记录器输出一条信息，提示没有实现其他的AuthConfigAdapter，当前使用的是DefaultAuthConfigAdapter，
+     * 并且表示所有的URL都需要进行认证（这是基于当前默认实现的规则设定，具体可能根据业务需求在子类中进行重写来改变）。
+     */
+    public DefaultAuthConfigAdapter() {
+        logger.info("not implement other AuthConfigAdapter, use DefaultAuthConfigAdapter... all url need auth...");
+    }
+
+    /**
+     * pathPatterns方法实现了AuthConfigAdapter接口中定义的方法，用于返回需要进行认证的路径模式列表。
+     * 在当前的默认实现中，返回一个包含通配符“/*”的列表，表示所有的路径都需要进行认证，
+     * 当然，具体的业务场景下如果有更精细的认证路径需求，可以通过继承该类并重写此方法来实现不同的路径配置。
+     *
+     * @return 返回一个List<String>类型的列表，其中元素为需要进行认证的路径模式，当前默认返回包含“/*”的列表，表示所有路径。
+     */
+    @Override
+    public List<String> pathPatterns() {
+        return Collections.singletonList("/*");
+    }
+
+    /**
+     * excludePathPatterns方法同样是实现AuthConfigAdapter接口定义的方法，用于返回不需要进行认证的路径模式列表。
+     * 在当前默认实现中，返回一个空的列表，表示没有任何路径被排除在认证之外，即所有路径都按照pathPatterns方法定义的规则进行认证，
+     * 同样，可根据实际业务需求在子类中重写此方法来指定特定的不需要认证的路径。
+     *
+     * @return 返回一个List<String>类型的列表，其中元素为不需要进行认证的路径模式，当前默认返回空列表，表示无排除路径。
+     */
+    @Override
+    public List<String> excludePathPatterns() {
+        return Collections.emptyList();
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/MallWebSecurityConfigurerAdapter.java

@@ -0,0 +1,59 @@
+package com.yami.shop.security.common.adapter;
+
+// 导入Spring框架中用于将方法标记为创建Bean的注解，通过该注解定义的方法返回的对象会被Spring容器管理，可在其他地方进行注入使用
+import org.springframework.context.annotation.Bean;
+// 导入Spring Security框架中用于配置基于Web的安全相关设置的类，通过链式调用的方式可以配置如认证、授权、跨域、会话管理等多个方面的安全策略
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+// 导入Spring Security框架中用于启用Web安全功能的注解，表明在当前应用中要开启Spring Security相关的Web安全配置机制
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+// 导入Spring Security框架中用于定义会话创建策略的枚举类，此处配置为无状态（STATELESS）会话策略，适用于基于Token的认证方式
+import org.springframework.security.config.http.SessionCreationPolicy;
+// 导入Spring Security框架中用于构建安全过滤链的核心接口，配置好的安全规则最终会形成这样一个过滤链来处理进入应用的请求，进行安全相关的检查和过滤操作
+import org.springframework.security.web.SecurityFilterChain;
+// 导入Spring框架中用于将类标记为组件的注解，表明该类是一个Spring管理的组件，会被自动扫描并实例化，可在其他地方进行依赖注入使用
+import org.springframework.stereotype.Component;
+// 导入Spring框架中用于处理跨域相关的工具类，此处用于判断请求是否是跨域预检请求（OPTIONS请求），以便对不同类型请求做不同的授权处理
+import org.springframework.web.cors.CorsUtils;
+
+/**
+ * MallWebSecurityConfigurerAdapter类主要用于配置Spring Security在Web应用中的安全策略，
+ * 其特点是利用了Spring Security的防火墙等安全相关功能，但并不使用Spring Security自带的认证授权登录机制，
+ * 而是自行处理认证授权逻辑（可能通过其他自定义方式，比如基于Token的方式等），在这个类中重点配置了如跨域、会话管理以及请求的授权规则等方面的内容，
+ * 通过定义SecurityFilterChain来构建整个安全过滤链，使得进入应用的请求按照设定的规则进行相应的安全处理。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+@Component
+@EnableWebSecurity
+public class MallWebSecurityConfigurerAdapter {
+
+    /**
+     * 定义一个名为filterChain的方法，并通过@Bean注解将其返回的SecurityFilterChain对象交由Spring容器管理，成为一个可被注入使用的Bean。
+     * 这个方法用于构建安全过滤链，配置了一系列的安全相关规则，具体如下：
+     *
+     * @param http HttpSecurity对象，用于以链式调用的方式配置基于HTTP请求的安全策略，如认证、授权、跨域、会话管理等各个方面
+     * @return SecurityFilterChain 返回配置好的安全过滤链对象，该过滤链会应用到整个Web应用中，对进入的请求进行安全相关的处理和过滤
+     * @throws Exception 如果在配置HttpSecurity过程中出现异常（比如配置的规则不符合要求等情况），则会抛出异常，需要进行相应的处理
+     */
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+
+        // 关闭跨站请求伪造（CSRF）防护功能，因为基于Token的认证方式下通常不需要CSRF防护，Token本身就用于身份验证，可避免此类安全风险
+        return http.csrf().disable().cors()
+
+                // 配置跨域相关设置，启用跨域支持（后续可能还需要配置更具体的跨域规则等，这里只是开启了基本的支持），
+                // 接着配置会话管理相关内容，将会话创建策略设置为无状态（STATELESS），意味着服务器不会为客户端创建和维护会话状态，
+                // 适用于基于Token的认证场景，每次请求都通过携带Token来验证身份，服务器不依赖会话来识别客户端
+                .and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+
+                // 配置请求授权相关规则，对于跨域预检请求（OPTIONS请求，通过CorsUtils::isPreFlightRequest判断），允许所有的此类请求通过，
+                // 因为跨域预检请求主要是浏览器在正式发起跨域请求前进行的一种询问服务器是否允许跨域的请求，通常需要放行
+                .and().authorizeRequests().requestMatchers(CorsUtils::isPreFlightRequest).permitAll()
+
+                // 继续配置请求授权规则，对于所有其他请求（通过"/**"表示任意路径的请求），也都允许通过，这意味着在这个配置下，没有进行严格的基于Spring Security自带认证授权的访问限制，
+                // 可能后续会通过其他自定义的中间件或者业务逻辑来对请求进行更细致的权限判断等操作，此处只是简单放开了所有请求的访问权限
+                .and().authorizeRequests().requestMatchers(
+                        "/**").permitAll().and().build();
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/config/AuthConfig.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+package com.yami.shop.security.common.config;
+
+import cn.hutool.core.util.ArrayUtil;
+// 导入自定义的授权配置适配器类，用于适配不同的授权配置相关逻辑，可根据具体业务需求进行扩展或定制
+import com.yami.shop.security.common.adapter.AuthConfigAdapter;
+// 导入默认的授权配置适配器实现类，当没有自定义的授权配置适配器时，会使用这个默认的实现类来处理相关逻辑
+import com.yami.shop.security.common.adapter.DefaultAuthConfigAdapter;
+// 导入自定义的授权过滤器类，用于对请求进行授权相关的过滤操作，比如验证用户权限等
+import com.yami.shop.security.common.filter.AuthFilter;
+import jakarta.servlet.DispatcherType;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+
+/**
+ * 授权配置类，主要用于在Spring应用中配置授权相关的组件和规则。
+ * 这个类负责创建授权配置适配器以及注册授权过滤器等操作，以确保应用的授权功能能够正常工作。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+@Configuration
+// 启用方法级别的安全配置，允许在方法上使用诸如 @PreAuthorize、@PostAuthorize 等注解来进行权限控制
+@EnableMethodSecurity
+public class AuthConfig {
+    // 通过自动注入获取授权过滤器实例，该过滤器将在后续的配置中被注册到Servlet容器中，用于对请求进行过滤处理
+    @Autowired
+    private AuthFilter authFilter;
+
+    /**
+     * 创建授权配置适配器的Bean。
+     * 如果在Spring容器中没有找到自定义的AuthConfigAdapter类型的Bean，
+     * 则会创建并返回一个默认的授权配置适配器实例（DefaultAuthConfigAdapter），
+     * 这样可以方便地进行默认授权配置或者允许用户自定义授权配置来替换默认配置。
+     *
+     * @return AuthConfigAdapter实例，用于适配授权配置相关逻辑
+     */
+    @Bean
+    @ConditionalOnMissingBean
+    public AuthConfigAdapter authConfigAdapter() {
+        return new DefaultAuthConfigAdapter();
+    }
+
+
+    /**
+     * 创建并注册授权过滤器的FilterRegistrationBean。
+     * 这个方法会创建一个FilterRegistrationBean对象，用于将授权过滤器（AuthFilter）注册到Servlet容器中，
+     * 并配置相关的属性，比如过滤路径、过滤器名称、优先级以及处理的请求类型等。
+     * 这里使用了 @Lazy 注解，表示该Bean会延迟初始化，只有在第一次使用时才会真正创建实例，避免不必要的资源消耗。
+     *
+     * @param authConfigAdapter 授权配置适配器实例，用于获取过滤路径等配置信息
+     * @return FilterRegistrationBean<AuthFilter>对象，用于将授权过滤器注册到Servlet容器
+     */
+    @Bean
+    @Lazy
+    public FilterRegistrationBean<AuthFilter> filterRegistration(AuthConfigAdapter authConfigAdapter) {
+        FilterRegistrationBean<AuthFilter> registration = new FilterRegistrationBean<>();
+        // 将之前注入的授权过滤器添加到FilterRegistrationBean中，这样Servlet容器就能识别并使用该过滤器来处理请求了
+        registration.setFilter(authFilter);
+        // 设置过滤路径，通过授权配置适配器获取需要过滤的路径列表，并转换为字符串数组格式。
+        // 这里使用ArrayUtil工具类将获取到的路径列表转换为String数组，以便设置给FilterRegistrationBean，
+        // 表示该过滤器将会对这些指定的路径下的请求进行过滤处理，此处的 /* 表示所有路径，具体路径配置通常由授权配置适配器决定
+        registration.addUrlPatterns(ArrayUtil.toArray(authConfigAdapter.pathPatterns(), String.class));
+        registration.setName("authFilter");
+        // 设置过滤器的优先级，数值越小优先级越高，这里设置为0，表示较高的优先级，在多个过滤器存在的情况下会先执行该过滤器
+        registration.setOrder(0);
+        registration.setDispatcherTypes(DispatcherType.REQUEST);
+        return registration;
+    }
+
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/config/CaptchaConfig.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.security.common.config;
+
+import com.anji.captcha.model.common.CaptchaTypeEnum;
+import com.anji.captcha.model.common.Const;
+import com.anji.captcha.service.CaptchaService;
+import com.anji.captcha.service.impl.CaptchaServiceFactory;
+import com.anji.captcha.util.ImageUtils;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
+import org.springframework.util.Base64Utils;
+import org.springframework.util.FileCopyUtils;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * CaptchaConfig类是一个Spring的配置类（通过@Configuration注解标识），
+ * 主要用于配置验证码相关的服务以及处理验证码底图在Redis中的存储等相关操作。
+ * 如果出现获取验证码失败的情况，并且提示找管理员查看时，可重点检查Redis中验证码相关数据的存储情况，
+ * 因为此配置类涉及将验证码底图存入Redis的相关逻辑。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+@Configuration
+public class CaptchaConfig {
+
+    /**
+     * captchaService方法是一个Spring的Bean定义方法（通过@Bean注解标识），
+     * 用于创建并配置一个CaptchaService实例，该实例在验证码的生成、验证等流程中起着核心作用。
+     * 在这里，通过创建一个Properties对象来配置CaptchaService所需的各项参数，
+     * 然后使用这些配置参数通过CaptchaServiceFactory获取具体的CaptchaService实例。
+     *
+     * @return 返回配置好的CaptchaService实例，供Spring容器管理并在需要验证码服务的地方注入使用。
+     */
+    @Bean
+    public CaptchaService captchaService() {
+        Properties config = new Properties();
+        // 设置验证码的缓存类型为Redis，意味着验证码相关的数据（如底图等）将存储在Redis中
+        config.put(Const.CAPTCHA_CACHETYPE, "redis");
+        // 设置验证码的水印为空字符串，即不添加水印（具体根据验证码实现逻辑来定是否生效）
+        config.put(Const.CAPTCHA_WATER_MARK, "");
+        // 设置验证码的类型为滑动验证，这里使用了CaptchaTypeEnum枚举中BLOCKPUZZLE对应的代码值来指定
+        config.put(Const.CAPTCHA_TYPE, CaptchaTypeEnum.BLOCKPUZZLE.getCodeValue());
+        // 设置初始化原始图片相关的标志为true，具体含义取决于验证码服务内部对该参数的使用逻辑
+        config.put(Const.CAPTCHA_INIT_ORIGINAL, "true");
+        // 调用initializeBaseMap方法进行一些初始化操作，可能与验证码底图相关（比如预加载等）
+        initializeBaseMap();
+        return CaptchaServiceFactory.getInstance(config);
+    }
+
+    /**
+     * initializeBaseMap方法用于执行与验证码底图初始化相关的操作。
+     * 它调用了ImageUtils类的cacheBootImage方法，传递从指定路径获取的原始图片资源和滑动块图片资源，
+     * 以及一个空的Map（可能后续会根据业务逻辑在方法内部填充相关数据），
+     * 目的是将这些图片资源进行缓存处理（比如转换格式、存入特定缓存等，具体取决于ImageUtils的实现），
+     * 以便后续验证码生成等操作可以方便地使用这些底图资源。
+     */
+    private static void initializeBaseMap() {
+        ImageUtils.cacheBootImage(getResourcesImagesFile("classpath:captcha" + "/original/*.png"),
+                getResourcesImagesFile("classpath:captcha" + "/slidingBlock/*.png"),
+                Collections.emptyMap());
+    }
+
+    /**
+     * getResourcesImagesFile方法用于从指定的类路径下获取图片资源，并将其转换为Base64编码的字符串格式存储在一个Map中。
+     * 这个Map的键是图片的文件名，值是对应的Base64编码后的字符串，方便后续在内存中对图片资源进行管理和使用，
+     * 例如传递给其他方法用于验证码底图相关的处理等操作。
+     *
+     * @param path 表示要获取图片资源的类路径表达式，例如"classpath:captcha" + "/original/*.png"用于获取指定目录下的所有png格式的原始图片资源。
+     * @return 返回一个Map，其中包含了从指定路径获取到的图片文件名及其对应的Base64编码后的字符串表示形式。
+     */
+    public static Map<String, String> getResourcesImagesFile(String path) {
+        Map<String, String> imgMap = new HashMap<>(16);
+        // 创建一个PathMatchingResourcePatternResolver实例，用于解析类路径下的资源模式，能够匹配符合指定模式的多个资源文件
+        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
+
+        try {
+            // 根据传入的路径表达式获取对应的资源数组，即匹配该模式的所有图片资源文件
+            Resource[] resources = resolver.getResources(path);
+            // 遍历获取到的所有资源文件
+            Resource[] var4 = resources;
+            int var5 = resources.length;
+
+            for (int var6 = 0; var6 < var5; ++var6) {
+                Resource resource = var4[var6];
+                // 将资源文件的内容读取为字节数组，以便后续进行Base64编码操作
+                byte[] bytes = FileCopyUtils.copyToByteArray(resource.getInputStream());
+                // 将字节数组转换为Base64编码的字符串，使得图片数据可以以文本形式方便地在内存中存储和传输等
+                String string = Base64Utils.encodeToString(bytes);
+                // 获取资源文件的文件名，用于作为Map中的键来标识对应的Base64编码后的图片数据
+                String filename = resource.getFilename();
+                imgMap.put(filename, string);
+            }
+        } catch (Exception var11) {
+            // 如果在获取资源文件或处理过程中出现异常，打印异常堆栈信息，方便排查问题
+            var11.printStackTrace();
+        }
+
+        return imgMap;
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/config/CorsConfig.java

@@ -0,0 +1,61 @@
+package com.yami.shop.security.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+/**
+ * CorsConfig类是一个Spring的配置类（通过@Configuration注解标识），
+ * 其主要作用是配置跨域资源共享（CORS）相关的设置，以便在前后端分离的项目中，
+ * 解决浏览器的同源策略限制，使得不同域名（或端口等不同源情况）下的前端应用能够安全地访问后端接口。
+ *
+ * @author yami
+ */
+@Configuration
+public class CorsConfig {
+
+    /**
+     * corsConfigurationSource方法是一个Spring的Bean定义方法（通过@Bean注解标识），
+     * 用于创建并配置一个CorsConfigurationSource对象，该对象作为Spring Web中CORS配置的数据源，
+     * 定义了哪些来源（origins）的请求可以访问本应用的接口、允许的HTTP方法、请求头以及其他相关的跨域设置等信息。
+     *
+     * 注意事项：
+     *  - 对于生产环境，建议将配置中的通配符（*）修改为实际需要允许跨域访问的具体域名，
+     *    虽然通配符可以方便开发测试阶段允许所有来源访问，但在生产环境出于安全考虑，应精确配置。
+     *  - 可以通过多次调用addAllowedOrigin等方法配置多个允许跨域访问的域名，例如：
+     *    configuration.addAllowedOrigin("http://localhost:8080");
+     *    configuration.addAllowedOrigin("http://192.168.1.6:8080");
+     *
+     * @return 返回配置好的CorsConfigurationSource对象，供Spring Web在处理跨域请求时使用其配置信息。
+     */
+    @Bean
+    public CorsConfigurationSource corsConfigurationSource() {
+        // 创建一个CorsConfiguration对象，用于配置跨域相关的各种规则
+        CorsConfiguration configuration = new CorsConfiguration();
+        // 使用addAllowedOriginPattern方法添加允许跨域访问的来源模式，这里使用通配符（*）表示允许所有来源访问，
+        // 但需注意在生产环境应按实际情况修改为具体域名，可参考上面的注释说明。
+        configuration.addAllowedOriginPattern("*");
+        // 修改为添加（add）而不是设置（set）允许的HTTP方法，使用通配符（*）表示允许所有的HTTP方法（如GET、POST、PUT等），
+        // 这样前端可以使用各种类型的HTTP请求来访问后端接口。
+        configuration.addAllowedMethod("*");
+        // 这里配置允许的请求头，同样使用通配符（*）表示允许所有的请求头信息，
+        // 特别重要的是起码需要允许 Access-Control-Allow-Origin这个请求头，它与跨域访问的合法性验证密切相关。
+        configuration.addAllowedHeader("*");
+        // 设置是否允许发送Cookie等凭证信息，设置为true表示允许，
+        // 若前后端交互需要携带用户认证等相关凭证（如Cookie中的登录信息），则需要开启此项。
+        configuration.setAllowCredentials(true);
+        // 设置预检请求（OPTIONS请求）的缓存时间，单位为秒，这里设置为一天（3600 * 24秒），
+        // 在缓存有效期内，对于相同来源、方法和请求头的请求，浏览器不会再次发送预检请求，提高性能。
+        configuration.setMaxAge(3600 * 24L);
+
+        // 创建一个基于URL的CorsConfigurationSource对象，它可以根据不同的URL路径应用不同的CorsConfiguration配置。
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        // 将上面配置好的CorsConfiguration应用到所有路径（/**表示匹配所有的请求路径），
+        // 意味着所有的接口请求都会按照这个配置来处理跨域相关的规则。
+        source.registerCorsConfiguration("/**", configuration);
+
+        return source;
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/controller/CaptchaController.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.security.common.controller;
+
+import com.anji.captcha.model.common.RepCodeEnum;
+import com.anji.captcha.model.common.ResponseModel;
+import com.anji.captcha.model.vo.CaptchaVO;
+import com.anji.captcha.service.CaptchaService;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import com.yami.shop.common.response.ServerResponseEntity;
+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;
+
+/**
+ * CaptchaController类是一个Spring RESTful风格的控制器类（通过@RestController注解标识），
+ * 主要负责处理与验证码相关的HTTP请求，如获取验证码、验证验证码等操作。
+ * 它被映射到"/captcha"路径下（通过@RequestMapping注解配置），并且在Swagger文档中被标记为"验证码"相关的接口（通过@Tag注解定义），方便接口文档的展示和查看。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+@RestController
+@RequestMapping("/captcha")
+@Tag(name = "验证码")
+public class CaptchaController {
+
+    // 通过构造函数注入的方式引入CaptchaService，用于后续调用验证码相关的业务逻辑方法，比如生成验证码、验证验证码有效性等操作
+    private final CaptchaService captchaService;
+
+    public CaptchaController(CaptchaService captchaService) {
+        this.captchaService = captchaService;
+    }
+
+    /**
+     * get方法是一个处理HTTP POST请求的方法，用于获取验证码信息。
+     * 它接收一个CaptchaVO类型的请求体参数（通过@RequestBody注解标识），该参数包含了获取验证码时可能需要的一些配置信息或参数（具体取决于CaptchaVO的定义）。
+     * 方法内部调用captchaService的get方法来实际获取验证码相关的数据，并将获取到的结果包装在ServerResponseEntity中返回给客户端，
+     * 表示操作成功以及返回对应的验证码相关信息（如果成功获取的话）。
+     *
+     * @param captchaVO 包含获取验证码相关配置或参数的请求体对象。
+     * @return 返回一个ServerResponseEntity，其中包装了验证码服务获取到的ResponseModel类型的结果，向客户端表示操作成功并传递验证码相关数据。
+     */
+    @PostMapping({ "/get" })
+    public ServerResponseEntity<ResponseModel> get(@RequestBody CaptchaVO captchaVO) {
+        return ServerResponseEntity.success(captchaService.get(captchaVO));
+    }
+
+    /**
+     * check方法同样是一个处理HTTP POST请求的方法，用于验证客户端提交的验证码是否正确。
+     * 它也接收一个CaptchaVO类型的请求体参数，该参数包含了待验证的验证码以及可能相关的验证辅助信息（同样取决于CaptchaVO的定义）。
+     * 方法内部首先尝试调用captchaService的check方法来验证验证码，如果验证过程中没有出现异常，则将验证结果包装在ServerResponseEntity中返回给客户端，
+     * 表示验证操作成功以及返回对应的验证结果（如验证码是否正确等信息）。
+     * 如果在验证过程中出现异常，会捕获该异常，并返回一个表示验证码坐标错误的默认错误响应（通过ResponseModel.errorMsg方法构建对应错误消息的ResponseModel对象），
+     * 同样包装在ServerResponseEntity中返回给客户端，提示客户端验证码验证出现问题。
+     *
+     * @param captchaVO 包含待验证验证码及相关信息的请求体对象。
+     * @return 返回一个ServerResponseEntity，其中包装了验证码服务验证后的ResponseModel类型的结果，向客户端反馈验证操作的成功与否及相应信息。
+     */
+    @PostMapping({ "/check" })
+    public ServerResponseEntity<ResponseModel> check(@RequestBody CaptchaVO captchaVO) {
+        ResponseModel responseModel;
+        try {
+            responseModel = captchaService.check(captchaVO);
+        } catch (Exception e) {
+            return ServerResponseEntity.success(ResponseModel.errorMsg(RepCodeEnum.API_CAPTCHA_COORDINATE_ERROR));
+        }
+        return ServerResponseEntity.success(responseModel);
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/controller/LogoutController.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+package com.yami.shop.security.common.controller;
+
+// 导入Hutool工具库中用于字符串操作的工具类，此处用于判断字符串是否为空（空白字符串），方便进行逻辑判断
+import cn.hutool.core.util.StrUtil;
+// 导入项目自定义的用于封装服务器响应信息的实体类，包含响应状态码、消息、数据等内容，用于统一向客户端返回响应结果，此处响应数据为Void表示无具体数据返回
+import com.yami.shop.common.response.ServerResponseEntity;
+// 导入与安全相关的用于管理Token存储和操作的类，负责对Token进行删除等相关管理操作，此处用于删除用户的登录Token
+import com.yami.shop.security.common.manager.TokenStore;
+// 导入Swagger相关的注解，用于生成API文档，@Operation注解用于描述接口的功能摘要和详细信息，方便前端开发人员等查看接口的作用和使用方式
+import io.swagger.v3.oas.annotations.Operation;
+// 导入Swagger相关的注解，用于给接口分类添加标签，方便文档中进行分组展示和说明，此处标记为"注销"类别
+import io.swagger.v3.oas.annotations.tags.Tag;
+// 导入Spring框架用于实现依赖注入的注解，表明后续的属性需要由Spring容器进行注入实例化，此处用于注入TokenStore实例
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架用于定义处理POST请求的注解，将下面的方法映射为一个接收POST请求的接口，处理对应的业务逻辑，即处理用户退出登录的请求
+import org.springframework.web.bind.annotation.PostMapping;
+// 导入Spring框架用于将类标记为RESTful风格的控制器的注解，表明该类中的方法主要用于处理HTTP请求并返回JSON等格式的响应数据
+import org.springframework.web.bind.annotation.RestController;
+
+// 导入Servlet相关的用于操作HTTP请求的类，用于获取请求头中的信息，此处主要用于获取包含Token的"Authorization"请求头内容
+import jakarta.servlet.http.HttpServletRequest;
+
+/**
+ * LogoutController类是一个Spring RESTful风格的控制器类，主要负责处理用户退出登录相关的业务逻辑，
+ * 通过接收客户端发送的退出登录请求，获取请求头中的Token信息（如果存在），然后调用相关的Token管理组件（TokenStore）删除对应的Token，
+ * 实现清除用户登录状态以及可能相关的缓存（如菜单缓存等，具体依赖于业务实现）的功能，同时使用Swagger注解生成相关的API文档，便于接口的查看和使用说明。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+@RestController
+@Tag(name = "注销")
+public class LogoutController {
+
+    // 通过Spring的依赖注入机制，注入一个TokenStore实例，用于管理Token的删除等相关操作，以实现清除用户登录Token的功能
+    @Autowired
+    private TokenStore tokenStore;
+
+    /**
+     * 处理用户退出登录请求的接口方法，接收客户端发送的HTTP请求（通过HttpServletRequest对象获取请求相关信息），
+     * 首先尝试从请求头中获取名为"Authorization"的Token信息，如果获取到的Token信息为空（空白字符串），
+     * 则直接返回成功的服务器响应实体，表示可以直接视为已退出登录（可能本身就没有有效的登录状态）；
+     * 如果获取到了Token信息，则调用TokenStore的方法删除该用户对应的当前Token，然后返回成功的服务器响应实体，告知客户端已成功退出登录。
+     *
+     * @param request 包含客户端发送的退出登录请求相关信息的HttpServletRequest对象，用于获取请求头中的Token信息等操作
+     * @return ServerResponseEntity<Void> 返回一个服务器响应实体，响应数据类型为Void表示无具体数据返回，若成功退出登录则状态码为成功状态；若出现异常等情况，相关的异常处理机制会在更上层进行处理并返回合适的错误响应
+     */
+    @PostMapping("/logOut")
+    @Operation(summary = "退出登陆", description = "点击退出登陆，清除token，清除菜单缓存")
+    public ServerResponseEntity<Void> logOut(HttpServletRequest request) {
+        // 从请求头中获取名为"Authorization"的Token信息，通常在登录成功后，客户端会在后续请求的这个请求头中携带Token用于身份验证等操作
+        String accessToken = request.getHeader("Authorization");
+        // 通过Hutool工具类判断获取到的Token信息是否为空（空白字符串），如果为空则直接返回成功的服务器响应实体，表示可视为已退出登录（可能本身就没登录）
+        if (StrUtil.isBlank(accessToken)) {
+            return ServerResponseEntity.success();
+        }
+
+        // 如果获取到了有效的Token信息，则调用注入的TokenStore实例的方法，删除该用户在当前系统对应的Token，实现清除登录状态的功能
+        tokenStore.deleteCurrentToken(accessToken);
+        return ServerResponseEntity.success();
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/dto/AuthenticationDTO.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.security.common.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import jakarta.validation.constraints.NotBlank;
+
+/**
+ * 这个类是数据传输对象（DTO），主要用于在登录操作时传递账号和密码相关的信息。
+ * 它在系统的安全模块中扮演着重要角色，作为客户端与服务端之间传递登录凭证的载体，方便对登录信息进行统一的校验、处理和传递。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+@Data
+public class AuthenticationDTO {
+
+    /**
+     * 用于存储用户登录时输入的用户名信息。
+     * 这里的用户名可以是实际的用户名，也可以是用户注册时关联的邮箱地址或者手机号等能够唯一标识用户身份的信息，具体取决于系统的业务逻辑和认证规则。
+     * 并且通过 @NotBlank 注解进行了校验约束，要求该字段不能为空，若为空则会根据注解中配置的提示信息（"userName不能为空"）给出相应的错误提示。
+     * 同时使用 @Schema 注解在 API 文档相关的生成（如 Swagger 等工具生成 API 文档时）中描述该字段，表明它代表用户名/邮箱/手机号，且是必填项。
+     */
+    @NotBlank(message = "userName不能为空")
+    @Schema(description = "用户名/邮箱/手机号", required = true)
+    protected String userName;
+
+    /**
+     * 用于存储用户登录时输入的密码信息。
+     * 此密码是用户在注册账号或者设置安全凭证时设定的，用于验证用户身份合法性的关键信息之一。
+     * 同样受到 @NotBlank 注解的约束，不能为空，若为空会提示 "passWord不能为空" 的错误信息。
+     * @Schema 注解用于在 API 文档生成时描述该字段，表示一般用作密码，且是必填项。
+     */
+    @NotBlank(message = "passWord不能为空")
+    @Schema(description = "一般用作密码", required = true)
+    protected String passWord;
+
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/filter/AuthFilter.java

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+package com.yami.shop.security.common.filter;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.StrUtil;
+import com.yami.shop.common.exception.YamiShopBindException;
+import com.yami.shop.common.handler.HttpHandler;
+import com.yami.shop.common.response.ResponseEnum;
+import com.yami.shop.common.response.ServerResponseEntity;
+import com.yami.shop.security.common.adapter.AuthConfigAdapter;
+import com.yami.shop.security.common.bo.UserInfoInTokenBO;
+import com.yami.shop.security.common.manager.TokenStore;
+import com.yami.shop.security.common.util.AuthUserContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.springframework.util.AntPathMatcher;
+
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.FilterConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * 授权过滤类，主要负责对请求进行授权相关的校验过滤操作。
+ * 只要实现AuthConfigAdapter接口，添加对应路径即可实现灵活的授权路径配置，以此来控制哪些请求需要授权，哪些不需要授权访问。
+ * 它在整个系统的安全机制中处于关键位置，是保障系统资源按权限访问的重要防线。
+ *
+ * @author 菠萝凤梨
+ * @date 2022/3/25 17:33
+ */
+@Component
+public class AuthFilter implements Filter {
+
+    // 用于记录日志，方便在运行过程中输出相关的调试、错误等信息，便于排查问题
+    private static final Logger logger = LoggerFactory.getLogger(AuthFilter.class);
+
+    // 注入AuthConfigAdapter接口的实现类，通过它可以获取到配置的需要授权和不需要授权的路径信息
+    @Autowired
+    private AuthConfigAdapter authConfigAdapter;
+
+    // 注入HttpHandler，用于处理向Web端输出响应相关的操作，比如将服务器响应信息正确地返回给前端页面
+    @Autowired
+    private HttpHandler httpHandler;
+
+    // 注入TokenStore，主要用于管理和操作与令牌（Token）相关的存储及查询等功能，例如从存储中获取用户信息等
+    @Autowired
+    private TokenStore tokenStore;
+
+    // 通过配置文件注入令牌名称，用于后续从请求头中获取对应的令牌信息
+    @Value("${sa-token.token-name}")
+    private String tokenName;
+
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+        Filter.super.init(filterConfig);
+    }
+
+    /**
+     * 核心的过滤方法，对每个经过该过滤器的请求进行处理，判断是否需要授权等操作。
+     *
+     * @param request  当前的Servlet请求对象，在这里被转换为HttpServletRequest以获取更多HTTP相关的请求信息
+     * @param response 当前的Servlet响应对象，在这里被转换为HttpServletResponse用于后续向客户端返回响应
+     * @param chain    过滤器链，用于将请求传递给下一个过滤器或者最终的目标资源（如Servlet、JSP页面等）
+     * @throws IOException      如果在处理请求或响应的输入输出流时出现错误则抛出此异常
+     * @throws ServletException 如果在Servlet处理过程中出现其他异常则抛出此异常
+     */
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+            throws IOException, ServletException {
+        // 将ServletRequest转换为HttpServletRequest，方便获取HTTP请求相关的属性和信息，比如请求路径、请求头信息等
+        HttpServletRequest req = (HttpServletRequest) request;
+        // 将ServletResponse转换为HttpServletResponse，便于后续进行HTTP响应相关的操作，比如设置响应状态码、响应头、输出响应内容等
+        HttpServletResponse resp = (HttpServletResponse) response;
+
+        // 获取当前请求的URI（统一资源标识符），用于后续与配置的授权路径进行匹配判断
+        String requestUri = req.getRequestURI();
+
+        // 通过AuthConfigAdapter获取不需要授权的路径列表，用于判断当前请求是否命中这些无需授权的路径
+        List<String> excludePathPatterns = authConfigAdapter.excludePathPatterns();
+
+        // 创建AntPathMatcher对象，用于进行路径的匹配操作，它支持通配符等方式来灵活匹配路径
+        AntPathMatcher pathMatcher = new AntPathMatcher();
+        // 如果不需要授权的路径列表不为空，就遍历这些路径，检查当前请求的URI是否匹配其中某个无需授权的路径模式
+        if (CollectionUtil.isNotEmpty(excludePathPatterns)) {
+            for (String excludePathPattern : excludePathPatterns) {
+                // 使用AntPathMatcher进行路径匹配，如果匹配成功，说明当前请求是不需要授权的，直接将请求传递给下一个过滤器或目标资源
+                if (pathMatcher.match(excludePathPattern, requestUri)) {
+                    chain.doFilter(req, resp);
+                    return;
+                }
+            }
+        }
+
+        // 从请求头中获取名为tokenName的令牌信息，这个令牌通常用于验证用户的登录状态和权限等
+        String accessToken = req.getHeader(tokenName);
+        // 判断当前请求的URI是否匹配可能需要登录但不登录也能用的路径模式（通过AuthConfigAdapter中定义的常量路径进行匹配）
+        boolean mayAuth = pathMatcher.match(AuthConfigAdapter.MAYBE_AUTH_URI, requestUri);
+
+        // 用于存储从令牌中解析出来的用户信息，如果后续成功获取到用户信息则会赋值
+        UserInfoInTokenBO userInfoInToken = null;
+
+        try {
+            // 如果获取到的令牌信息不为空（即存在令牌），说明用户可能已经登录，需要进一步验证并获取用户信息
+            if (StrUtil.isNotBlank(accessToken)) {
+                // 使用StpUtil工具类来校验用户是否已经登录，若登录验证失败会抛出异常，在这里捕获异常并进行相应处理
+                try {
+                    StpUtil.checkLogin();
+                } catch (Exception e) {
+                    // 如果登录校验失败，通过HttpHandler将表示未授权的服务器响应信息输出到Web端（通常是返回给前端页面显示相应的错误提示）
+                    httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
+                    return;
+                }
+                // 如果登录校验通过，从TokenStore中根据令牌获取对应的用户信息（从缓存等存储中查询并解析用户信息）
+                userInfoInToken = tokenStore.getUserInfoByAccessToken(accessToken, true);
+            } else if (!mayAuth) {
+                // 如果没有令牌且当前请求也不属于可能不需要登录就能访问的路径，那么说明该请求需要授权但未提供有效令牌，返回表示未授权的响应给前端
+                httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
+                return;
+            }
+            // 将获取到的用户信息保存到AuthUserContext中，方便在后续的请求处理过程中（比如在其他地方需要获取当前登录用户信息时）可以直接获取
+            AuthUserContext.set(userInfoInToken);
+
+            // 如果前面的授权校验等操作都通过了，将请求传递给下一个过滤器或者最终的目标资源（如业务处理的Servlet等）继续处理
+            chain.doFilter(req, resp);
+
+        } catch (Exception e) {
+            // 手动捕获非controller层抛出的异常，进行统一处理
+            if (e instanceof YamiShopBindException) {
+                // 如果是YamiShopBindException类型的异常，通过HttpHandler将该异常对应的响应信息输出到Web端
+                httpHandler.printServerResponseToWeb((YamiShopBindException) e);
+            } else {
+                // 如果是其他类型的异常，直接抛出，让上层的异常处理机制（比如容器的异常处理）去进一步处理
+                throw e;
+            }
+        } finally {
+            // 无论请求处理过程是否出现异常，最终都要清理AuthUserContext中的用户信息，避免数据残留影响下一次请求处理
+            AuthUserContext.clean();
+        }
+    }
+
+    @Override
+    public void destroy() {
+        Filter.super.destroy();
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/manager/PasswordManager.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+package com.yami.shop.security.common.manager;
+
+import cn.hutool.crypto.symmetric.AES;
+import com.yami.shop.common.exception.YamiShopBindException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * @author 菠萝凤梨
+ * @date 2022/1/19 16:02
+ */
+@Component
+public class PasswordManager {
+    private static final Logger logger = LoggerFactory.getLogger(PasswordManager.class);
+
+    /**
+     * 用于aes签名的key，16位
+     */
+    @Value("${auth.password.signKey:-mall4j-password}")
+    public String passwordSignKey;
+
+    public String decryptPassword(String data) {
+        // 在使用oracle的JDK时，JAR包必须签署特殊的证书才能使用。
+        // 解决方案 1.使用openJDK或者非oracle的JDK（建议） 2.添加证书
+        // hutool的aes报错可以打开下面那段代码
+        // SecureUtil.disableBouncyCastle();
+        AES aes = new AES(passwordSignKey.getBytes(StandardCharsets.UTF_8));
+        String decryptStr;
+        String decryptPassword;
+        try {
+            decryptStr = aes.decryptStr(data);
+            decryptPassword = decryptStr.substring(13);
+        } catch (Exception e) {
+            logger.error("Exception:", e);
+            throw new YamiShopBindException("AES解密错误", e);
+        }
+        return decryptPassword;
+    }
+}

yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/util/AuthUserContext.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+package com.yami.shop.security.common.util;
+
+import com.alibaba.ttl.TransmittableThreadLocal;
+import com.yami.shop.security.common.bo.UserInfoInTokenBO;
+
+/**
+ * 这个类主要用于管理当前用户在整个线程上下文中的相关信息（具体是存储从令牌中解析出来的用户信息）。
+ * 它利用了 `TransmittableThreadLocal` 来实现线程间的数据传递，方便在不同的代码位置都能获取到当前登录用户的相关信息，
+ * 在整个系统的权限验证及业务处理流程中起着传递用户上下文信息的重要作用。
+ *
+ * @author FrozenWatermelon
+ * @date 2020/7/16
+ */
+public class AuthUserContext {
+
+    // 使用 `TransmittableThreadLocal` 来创建一个线程本地变量，用于存储 `UserInfoInTokenBO` 类型的用户信息对象。
+    // `TransmittableThreadLocal` 相较于普通的 `ThreadLocal` 具有能在线程间传递数据的优势，
+    // 适合在多线程环境下（比如异步调用、线程池场景等）保证用户信息的正确传递和共享。
+    private static final ThreadLocal<UserInfoInTokenBO> USER_INFO_IN_TOKEN_HOLDER = new TransmittableThreadLocal<>();
+
+    /**
+     * 获取存储在当前线程上下文中的用户信息对象（从令牌中解析出的用户信息）。
+     * 通过调用 `USER_INFO_IN_TOKEN_HOLDER` 的 `get` 方法来获取对应的 `UserInfoInTokenBO` 对象，
+     * 如果当前线程上下文中没有设置该信息，则会返回 `null`。
+     *
+     * @return 当前线程上下文中存储的 `UserInfoInTokenBO` 对象，代表从令牌中解析出的用户信息，可能为 `null`。
+     */
+    public static UserInfoInTokenBO get() {
+        return USER_INFO_IN_TOKEN_HOLDER.get();
+    }
+
+    /**
+     * 设置当前线程上下文中的用户信息对象（将从令牌中解析出的用户信息存入线程本地变量中）。
+     * 调用 `USER_INFO_IN_TOKEN_HOLDER` 的 `set` 方法来保存传入的 `UserInfoInTokenBO` 对象，
+     * 这样在当前线程后续的执行过程中，其他地方可以通过 `get` 方法获取到这个设置好的用户信息。
+     *
+     * @param userInfoInTokenBo 要设置的 `UserInfoInTokenBO` 对象，即从令牌中解析出的用户信息。
+     */
+    public static void set(UserInfoInTokenBO userInfoInTokenBo) {
+        USER_INFO_IN_TOKEN_HOLDER.set(userInfoInTokenBo);
+    }
+
+    /**
+     * 清理当前线程上下文中存储的用户信息对象（从线程本地变量中移除用户信息）。
+     * 首先判断当前线程上下文中是否已经设置了用户信息（即 `USER_INFO_IN_TOKEN_HOLDER.get()` 是否不为 `null`），
+     * 如果不为 `null`，则调用 `USER_INFO_IN_TOKEN_HOLDER` 的 `remove` 方法将其移除，
+     * 确保线程本地变量不会残留上一次的用户信息，避免对后续请求处理产生干扰。
+     */
+    public static void clean() {
+        if (USER_INFO_IN_TOKEN_HOLDER.get()!= null) {
+            USER_INFO_IN_TOKEN_HOLDER.remove();
+        }
+    }
+}

yami-shop-service/src/main/java/com/yami/shop/dao/AreaMapper.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义了一个名为com.yami.shop.dao的包，用于组织代码
+package com.yami.shop.dao;
+
+// 导入了MyBatis Plus框架中的BaseMapper接口，用于提供基础的CRUD操作
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 导入了Area实体类，这个类代表了数据库中的一个表
+import com.yami.shop.bean.model.Area;
+
+/**
+ * 这是一个Mapper接口，用于定义与Area实体相关的数据库操作。
+ *
+ * @author lanhai 表示这个接口的作者是lanhai
+ */
+public interface AreaMapper extends BaseMapper<Area> {
+    // 这个接口继承了BaseMapper接口，因此已经包含了基础的CRUD操作，不需要额外定义方法
+}

yami-shop-service/src/main/java/com/yami/shop/dao/AttachFileMapper.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义了一个名为com.yami.shop.dao的包，用于组织代码
+package com.yami.shop.dao;
+
+// 导入了MyBatis Plus框架中的BaseMapper接口，用于提供基础的CRUD操作
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 导入了AttachFile实体类，这个类代表了数据库中的一个表
+import com.yami.shop.bean.model.AttachFile;
+
+/**
+ * 这是一个Mapper接口，用于定义与AttachFile实体相关的数据库操作。
+ *
+ * @author lanhai 表示这个接口的作者是lanhai。
+ */
+public interface AttachFileMapper extends BaseMapper<AttachFile> {
+    // 这个接口继承了BaseMapper接口，因此已经包含了基础的CRUD操作，不需要额外定义方法
+}

yami-shop-service/src/main/java/com/yami/shop/dao/BasketMapper.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义了一个名为com.yami.shop.dao的包，用于组织代码
+package com.yami.shop.dao;
+
+// 导入了MyBatis Plus框架中的BaseMapper接口，用于提供基础的CRUD操作
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+// 导入了项目中定义的DTO和参数类
+import com.yami.shop.bean.app.dto.ShopCartItemDto;
+import com.yami.shop.bean.app.param.ShopCartParam;
+// 导入了项目中的实体类
+import com.yami.shop.bean.model.Basket;
+// 导入了MyBatis的@Param注解，用于在XML或注解中传递参数
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 这是一个Mapper接口，用于定义与Basket实体（购物车）相关的数据库操作。
+ *
+ * @author lanhai 表示这个接口的作者是lanhai。
+ */
+public interface BasketMapper extends BaseMapper<Basket> {
+
+    /**
+     * 获取用户的购物项列表。
+     *
+     * @param userId 用户id
+     * @return 返回一个包含用户购物项的DTO列表
+     */
+    List<ShopCartItemDto> getShopCartItems(@Param("userId") String userId);
+
+    /**
+     * 根据购物车id列表和用户id删除购物车项。
+     *
+     * @param userId 用户id
+     * @param basketIds 购物车id列表
+     */
+    void deleteShopCartItemsByBasketIds(@Param("userId") String userId, @Param("basketIds") List<Long> basketIds);
+
+    /**
+     * 删除用户的所有购物车项。
+     *
+     * @param userId 用户id
+     */
+    void deleteAllShopCartItems(@Param("userId") String userId);
+
+    /**
+     * 获取失效的购物项列表。
+     *
+     * @param userId 用户id
+     * @return 返回一个包含失效购物项的DTO列表
+     */
+    List<ShopCartItemDto> getShopCartExpiryItems(@Param("userId") String userId);
+
+    /**
+     * 删除失效的购物项。
+     *
+     * @param userId 用户id
+     */
+    void cleanExpiryProdList(@Param("userId") String userId);
+
+    /**
+     * 更新购物车的满减活动id。
+     *
+     * @param userId 用户id
+     * @param basketIdShopCartParamMap 购物项id与满减活动参数的映射
+     */
+    void updateDiscountItemId(@Param("userId")String userId, @Param("basketIdShopCartParamMap") Map<Long, ShopCartParam> basketIdShopCartParamMap);
+
+    /**
+     * 根据商品id获取包含该商品的用户id列表。
+     *
+     * @param prodId 商品id
+     * @return 返回一个包含用户id的列表
+     */
+    List<String> listUserIdByProdId(@Param("prodId")Long prodId);
+
+}

yami-shop-service/src/main/java/com/yami/shop/dao/BrandMapper.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.yami.shop.bean.model.Brand;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * @author lanhai
+ */
+public interface BrandMapper extends BaseMapper<Brand> {
+
+	/**
+	 * 根据品牌名称获取品牌
+	 * @param brandName 品牌名称
+	 * @return 品牌信息
+	 */
+	Brand getByBrandName(String brandName);
+
+	/**
+	 * 根据分类id获取品牌列表
+	 * @param categoryId 分类id
+	 * @return 品牌列表
+	 */
+	List<Brand> listByCategoryId(@Param("categoryId")Long categoryId);
+}

yami-shop-service/src/main/java/com/yami/shop/dao/CategoryBrandMapper.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.yami.shop.bean.model.CategoryBrand;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 分类品牌Mapper接口，定义了与分类品牌相关的数据库操作
+ *
+ * @author lanhai
+ */
+public interface CategoryBrandMapper extends BaseMapper<CategoryBrand> {
+
+	/**
+	 * 批量插入分类品牌关系
+	 * @param categoryId 分类ID
+	 * @param brandIds 品牌ID列表
+	 */
+	void insertCategoryBrand(@Param("categoryId") Long categoryId, @Param("brandIds") List<Long> brandIds);
+
+	/**
+	 * 根据分类ID删除分类品牌关系
+	 * @param categoryId 分类ID
+	 */
+	void deleteByCategoryId(Long categoryId);
+
+	/**
+	 * 根据品牌ID删除分类品牌关系
+	 * @param brandId 品牌ID
+	 */
+	void deleteByBrandId(Long brandId);
+}

yami-shop-service/src/main/java/com/yami/shop/dao/CategoryMapper.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.yami.shop.bean.model.Category;
+import java.util.List;
+
+/**
+ * 分类Mapper接口，定义了与分类相关的数据库操作
+ *
+ * @author lanhai
+ */
+public interface CategoryMapper extends BaseMapper<Category> {
+
+	/**
+	 * 根据父级ID查询分类列表
+	 * @param parentId 父级ID
+	 * @return 分类列表
+	 */
+	List<Category> listByParentId(Long parentId);
+
+	/**
+	 * 根据店铺ID查询分类列表
+	 * @param shopId 店铺ID
+	 * @return 分类列表
+	 */
+	List<Category> tableCategory(Long shopId);
+}

yami-shop-service/src/main/java/com/yami/shop/dao/CategoryPropMapper.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.yami.shop.bean.model.CategoryProp;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 分类属性Mapper接口，定义了与分类属性相关的数据库操作
+ *
+ * @author lanhai
+ */
+public interface CategoryPropMapper extends BaseMapper<CategoryProp> {
+
+	/**
+	 * 批量插入分类属性关系
+	 * @param categoryId 分类ID
+	 * @param propIds 属性ID列表
+	 */
+	void insertCategoryProp(@Param("categoryId") Long categoryId, @Param("propIds") List<Long> propIds);
+
+	/**
+	 * 根据分类ID删除分类属性关系
+	 * @param categoryId 分类ID
+	 */
+	void deleteByCategoryId(Long categoryId);
+
+	/**
+	 * 根据属性ID删除分类属性关系
+	 * @param propId 属性ID
+	 */
+	void deleteByPropId(Long propId);
+}

yami-shop-service/src/main/java/com/yami/shop/dao/DeliveryMapper.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名
+package com.yami.shop.dao;
+
+// 导入所需的类
+import com.yami.shop.bean.model.Delivery;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * DeliveryMapper 接口的文档注释
+ * 这里可以描述这个接口的作用，比如它是用于数据库操作的Mapper接口
+ *
+ * @author lanhai 表示这个类的作者是lanhai
+ */
+public interface DeliveryMapper extends BaseMapper<Delivery> {
+    // 这个接口继承了BaseMapper接口，泛型参数为Delivery，表示这个Mapper与Delivery实体类相关联
+    // 在这个接口中，可以定义与Delivery表相关的数据库操作方法
+    // 由于继承了BaseMapper，已经包含了很多基础的数据库操作方法，如增删改查
+    // 如果需要额外的自定义方法，可以在这个接口中声明，然后在对应的XML文件或使用MyBatis Plus的注解方式实现
+}

yami-shop-service/src/main/java/com/yami/shop/dao/HotSearchMapper.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.yami.shop.bean.dto.HotSearchDto;
+import com.yami.shop.bean.model.HotSearch;
+
+import java.util.List;
+
+/**
+ * HotSearchMapper 是一个数据访问层接口，继承自MyBatis-Plus提供的BaseMapper，
+ * 提供对HotSearch实体的基本CRUD操作方法。
+ * 此外，它还定义了一个特定的方法用于根据店铺ID获取热搜列表。
+ *
+ * @author lanhai
+ */
+public interface HotSearchMapper extends BaseMapper<HotSearch> {
+
+    /**
+     * getHotSearchDtoByShopId 方法用于根据给定的店铺ID获取该店铺的热搜列表。
+     * 它返回的是一个HotSearchDto对象的列表，而不是直接返回数据库中的HotSearch实体对象。
+     * 这样做通常是为了能够在不改变数据库表结构的情况下调整API输出格式，或者为了减少不必要的数据传输。
+     *
+     * @param shopId 店铺的唯一标识符，用于确定要查询的热搜信息所属的店铺。
+     * @return 返回一个包含指定店铺热搜信息的HotSearchDto对象列表。
+     */
+    List<HotSearchDto> getHotSearchDtoByShopId(Long shopId);
+}

yami-shop-service/src/main/java/com/yami/shop/dao/IndexImgMapper.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.yami.shop.bean.model.IndexImg;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * IndexImgMapper 是一个数据访问层接口，用于定义对IndexImg实体进行数据库操作的方法。
+ * 它继承自MyBatis-Plus提供的BaseMapper，从而获得了一系列默认的CRUD方法。
+ * @author lanhai
+ */
+public interface IndexImgMapper extends BaseMapper<IndexImg> {
+
+	/**
+	 * deleteIndexImgByIds 方法用于根据给定的ID列表批量删除图片记录。
+	 * @param ids 一个或多个要删除的图片记录的ID数组。
+	 */
+	void deleteIndexImgByIds(@Param("ids") Long[] ids);
+
+	/**
+	 * listIndexImg 方法用于获取所有的图片记录列表。
+	 * @return 返回一个包含所有IndexImg对象的列表。
+	 */
+	List<IndexImg> listIndexImg();
+}

yami-shop-service/src/main/java/com/yami/shop/dao/MessageMapper.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.dao;
+
+import com.yami.shop.bean.model.Message;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * MessageMapper 是一个数据访问层接口，用于定义针对Message实体的操作方法。
+ * 它继承自MyBatis-Plus提供的BaseMapper，因此默认实现了对Message表的基本CRUD功能。
+ *
+ * 如果需要额外的数据库查询或修改操作，可以在本接口中添加相应的方法，并在对应的XML映射文件或使用@Select等注解实现这些方法。
+ *
+ * @author lanhai
+ */
+public interface MessageMapper extends BaseMapper<Message> {
+    // 本接口当前没有定义额外的方法，所有操作都依赖于BaseMapper提供的默认方法。
+}

yami-shop-service/src/main/java/com/yami/shop/service/AreaService.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义了一个名为com.yami.shop.service的包，用于组织代码
+package com.yami.shop.service;
+
+// 导入了MyBatis Plus框架中的分页插件Page类
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入了MyBatis Plus框架中的IService接口，用于提供基础的CRUD操作
+import com.baomidou.mybatisplus.extension.service.IService;
+// 导入了Area实体类，这个类代表了数据库中的一个表
+import com.yami.shop.bean.model.Area;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 这是一个服务接口，用于定义与Area实体相关的业务操作。
+ *
+ * @author lgh on 2018/10/26 表示这个接口的作者是lgh，创建时间为2018年10月26日。
+ */
+public interface AreaService extends IService<Area> {
+
+    /**
+     * 这是一个通过父id查找地址的方法。
+     *
+     * @param pid 父id，用于指定要查找的地址的父级地址
+     * @return 返回一个Area对象的列表，包含了所有父id为pid的地址信息
+     */
+    List<Area> listByPid(Long pid);
+
+    /**
+     * 这是一个通过父id清除地址缓存的方法。
+     *
+     * @param pid 父id，用于指定要清除缓存的地址的父级地址
+     */
+    void removeAreaCacheByParentId(Long pid);
+}

yami-shop-service/src/main/java/com/yami/shop/service/AttachFileService.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义了一个名为com.yami.shop.service的包，用于组织代码
+package com.yami.shop.service;
+
+// 导入了MyBatis Plus框架中的IService接口，用于提供基础的CRUD操作
+import com.baomidou.mybatisplus.extension.service.IService;
+// 导入了AttachFile实体类，这个类代表了数据库中的一个表
+import com.yami.shop.bean.model.AttachFile;
+// 导入了Spring框架中的MultipartFile类，用于处理上传的文件
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+
+/**
+ * 这是一个服务接口，用于定义与AttachFile实体相关的业务操作。
+ *
+ * @author lanhai 表示这个接口的作者是lanhai。
+ * Created by lgh on 2018/07/27 表示这个接口是由lgh创建的，创建时间为2018年7月27日。
+ */
+public interface AttachFileService extends IService<AttachFile> {
+
+	/**
+	 * 上传文件到本地的方法。
+	 *
+	 * @param file 要上传的文件对象，类型为MultipartFile
+	 * @throws IOException 如果上传过程中发生I/O错误，会抛出IOException异常
+	 * @return 返回一个字符串，通常是上传文件后的一些信息，比如文件路径或者文件ID
+	 */
+	String uploadFile(MultipartFile file) throws IOException;
+
+	/**
+	 * 删除文件的方法。
+	 *
+	 * @param fileName 要删除的文件名称
+	 */
+	void deleteFile(String fileName);
+}

yami-shop-service/src/main/java/com/yami/shop/service/BasketService.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.yami.shop.bean.app.dto.ShopCartDto;
+import com.yami.shop.bean.app.dto.ShopCartItemDto;
+import com.yami.shop.bean.app.param.ChangeShopCartParam;
+import com.yami.shop.bean.app.param.OrderItemParam;
+import com.yami.shop.bean.app.param.ShopCartParam;
+import com.yami.shop.bean.model.Basket;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author lgh on 2018/10/18.
+ */
+public interface BasketService extends IService<Basket> {
+
+    /**
+     * 根据购物车id列表删除购物项
+     * @param userId 用户id
+     * @param basketIds 购物车id列表
+     */
+    void deleteShopCartItemsByBasketIds(String userId, List<Long> basketIds);
+
+    /**
+     * 添加购物车
+     * @param param
+     * @param userId
+     */
+    void addShopCartItem(ChangeShopCartParam param, String userId);
+
+    /**
+     * 更新购物车
+     * @param basket
+     */
+    void updateShopCartItem(Basket basket);
+
+    /**
+     * 删除所有购物车
+     * @param userId
+     */
+    void deleteAllShopCartItems(String userId);
+
+    /**
+     * 根据用户id获取购物车列表
+     * @param userId 用户id
+     * @return 购物车列表
+     */
+    List<ShopCartItemDto> getShopCartItems(String userId);
+
+    /**
+     * 获取购物车失效列表
+     * @param userId 用户id
+     * @return 失效商品
+     */
+    List<ShopCartItemDto> getShopCartExpiryItems(String userId);
+
+    /**
+     * 清除失效的购物项
+     * @param userId 用户id
+     */
+    void cleanExpiryProdList(String userId);
+
+    /**
+     * 更新满减活动id
+     * @param userId 用户id
+     * @param basketIdShopCartParamMap 购物车map
+     */
+    void updateBasketByShopCartParam(String userId, Map<Long, ShopCartParam> basketIdShopCartParamMap);
+
+    /**
+     * 删除购物车缓存
+     * @param userId
+     */
+    void removeShopCartItemsCacheByUserId(String userId);
+
+    /**
+     * 获取购物车中拥有某件商品的用户，用于清除该用户购物车的缓存
+     * @param prodId 商品id
+     * @return 用户id
+     */
+    List<String> listUserIdByProdId(Long prodId);
+
+    /**
+     * 根据店铺组装购车中的商品信息，返回每个店铺中的购物车商品信息
+     * @param shopCartItems 指定的购物项目
+     * @return 每个店铺的购物车信息
+     */
+    List<ShopCartDto> getShopCarts(List<ShopCartItemDto> shopCartItems);
+
+    /**
+     * 组装获取用户提交的购物车商品项
+     * @param orderItem 提交订单时携带的商品信息
+     * @param userId 当前用户的用户id
+     * @param basketId 购物车id
+     * @return 所有的商品购物项
+     */
+    List<ShopCartItemDto> getShopCartItemsByOrderItems(List<Long> basketId, OrderItemParam orderItem,String userId);
+
+}

yami-shop-service/src/main/java/com/yami/shop/service/BrandService.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.yami.shop.bean.model.Brand;
+
+import java.util.List;
+
+/**
+ * @author lanhai
+ */
+public interface BrandService extends IService<Brand> {
+
+	/**
+	 * 根据品牌名称获取该品牌
+	 * @param brandName
+	 * @return
+	 */
+	Brand getByBrandName(String brandName);
+
+	/**
+	 * 删除品牌，同时删除品牌与分类之间的关联关系
+	 * @param brandId
+	 */
+	void deleteByBrand(Long brandId);
+
+	/**
+	 * 根据分类id获取品牌列表
+	 * @param categoryId 分类id
+	 * @return
+	 */
+	List<Brand> listByCategoryId(Long categoryId);
+
+}

yami-shop-service/src/main/java/com/yami/shop/service/CategoryBrandService.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.yami.shop.bean.model.CategoryBrand;
+
+/**
+ * 分类品牌服务接口，继承了MyBatis Plus的IService接口，提供分类品牌相关的业务操作
+ *
+ * @author lanhai
+ */
+public interface CategoryBrandService extends IService<CategoryBrand> {
+
+    // 该接口目前为空，继承了IService接口的所有方法，可以添加自定义的方法
+}

yami-shop-service/src/main/java/com/yami/shop/service/CategoryPropService.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.yami.shop.bean.model.CategoryProp;
+
+/**
+ * 分类属性服务接口，继承了MyBatis Plus的IService接口，提供分类属性相关的业务操作
+ *
+ * @author lanhai
+ */
+public interface CategoryPropService extends IService<CategoryProp> {
+
+    // 该接口目前为空，继承了IService接口的所有方法，可以添加自定义的方法
+}

yami-shop-service/src/main/java/com/yami/shop/service/CategoryService.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.yami.shop.bean.model.Category;
+import java.util.List;
+
+/**
+ * 商品分类服务接口，继承了MyBatis Plus的IService接口，并扩展了分类相关的业务操作
+ *
+ * @author lanhai
+ */
+public interface CategoryService extends IService<Category> {
+
+	/**
+	 * 根据父级ID查询分类列表，用于获取一级分类时传入0
+	 * @param parentId 父级ID，0表示查询一级分类
+	 * @return 分类列表
+	 */
+	List<Category> listByParentId(Long parentId);
+
+	/**
+	 * 根据店铺ID查询分类列表，并根据seq排序，用于页面表单展示
+	 * @param shopId 店铺ID
+	 * @return 分类列表
+	 */
+	List<Category> tableCategory(Long shopId);
+
+	/**
+	 * 保存分类信息，包括品牌和参数
+	 * @param category 分类对象
+	 */
+	void saveCategory(Category category);
+
+	/**
+	 * 更新分类信息，包括品牌和参数
+	 * @param category 分类对象
+	 */
+	void updateCategory(Category category);
+
+	/**
+	 * 删除分类信息，包括品牌、参数以及分类对应的图片
+	 * @param categoryId 分类ID
+	 */
+	void deleteCategory(Long categoryId);
+
+	/**
+	 * 根据店铺ID和层级获取商品分类树，用于构建分类树结构
+	 * @param shopId 店铺ID
+	 * @param grade 分类层级
+	 * @return 分类树列表
+	 */
+	List<Category> treeSelect(Long shopId, int grade);
+
+}

yami-shop-service/src/main/java/com/yami/shop/service/DeliveryService.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名，表示这个类属于com.yami.shop.service包
+package com.yami.shop.service;
+
+// 导入MyBatis Plus框架中的IService接口，这个接口提供了基本的CRUD操作
+import com.baomidou.mybatisplus.extension.service.IService;
+// 导入项目中定义的Delivery实体类
+import com.yami.shop.bean.model.Delivery;
+
+/**
+ * DeliveryService接口的文档注释
+ * 这个接口是用于定义与Delivery实体类相关的业务操作
+ *
+ * @author lgh on 2018/11/26 表示这个接口是由lgh在2018年11月26日创建的
+ */
+public interface DeliveryService extends IService<Delivery> {
+
+    // 这个接口继承了IService接口，泛型参数为Delivery，表示这个服务接口与Delivery实体类相关联
+    // 在这个接口中，可以定义与Delivery实体类相关的额外业务操作方法
+    // 由于继承了IService，已经包含了很多基础的CRUD操作，如增删改查
+}

yami-shop-service/src/main/java/com/yami/shop/service/HotSearchService.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名，表示这个接口属于com.yami.shop.service包
+package com.yami.shop.service;
+
+// 导入MyBatis Plus框架中的IService接口，提供基础的CRUD操作
+import com.baomidou.mybatisplus.extension.service.IService;
+// 导入项目中定义的HotSearchDto数据传输对象
+import com.yami.shop.bean.dto.HotSearchDto;
+// 导入项目中定义的HotSearch实体类
+import com.yami.shop.bean.model.HotSearch;
+// 导入Java.util.List接口，用于返回列表类型的数据
+import java.util.List;
+
+/**
+ * HotSearchService接口的文档注释
+ * 这个接口是用于定义与HotSearch实体类相关的业务操作
+ *
+ * @author lgh on 2019/03/27 表示这个接口是由lgh在2019年3月27日创建的
+ */
+public interface HotSearchService extends IService<HotSearch> {
+
+    /**
+     * 根据店铺ID获取热搜列表的方法
+     * 这个方法允许传入一个Long类型的店铺ID，返回一个包含热搜数据的HotSearchDto列表
+     *
+     * @param shopId 店铺ID
+     * @return 根据店铺ID获取的热搜列表
+     */
+    List<HotSearchDto> getHotSearchDtoByShopId(Long shopId);
+
+    /**
+     * 根据店铺ID删除热搜缓存的方法
+     * 这个方法允许传入一个Long类型的店铺ID，用于清除与该店铺ID相关的热搜缓存
+     *
+     * @param shopId 店铺ID
+     */
+    void removeHotSearchDtoCacheByShopId(Long shopId);
+}

yami-shop-service/src/main/java/com/yami/shop/service/IndexImgService.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名，表示这个类属于com.yami.shop.service包
+package com.yami.shop.service;
+
+// 导入MyBatis Plus框架中的IService接口，提供基础的CRUD操作
+import com.baomidou.mybatisplus.extension.service.IService;
+// 导入项目中定义的IndexImg实体类
+import com.yami.shop.bean.model.IndexImg;
+// 导入Java.util.List接口，用于返回列表类型的数据
+import java.util.List;
+
+/**
+ * IndexImgService接口的文档注释
+ * 这个接口是用于定义与IndexImg实体类相关的业务操作
+ *
+ * @author lgh on 2018/11/26 表示这个接口是由lgh在2018年11月26日创建的
+ */
+public interface IndexImgService extends IService<IndexImg> {
+
+    /**
+     * 根据id列表删除图片的方法
+     * 这个方法允许传入一个Long类型的数组，表示要删除的图片的ID列表
+     *
+     * @param ids 要删除的图片ID数组
+     */
+    void deleteIndexImgByIds(Long[] ids);
+
+    /**
+     * 获取全部图片列表的方法
+     * 这个方法返回一个List<IndexImg>类型的数据，包含了所有的图片实体
+     *
+     * @return 包含所有图片的列表
+     */
+    List<IndexImg> listIndexImg();
+
+    /**
+     * 删除图片缓存的方法
+     * 这个方法用于清除与图片相关的缓存，以确保数据的一致性
+     */
+    void removeIndexImgCache();
+}

yami-shop-service/src/main/java/com/yami/shop/service/MessageService.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.yami.shop.bean.model.Message;
+
+/**
+ * MessageService 是一个服务层接口，用于定义针对Message实体的业务逻辑方法。
+ * 它继承自MyBatis-Plus提供的IService，因此默认实现了对Message表的基本CRUD功能。
+ *
+ * 通过实现此接口，开发者可以在相应的ServiceImpl类中添加额外的业务逻辑，
+ * 或者重写已有的方法以满足特定需求。
+ *
+ * @author lgh on 2018/10/15.
+ */
+public interface MessageService extends IService<Message> {
+
+    // 本接口当前没有定义额外的方法，所有操作都依赖于IService提供的默认方法。
+    // 如果需要增加特定的业务逻辑方法，可以在本接口中添加相应的方法签名。
+}

yami-shop-service/src/main/java/com/yami/shop/service/MyOrderService.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.yami.shop.bean.app.dto.MyOrderDto;
+import com.yami.shop.bean.model.Order;
+
+/**
+ * MyOrderService 是一个服务层接口，用于定义针对用户订单（Order）的业务逻辑方法。
+ * 它继承自MyBatis-Plus提供的IService，因此默认实现了对Order表的基本CRUD功能。
+ * 此外，它还提供了一个特定的方法来根据用户ID和订单状态分页获取订单信息。
+ *
+ * @author lgh
+ */
+public interface MyOrderService extends IService<Order> {
+
+	/**
+	 * pageMyOrderByUserIdAndStatus 方法用于根据用户ID和订单状态分页查询订单信息。
+	 *
+	 * @param page   分页参数，包含了当前页码、每页显示记录数等信息。
+	 *               该参数也作为返回结果的一部分，用来封装分页后的数据。
+	 * @param userId 用户唯一标识符，用于确定要查询哪个用户的订单。
+	 * @param status 订单的状态码，用于过滤符合条件的订单。
+	 *               如果为null，则表示不根据订单状态进行过滤。
+	 * @return 返回一个IPage<MyOrderDto>对象，其中包含分页后的订单信息列表，
+	 *         以及与分页相关的元数据（如总记录数、总页数等）。
+	 */
+	IPage<MyOrderDto> pageMyOrderByUserIdAndStatus(Page<MyOrderDto> page, String userId, Integer status);
+}

yami-shop-service/src/main/java/com/yami/shop/service/NoticeService.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名，表示这个接口属于com.yami.shop.service包
+        package com.yami.shop.service;
+
+// 导入MyBatis Plus框架中的分页插件的Page类
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入MyBatis Plus框架中的IService接口，提供基础的CRUD操作
+import com.baomidou.mybatisplus.extension.service.IService;
+// 导入项目中定义的NoticeDto数据传输对象
+import com.yami.shop.bean.app.dto.NoticeDto;
+// 导入项目中定义的Notice实体类
+import com.yami.shop.bean.model.Notice;
+// 导入Java.util.List接口，用于返回列表类型的数据
+import java.util.List;
+
+/**
+ * NoticeService接口的文档注释
+ * 这个接口是用于定义与Notice实体类相关的业务操作，主要用于公告管理
+ *
+ * @author hzm 表示这个接口是由hzm创建的
+ * @date 2019-04-18 21:21:40 表示这个接口是在2019年4月18日创建的
+ */
+public interface NoticeService extends IService<Notice> {
+
+    /**
+     * 获取公告列表的方法
+     * 这个方法返回一个List<Notice>类型的数据，包含了所有的公告实体
+     *
+     * @return 包含所有公告的列表
+     */
+    List<Notice> listNotice();
+
+    /**
+     * 删除公告缓存的方法
+     * 这个方法用于清除与公告相关的缓存，以确保数据的一致性
+     */
+    void removeNoticeList();
+
+    /**
+     * 分页获取公布的公告的方法
+     * 这个方法接受一个Page<NoticeDto>类型的参数，返回一个分页的NoticeDto列表
+     *
+     * @param page 分页参数
+     * @return 分页的公告DTO列表
+     */
+    Page<NoticeDto> pageNotice(Page<NoticeDto> page);
+
+    /**
+     * 根据公告id获取公告的方法
+     * 这个方法接受一个Long类型的公告ID，返回对应的Notice实体
+     *
+     * @param noticeId 公告ID
+     * @return 对应的公告实体
+     */
+    Notice getNoticeById(Long noticeId);
+
+    /**
+     * 根据公告id删除公告的方法
+     * 这个方法接受一个Long类型的公告ID，用于删除对应的公告实体
+     *
+     * @param noticeId 公告ID
+     */
+    void removeNoticeById(Long noticeId);
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/AreaServiceImpl.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义了一个名为com.yami.shop.service.impl的包，用于组织代码
+package com.yami.shop.service.impl;
+
+// 导入了MyBatis Plus框架中的LambdaQueryWrapper类，用于构建条件查询
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+// 导入了MyBatis Plus框架中的ServiceImpl类，用于提供基础的CRUD操作实现
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入了Area实体类，这个类代表了数据库中的一个表
+import com.yami.shop.bean.model.Area;
+// 导入了AreaMapper接口，用于数据库操作
+import com.yami.shop.dao.AreaMapper;
+// 导入了AreaService接口，用于定义业务操作
+import com.yami.shop.service.AreaService;
+// 导入了Spring框架的注解，用于注入依赖和定义服务
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * 这是一个服务实现类，用于实现AreaService接口中定义的业务操作。
+ *
+ * @author lgh on 2018/10/26 表示这个类的作者是lgh，创建时间为2018年10月26日。
+ */
+@Service
+public class AreaServiceImpl extends ServiceImpl<AreaMapper, Area> implements AreaService {
+
+    // 使用Spring的@Autowired注解自动注入AreaMapper
+    @Autowired
+    private AreaMapper areaMapper;
+
+    /**
+     * 通过父id查找地址列表的方法实现。
+     * 使用了MyBatis Plus的LambdaQueryWrapper来构建查询条件，查询父id为pid的地址。
+     * 使用了Spring的@Cacheable注解，表示这个方法的结果会被缓存，缓存名称为"area"，键为方法参数pid。
+     *
+     * @param pid 父id，用于指定要查找的地址的父级地址
+     * @return 返回一个Area对象的列表，包含了所有父id为pid的地址信息
+     */
+    @Override
+    @Cacheable(cacheNames = "area", key = "#pid")
+    public List<Area> listByPid(Long pid) {
+        return areaMapper.selectList(new LambdaQueryWrapper<Area>().eq(Area::getParentId, pid));
+    }
+
+    /**
+     * 通过父id清除地址缓存的方法实现。
+     * 使用了Spring的@CacheEvict注解，表示这个方法会清除缓存，缓存名称为"area"，键为方法参数pid。
+     *
+     * @param pid 父id，用于指定要清除缓存的地址的父级地址
+     */
+    @Override
+    @CacheEvict(cacheNames = "area", key = "#pid")
+    public void removeAreaCacheByParentId(Long pid) {
+        // 方法体为空，清除缓存的逻辑由Spring Cache自动处理
+    }
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/AttachFileServiceImpl.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义了一个名为com.yami.shop.service.impl的包，用于组织代码
+package com.yami.shop.service.impl;
+
+// 导入了Hutool工具类，用于日期、文件和ID操作
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.util.IdUtil;
+// 导入了MyBatis Plus框架中的LambdaQueryWrapper类，用于构建条件查询
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+// 导入了MyBatis Plus框架中的ServiceImpl类，用于提供基础的CRUD操作实现
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入了七牛云存储相关类
+import com.qiniu.common.QiniuException;
+import com.qiniu.http.Response;
+import com.qiniu.storage.BucketManager;
+import com.qiniu.storage.UploadManager;
+import com.qiniu.storage.model.DefaultPutRet;
+import com.qiniu.util.Auth;
+// 导入了项目中的枚举、模型、工具类和配置类
+import com.yami.shop.bean.enums.UploadType;
+import com.yami.shop.bean.model.AttachFile;
+import com.yami.shop.common.bean.Qiniu;
+import com.yami.shop.common.util.ImgUploadUtil;
+import com.yami.shop.common.util.Json;
+import com.yami.shop.dao.AttachFileMapper;
+import com.yami.shop.service.AttachFileService;
+// 导入了Spring框架的注解，用于注入依赖和定义服务
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+// 导入了Spring框架的MultipartFile类，用于处理上传的文件
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.Objects;
+
+/**
+ * 这是一个服务实现类，用于实现AttachFileService接口中定义的业务操作。
+ *
+ * @author lanhai 表示这个类的作者是lanhai。
+ */
+@Service
+public class AttachFileServiceImpl extends ServiceImpl<AttachFileMapper, AttachFile> implements AttachFileService {
+
+	// 使用Spring的@Autowired注解自动注入AttachFileMapper
+	@Autowired
+	private AttachFileMapper attachFileMapper;
+	// 使用Spring的@Autowired注解自动注入七牛云的UploadManager
+	@Autowired
+	private UploadManager uploadManager;
+	// 使用Spring的@Autowired注解自动注入七牛云的BucketManager
+	@Autowired
+	private BucketManager bucketManager;
+	// 使用Spring的@Autowired注解自动注入七牛云的配置信息
+	@Autowired
+	private Qiniu qiniu;
+	// 使用Spring的@Autowired注解自动注入七牛云的认证工具
+	@Autowired
+	private Auth auth;
+	// 使用Spring的@Autowired注解自动注入图片上传工具类
+	@Autowired
+	private ImgUploadUtil imgUploadUtil;
+	// 定义了一个常量，用于格式化文件名
+	public final static String NORM_MONTH_PATTERN = "yyyy/MM/";
+
+	/**
+	 * 上传文件的方法实现。
+	 * 使用了Spring的@Transactional注解，表示这个方法是一个事务性操作，如果发生异常则回滚。
+	 *
+	 * @param file 要上传的文件对象，类型为MultipartFile
+	 * @throws IOException 如果上传过程中发生I/O错误，会抛出IOException异常
+	 * @return 返回一个字符串，通常是上传文件后的一些信息，比如文件路径或者文件ID
+	 */
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public String uploadFile(MultipartFile file) throws IOException {
+		// 获取文件扩展名
+		String extName = FileUtil.extName(file.getOriginalFilename());
+		// 格式化文件名，包含日期和UUID
+		String fileName = DateUtil.format(new Date(), NORM_MONTH_PATTERN) + IdUtil.simpleUUID() + "." + extName;
+		// 创建AttachFile对象，并设置属性
+		AttachFile attachFile = new AttachFile();
+		attachFile.setFilePath(fileName);
+		attachFile.setFileSize(file.getBytes().length);
+		attachFile.setFileType(extName);
+		attachFile.setUploadTime(new Date());
+		// 判断上传类型，如果是本地上传，则保存文件信息到数据库，并上传文件到本地
+		if (Objects.equals(imgUploadUtil.getUploadType(), 1)) {
+			attachFileMapper.insert(attachFile);
+			return imgUploadUtil.upload(file, fileName);
+		} else {
+			// 如果是七牛云上传，则获取上传凭证，并上传文件到七牛云
+			String upToken = auth.uploadToken(qiniu.getBucket(), fileName);
+			Response response = uploadManager.put(file.getBytes(), fileName, upToken);
+			// 解析上传响应
+			Json.parseObject(response.bodyString(), DefaultPutRet.class);
+			return fileName;
+		}
+	}
+
+	/**
+	 * 删除文件的方法实现。
+	 *
+	 * @param fileName 要删除的文件名称
+	 */
+	@Override
+	public void deleteFile(String fileName){
+		// 根据文件名删除数据库中的记录
+		attachFileMapper.delete(new LambdaQueryWrapper<AttachFile>().eq(AttachFile::getFilePath, fileName));
+		try {
+			// 判断上传类型，如果是本地上传，则删除本地文件
+			if (Objects.equals(imgUploadUtil.getUploadType(), UploadType.LOCAL.value())) {
+				imgUploadUtil.delete(fileName);
+			} else if (Objects.equals(imgUploadUtil.getUploadType(), UploadType.QINIU.value())) {
+				// 如果是七牛云上传，则删除七牛云上的文件
+				bucketManager.delete(qiniu.getBucket(), fileName);
+			}
+		} catch (QiniuException e) {
+			// 如果删除失败，抛出运行时异常
+			throw new RuntimeException(e);
+		}
+	}
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/BasketServiceImpl.java

@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+// 导入所需的类和包
+
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.google.common.collect.Lists;
+import com.yami.shop.bean.app.dto.*;
+import com.yami.shop.bean.app.param.ChangeShopCartParam;
+import com.yami.shop.bean.app.param.OrderItemParam;
+import com.yami.shop.bean.app.param.ShopCartParam;
+import com.yami.shop.bean.event.ShopCartEvent;
+import com.yami.shop.bean.model.Basket;
+import com.yami.shop.bean.model.Product;
+import com.yami.shop.bean.model.ShopDetail;
+import com.yami.shop.bean.model.Sku;
+import com.yami.shop.common.util.Arith;
+import com.yami.shop.common.util.CacheManagerUtil;
+import com.yami.shop.dao.BasketMapper;
+import com.yami.shop.service.BasketService;
+import com.yami.shop.service.ProductService;
+import com.yami.shop.service.ShopDetailService;
+import com.yami.shop.service.SkuService;
+import lombok.AllArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.context.ApplicationContext;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 购物车服务实现类
+ *
+ * @author lgh on 2018/10/18.
+ */
+@Service
+@AllArgsConstructor
+public class BasketServiceImpl extends ServiceImpl<BasketMapper, Basket> implements BasketService {
+
+    // 注入的组件
+    private final BasketMapper basketMapper;
+    private final CacheManagerUtil cacheManagerUtil;
+    private final ApplicationContext applicationContext;
+    private final SkuService skuService;
+    private final ShopDetailService shopDetailService;
+    private final ProductService productService;
+
+    /**
+     * 根据购物车ID删除购物车商品
+     * @param userId 用户ID
+     * @param basketIds 购物车ID列表
+     */
+    @Override
+    @CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
+    public void deleteShopCartItemsByBasketIds(String userId, List<Long> basketIds) {
+        basketMapper.deleteShopCartItemsByBasketIds(userId, basketIds);
+    }
+
+    /**
+     * 添加购物车商品
+     * @param param 购物车参数
+     * @param userId 用户ID
+     */
+    @Override
+    @CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
+    public void addShopCartItem(ChangeShopCartParam param, String userId) {
+        Basket basket = new Basket();
+        basket.setBasketCount(param.getCount());
+        basket.setBasketDate(new Date());
+        basket.setProdId(param.getProdId());
+        basket.setShopId(param.getShopId());
+        basket.setUserId(userId);
+        basket.setSkuId(param.getSkuId());
+        basket.setDistributionCardNo(param.getDistributionCardNo());
+        basketMapper.insert(basket);
+    }
+
+    /**
+     * 更新购物车商品
+     * @param basket 购物车对象
+     */
+    @Override
+    @CacheEvict(cacheNames = "ShopCartItems", key = "#basket.userId")
+    public void updateShopCartItem(Basket basket) {
+        basketMapper.updateById(basket);
+    }
+
+    /**
+     * 删除用户所有购物车商品
+     * @param userId 用户ID
+     */
+    @Override
+    @CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
+    public void deleteAllShopCartItems(String userId) {
+        basketMapper.deleteAllShopCartItems(userId);
+    }
+
+    /**
+     * 获取用户购物车商品列表
+     * @param userId 用户ID
+     * @return 购物车商品列表
+     */
+    @Override
+    public List<ShopCartItemDto> getShopCartItems(String userId) {
+        // 从缓存中获取购物车商品列表，如果缓存中没有则从数据库中获取
+        List<ShopCartItemDto> shopCartItemDtoList = cacheManagerUtil.getCache("ShopCartItems", userId);
+        if (shopCartItemDtoList != null) {
+            return shopCartItemDtoList;
+        }
+        shopCartItemDtoList = basketMapper.getShopCartItems(userId);
+        for (ShopCartItemDto shopCartItemDto : shopCartItemDtoList) {
+            shopCartItemDto.setProductTotalAmount(Arith.mul(shopCartItemDto.getProdCount(), shopCartItemDto.getPrice()));
+        }
+        cacheManagerUtil.putCache("ShopCartItems", userId, shopCartItemDtoList);
+        return shopCartItemDtoList;
+    }
+
+    /**
+     * 获取过期的购物车商品列表
+     * @param userId 用户ID
+     * @return 过期的购物车商品列表
+     */
+    @Override
+    public List<ShopCartItemDto> getShopCartExpiryItems(String userId) {
+        return basketMapper.getShopCartExpiryItems(userId);
+    }
+
+    /**
+     * 清除过期商品列表
+     * @param userId 用户ID
+     */
+    @Override
+    @CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
+    public void cleanExpiryProdList(String userId) {
+        basketMapper.cleanExpiryProdList(userId);
+    }
+
+    /**
+     * 根据购物车参数更新购物车
+     * @param userId 用户ID
+     * @param basketIdShopCartParamMap 购物车ID和参数的映射
+     */
+    @Override
+    @CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
+    public void updateBasketByShopCartParam(String userId, Map<Long, ShopCartParam> basketIdShopCartParamMap) {
+        basketMapper.updateDiscountItemId(userId, basketIdShopCartParamMap);
+    }
+
+    /**
+     * 根据用户ID移除购物车缓存
+     * @param userId 用户ID
+     */
+    @Override
+    @CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
+    public void removeShopCartItemsCacheByUserId(String userId) {
+        // 该方法体为空，可能是待实现的方法
+    }
+
+    /**
+     * 根据商品ID列出所有用户的ID
+     * @param prodId 商品ID
+     * @return 用户ID列表
+     */
+    @Override
+    public List<String> listUserIdByProdId(Long prodId) {
+        return basketMapper.listUserIdByProdId(prodId);
+    }
+
+    /**
+     * 根据购物车商品项获取购物车信息
+     * @param shopCartItems 购物车商品项列表
+     * @return 购物车信息列表
+     */
+    @Override
+    public List<ShopCartDto> getShopCarts(List<ShopCartItemDto> shopCartItems) {
+        // 根据店铺ID分组购物车商品项
+        Map<Long, List<ShopCartItemDto>> shopCartMap = shopCartItems.stream().collect(Collectors.groupingBy(ShopCartItemDto::getShopId));
+
+        // 构建购物车信息列表
+        List<ShopCartDto> shopCartDtos = Lists.newArrayList();
+        for (Long shopId : shopCartMap.keySet()) {
+            // 获取店铺的所有商品项
+            List<ShopCartItemDto> shopCartItemDtoList = shopCartMap.get(shopId);
+
+            // 构建每个店铺的购物车信息
+            ShopCartDto shopCart = new ShopCartDto();
+            shopCart.setShopId(shopId);
+            shopCart.setShopName(shopCartItemDtoList.get(0).getShopName());
+
+            // 发布购物车事件
+            applicationContext.publishEvent(new ShopCartEvent(shopCart, shopCartItemDtoList));
+
+            shopCartDtos.add(shopCart);
+        }
+
+        return shopCartDtos;
+    }
+
+    /**
+     * 根据订单项和用户ID获取购物车商品项
+     * @param basketId 购物车ID列表
+     * @param orderItem 订单项参数
+     * @param userId 用户ID
+     * @return 购物车商品项列表
+     */
+    @Override
+    public List<ShopCartItemDto> getShopCartItemsByOrderItems(List<Long> basketId, OrderItemParam orderItem, String userId) {
+        if (orderItem == null && CollectionUtil.isEmpty(basketId)) {
+            return Collections.emptyList();
+        }
+
+        // 当立即购买时，没有提交的订单是没有购物车信息的
+        if (CollectionUtil.isEmpty(basketId) && orderItem != null) {
+            Sku sku = skuService.getSkuBySkuId(orderItem.getSkuId());
+            if (sku == null) {
+                throw new RuntimeException("订单包含无法识别的商品");
+            }
+            Product prod = productService.getProductByProdId(orderItem.getProdId());
+            if (prod == null) {
+                throw new RuntimeException("订单包含无法识别的商品");
+            }
+
+            // 构建购物车商品项
+            ShopCartItemDto shopCartItemDto = new ShopCartItemDto();
+            shopCartItemDto.setBasketId(-1L);
+            shopCartItemDto.setSkuId(orderItem.getSkuId());
+            shopCartItemDto.setProdCount(orderItem.getProdCount());
+            shopCartItemDto.setProdId(orderItem.getProdId());
+            shopCartItemDto.setSkuName(sku.getSkuName());
+            shopCartItemDto.setPic(StrUtil.isBlank(sku.getPic()) ? prod.getPic() : sku.getPic());
+            shopCartItemDto.setProdName(sku.getProdName());
+            shopCartItemDto.set
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/BrandServiceImpl.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.yami.shop.bean.model.Brand;
+import com.yami.shop.dao.BrandMapper;
+import com.yami.shop.dao.CategoryBrandMapper;
+import com.yami.shop.service.BrandService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 品牌服务实现类，提供品牌相关的业务逻辑
+ *
+ * @author lanhai
+ */
+@Service
+public class BrandServiceImpl extends ServiceImpl<BrandMapper, Brand> implements BrandService {
+
+	// 自动注入BrandMapper，用于操作品牌数据
+	@Autowired
+	private BrandMapper brandMapper;
+
+	// 自动注入CategoryBrandMapper，用于操作品牌与分类关系的数据
+	@Autowired
+	private CategoryBrandMapper categoryBrandMapper;
+
+	/**
+	 * 根据品牌名称查询品牌信息
+	 * @param brandName 品牌名称
+	 * @return 品牌对象
+	 */
+	@Override
+	public Brand getByBrandName(String brandName) {
+		return brandMapper.getByBrandName(brandName);
+	}
+
+	/**
+	 * 根据品牌ID删除品牌以及其与分类的关系
+	 * @param brandId 品牌ID
+	 */
+	@Override
+	public void deleteByBrand(Long brandId) {
+		brandMapper.deleteById(brandId);
+		categoryBrandMapper.deleteByBrandId(brandId);
+	}
+
+	/**
+	 * 根据分类ID查询品牌列表
+	 * @param categoryId 分类ID
+	 * @return 品牌列表
+	 */
+	@Override
+	public List<Brand> listByCategoryId(Long categoryId) {
+		return brandMapper.listByCategoryId(categoryId);
+	}
+
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/CategoryBrandServiceImpl.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.yami.shop.bean.model.CategoryBrand;
+import com.yami.shop.dao.CategoryBrandMapper;
+import com.yami.shop.service.CategoryBrandService;
+
+/**
+ * 分类品牌服务实现类，提供分类品牌相关的业务逻辑实现
+ *
+ * @author lanhai
+ */
+@Service
+public class CategoryBrandServiceImpl extends ServiceImpl<CategoryBrandMapper, CategoryBrand> implements CategoryBrandService {
+
+    /**
+     * 自动注入CategoryBrandMapper，用于操作分类品牌数据
+     */
+    @Autowired
+    private CategoryBrandMapper categoryBrandMapper;
+
+    // 该类目前为空，继承了ServiceImpl的所有方法，可以添加自定义的方法实现
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/CategoryPropServiceImpl.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.yami.shop.bean.model.CategoryProp;
+import com.yami.shop.dao.CategoryPropMapper;
+import com.yami.shop.service.CategoryPropService;
+
+/**
+ * 分类属性服务实现类，提供分类属性相关的业务逻辑实现
+ *
+ * @author lanhai
+ */
+@Service
+public class CategoryPropServiceImpl extends ServiceImpl<CategoryPropMapper, CategoryProp> implements CategoryPropService {
+
+    /**
+     * 自动注入CategoryPropMapper，用于操作分类属性数据
+     */
+    @Autowired
+    private CategoryPropMapper categoryPropMapper;
+
+    // 该类目前为空，继承了ServiceImpl的所有方法，可以添加自定义的方法实现
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/CategoryServiceImpl.java

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.google.common.collect.Lists;
+import com.yami.shop.bean.model.Category;
+import com.yami.shop.dao.CategoryBrandMapper;
+import com.yami.shop.dao.CategoryMapper;
+import com.yami.shop.dao.CategoryPropMapper;
+import com.yami.shop.service.AttachFileService;
+import com.yami.shop.service.CategoryService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * 商品分类服务实现类，提供商品分类相关的业务逻辑实现
+ *
+ * @author lanhai
+ */
+@Service
+public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {
+
+	@Autowired
+	private CategoryMapper categoryMapper;
+
+	@Autowired
+	private CategoryBrandMapper categoryBrandMapper;
+
+	@Autowired
+	private CategoryPropMapper categoryPropMapper;
+
+	@Autowired
+	private AttachFileService attachFileService;
+
+	/**
+	 * 根据父级ID查询分类列表
+	 * @param parentId 父级ID
+	 * @return 分类列表
+	 */
+	@Override
+	public List<Category> listByParentId(Long parentId) {
+		return categoryMapper.listByParentId(parentId);
+	}
+
+	/**
+	 * 根据店铺ID查询分类列表，并根据seq排序，用于页面表单展示
+	 * @param shopId 店铺ID
+	 * @return 分类列表
+	 */
+	@Override
+	public List<Category> tableCategory(Long shopId) {
+		return categoryMapper.tableCategory(shopId);
+	}
+
+	/**
+	 * 保存分类信息，包括品牌和参数
+	 * @param category 分类对象
+	 */
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public void saveCategory(Category category) {
+		category.setRecTime(new Date());
+		// 保存分类信息
+		categoryMapper.insert(category);
+		insertBrandsAndAttributes(category);
+	}
+
+	/**
+	 * 更新分类信息，包括品牌和参数
+	 * @param category 分类对象
+	 */
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public void updateCategory(Category category) {
+		Category dbCategory = categoryMapper.selectById(category.getCategoryId());
+		category.setUpdateTime(new Date());
+		// 保存分类信息
+		categoryMapper.updateById(category);
+		// 先删除后增加
+		deleteBrandsAndAttributes(category.getCategoryId());
+		insertBrandsAndAttributes(category);
+		// 如果以前有图片，并且图片与现在不同，则删除以前的图片
+		// if (StrUtil.isNotBlank(dbCategory.getPic()) && !dbCategory.getPic().equals(category.getPic())) {
+		//     attachFileService.deleteFile(dbCategory.getPic());
+		// }
+	}
+
+	/**
+	 * 删除分类信息，包括品牌、参数以及分类对应的图片
+	 * @param categoryId 分类ID
+	 */
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public void deleteCategory(Long categoryId) {
+		Category category = categoryMapper.selectById(categoryId);
+		categoryMapper.deleteById(categoryId);
+		deleteBrandsAndAttributes(categoryId);
+		// if (StrUtil.isNotBlank(category.getPic())) {
+		//     attachFileService.deleteFile(category.getPic());
+		// }
+	}
+
+	/**
+	 * 删除所有分类所关联的品牌和参数
+	 * @param categoryId 分类ID
+	 */
+	private void deleteBrandsAndAttributes(Long categoryId) {
+		// 删除所有分类所关联的品牌
+		categoryBrandMapper.deleteByCategoryId(categoryId);
+		// 删除所有分类所关联的参数
+		categoryPropMapper.deleteByCategoryId(categoryId);
+	}
+
+	/**
+	 * 保存分类与品牌信息，保存分类与参数信息
+	 * @param category 分类对象
+	 */
+	private void insertBrandsAndAttributes(Category category) {
+		// 保存分类与品牌信息
+		if(CollUtil.isNotEmpty(category.getBrandIds())){
+			categoryBrandMapper.insertCategoryBrand(category.getCategoryId(), category.getBrandIds());
+		}
+		// 保存分类与参数信息
+		if(CollUtil.isNotEmpty(category.getAttributeIds())){
+			categoryPropMapper.insertCategoryProp(category.getCategoryId(), category.getAttributeIds());
+		}
+	}
+
+	/**
+	 * 根据店铺ID和层级，获取商品分类树
+	 * @param shopId 店铺ID
+	 * @param grade 分类层级
+	 * @return 分类树列表
+	 */
+	@Override
+	public List<Category> treeSelect(Long shopId, int grade) {
+		List<Category> categories = categoryMapper.selectList(new LambdaQueryWrapper<Category>().le(Category::getGrade, grade).eq(Category::getShopId, shopId));
+		return categoryListToTree(categories);
+	}
+
+	/**
+	 * 将分类列表转换为树形结构
+	 * @param categorys 分类列表
+	 * @return 树形结构的分类列表
+	 */
+	public List<Category> categoryListToTree(List<Category> categorys){
+		if (CollectionUtils.isEmpty(categorys)) {
+			return Lists.newArrayList();
+		}
+		Map<Long, List<Category>> categoryMap = categorys.stream().collect(Collectors.groupingBy(Category::getParentId));
+		List<Category> rootList = categoryMap.get(0L);
+		transformCategoryTree(rootList, categoryMap);
+		return rootList;
+	}
+
+	/**
+	 * 递归构建分类树
+	 * @param categorys 当前层级的分类列表
+	 * @param categoryMap 所有分类的映射
+	 */
+	public void transformCategoryTree(List<Category> categorys, Map<Long, List<Category>> categoryMap) {
+		for (Category category : categorys) {
+			List<Category> nextList = categoryMap.get(category.getCategoryId());
+			if (CollectionUtils.isEmpty(nextList)) {
+				continue;
+			}
+			// 将排序完成的list设为下一层级
+			category.setCategories(nextList);
+			// 处理下一层级
+			transformCategoryTree(nextList, categoryMap);
+		}
+	}
+
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/DeliveryServiceImpl.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名，表示这个类属于com.yami.shop.service.impl包
+package com.yami.shop.service.impl;
+
+// 导入MyBatis Plus框架中的ServiceImpl类，提供基础的CRUD操作实现
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring框架的Autowired注解，用于自动注入依赖的组件
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的Service注解，用于声明这是一个服务组件
+import org.springframework.stereotype.Service;
+
+// 导入项目中定义的Delivery实体类
+import com.yami.shop.bean.model.Delivery;
+// 导入与Delivery实体类相关的Mapper接口
+import com.yami.shop.dao.DeliveryMapper;
+// 导入定义的服务接口
+import com.yami.shop.service.DeliveryService;
+
+/**
+ * DeliveryServiceImpl类的文档注释
+ * 这个类是DeliveryService接口的实现类，提供了与Delivery实体类相关的业务操作实现
+ *
+ * @author lgh on 2018/11/26 表示这个类是由lgh在2018年11月26日创建的
+ */
+// 使用Spring的Service注解标注这个类为一个服务组件，这样Spring容器可以自动扫描并管理这个类的实例
+@Service
+public class DeliveryServiceImpl extends ServiceImpl<DeliveryMapper, Delivery> implements DeliveryService {
+
+    // 使用Autowired注解自动注入DeliveryMapper的实例
+    @Autowired
+    private DeliveryMapper deliveryMapper;
+
+    // 这里可以添加额外的业务逻辑方法，或者覆盖ServiceImpl中的方法以提供定制化的实现
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/HotSearchServiceImpl.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名，表示这个类属于com.yami.shop.service.impl包
+package com.yami.shop.service.impl;
+
+// 导入MyBatis Plus框架中的ServiceImpl类，提供基础的CRUD操作实现
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring框架的缓存注解
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+// 导入Spring框架的Service注解，用于声明这是一个服务组件
+import org.springframework.stereotype.Service;
+
+// 导入项目中定义的HotSearchDto数据传输对象
+import com.yami.shop.bean.dto.HotSearchDto;
+// 导入项目中定义的HotSearch实体类
+import com.yami.shop.bean.model.HotSearch;
+// 导入Spring框架的Autowired注解，用于自动注入依赖的组件
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入与HotSearch实体类相关的Mapper接口
+import com.yami.shop.dao.HotSearchMapper;
+// 导入定义的服务接口
+import com.yami.shop.service.HotSearchService;
+// 导入Java.util.List接口，用于返回列表类型的数据
+import java.util.List;
+
+/**
+ * HotSearchServiceImpl类的文档注释
+ * 这个类是HotSearchService接口的实现类，提供了与HotSearch实体类相关的业务操作实现
+ *
+ * @author lgh on 2019/03/27 表示这个类是由lgh在2019年3月27日创建的
+ */
+// 使用Spring的Service注解标注这个类为一个服务组件，这样Spring容器可以自动扫描并管理这个类的实例
+@Service
+public class HotSearchServiceImpl extends ServiceImpl<HotSearchMapper, HotSearch> implements HotSearchService {
+
+    // 使用Autowired注解自动注入HotSearchMapper的实例
+    @Autowired
+    private HotSearchMapper hotSearchMapper;
+
+    /**
+     * 根据店铺ID获取热点搜索DTO列表的方法
+     * 这个方法使用@Cacheable注解，表示其返回结果将被缓存，缓存名称为"HotSearchDto"，键为方法参数shopId
+     * @param shopId 店铺ID
+     * @return 根据店铺ID获取的热点搜索DTO列表
+     */
+    @Override
+    @Cacheable(cacheNames = "HotSearchDto", key = "#shopId")
+    public List<HotSearchDto> getHotSearchDtoByShopId(Long shopId) {
+        // 调用hotSearchMapper的同名方法获取数据
+        return hotSearchMapper.getHotSearchDtoByShopId(shopId);
+    }
+
+    /**
+     * 根据店铺ID移除热点搜索DTO缓存的方法
+     * 这个方法使用@CacheEvict注解，表示将从缓存中移除指定的缓存项，缓存名称为"HotSearchDto"，键为方法参数shopId
+     * @param shopId 店铺ID
+     */
+    @Override
+    @CacheEvict(cacheNames = "HotSearchDto", key = "#shopId")
+    public void removeHotSearchDtoCacheByShopId(Long shopId) {
+        // 这里可以添加额外的逻辑，比如通知缓存管理器移除缓存
+    }
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/IndexImgServiceImpl.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+import com.yami.shop.bean.model.IndexImg;
+import com.yami.shop.dao.IndexImgMapper;
+import com.yami.shop.service.IndexImgService;
+
+import java.util.List;
+
+/**
+ * IndexImgServiceImpl 是IndexImgService接口的具体实现类。
+ * 它继承自MyBatis-Plus提供的ServiceImpl，并实现了IndexImgService接口中定义的方法。
+ * 该服务负责处理与首页图片（IndexImg）相关的业务逻辑。
+ *
+ * @author lgh on 2018/11/26.
+ */
+@Service
+public class IndexImgServiceImpl extends ServiceImpl<IndexImgMapper, IndexImg> implements IndexImgService {
+
+    /**
+     * indexImgMapper是通过Spring自动装配的DAO层组件，
+     * 用于执行对IndexImg实体对应的数据库表的操作。
+     */
+    @Autowired
+    private IndexImgMapper indexImgMapper;
+
+    /**
+     * deleteIndexImgByIds方法实现了根据给定ID列表批量删除首页图片的功能。
+     * 它调用了indexImgMapper中的deleteIndexImgByIds方法来执行实际的删除操作。
+     */
+    @Override
+    public void deleteIndexImgByIds(Long[] ids) {
+        indexImgMapper.deleteIndexImgByIds(ids);
+    }
+
+    /**
+     * listIndexImg方法返回所有首页图片的列表。
+     * 使用了@Cacheable注解以启用Spring Cache缓存机制，
+     * 这样可以避免重复查询数据库，提高性能。
+     * 当首次调用此方法时，结果会被缓存起来；
+     * 后续相同请求将直接从缓存中读取数据，直到缓存失效或被手动清除。
+     */
+    @Override
+    @Cacheable(cacheNames = "indexImg", key = "'indexImg'")
+    public List<IndexImg> listIndexImg() {
+        return indexImgMapper.listIndexImg();
+    }
+
+    /**
+     * removeIndexImgCache方法用于清除首页图片的缓存。
+     * 使用了@CacheEvict注解，当调用此方法时会清除指定名称的缓存，
+     * 确保在需要的时候缓存内容是最新的。
+     */
+    @Override
+    @CacheEvict(cacheNames = "indexImg", key = "'indexImg'")
+    public void removeIndexImgCache() {
+        // 方法体为空，因为实际的缓存清除工作由@CacheEvict注解完成。
+    }
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/MessageServiceImpl.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+// 定义包名，表示这个类属于com.yami.shop.service.impl包
+package com.yami.shop.service.impl;
+
+// 导入MyBatis Plus框架中的ServiceImpl类，提供基础的CRUD操作实现
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+// 导入Spring框架的Autowired注解，用于自动注入依赖的组件
+import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架的Service注解，用于声明这是一个服务组件
+import org.springframework.stereotype.Service;
+
+// 导入项目中定义的Message实体类
+import com.yami.shop.bean.model.Message;
+// 导入与Message实体类相关的Mapper接口
+import com.yami.shop.dao.MessageMapper;
+// 导入定义的服务接口
+import com.yami.shop.service.MessageService;
+
+/**
+ * MessageServiceImpl类的文档注释
+ * 这个类是MessageService接口的实现类，提供了与Message实体类相关的业务操作实现
+ *
+ * @author lgh on 2018/10/15 表示这个类是由lgh在2018年10月15日创建的
+ */
+// 使用Spring的Service注解标注这个类为一个服务组件，这样Spring容器可以自动扫描并管理这个类的实例
+@Service
+public class MessageServiceImpl extends ServiceImpl<MessageMapper, Message> implements MessageService {
+
+    // 使用Autowired注解自动注入MessageMapper的实例
+    @Autowired
+    private MessageMapper messageMapper;
+
+    // 这里可以添加额外的业务逻辑方法，或者覆盖ServiceImpl中的方法以提供定制化的实现
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/MyOrderServiceImpl.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.yami.shop.bean.app.dto.MyOrderDto;
+import com.yami.shop.bean.model.Order;
+import com.yami.shop.common.util.PageAdapter;
+import com.yami.shop.dao.OrderMapper;
+import com.yami.shop.service.MyOrderService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+/**
+ * MyOrderServiceImpl 是 MyOrderService 接口的具体实现类。
+ * 它继承自 MyBatis-Plus 提供的 ServiceImpl，并实现了 MyOrderService 中定义的方法。
+ * 该服务负责处理与用户订单（Order）相关的业务逻辑。
+ *
+ * @author lgh on 2018/09/15.
+ */
+@Service
+public class MyOrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements MyOrderService {
+
+    /**
+     * orderMapper 是通过 Spring 自动装配的 DAO 层组件，
+     * 用于执行对 Order 实体对应的数据库表的操作。
+     */
+    @Autowired
+    private OrderMapper orderMapper;
+
+    /**
+     * pageMyOrderByUserIdAndStatus 方法实现了根据用户ID和订单状态分页查询订单信息的功能。
+     *
+     * @param page   分页参数，包含了当前页码、每页显示记录数等信息。
+     *               该参数也作为返回结果的一部分，用来封装分页后的数据。
+     * @param userId 用户唯一标识符，用于确定要查询哪个用户的订单。
+     * @param status 订单的状态码，用于过滤符合条件的订单。
+     *               如果为 null，则表示不根据订单状态进行过滤。
+     * @return 返回一个 IPage<MyOrderDto> 对象，其中包含分页后的订单信息列表，
+     *         以及与分页相关的元数据（如总记录数、总页数等）。
+     */
+    @Override
+    public IPage<MyOrderDto> pageMyOrderByUserIdAndStatus(Page<MyOrderDto> page, String userId, Integer status) {
+        // 使用 PageAdapter 将传入的分页对象适配成适合底层查询的形式
+        page.setRecords(orderMapper.listMyOrderByUserIdAndStatus(new PageAdapter(page), userId, status));
+
+        // 查询满足条件的订单总数，以便设置分页对象的总记录数
+        page.setTotal(orderMapper.countMyOrderByUserIdAndStatus(userId, status));
+
+        // 返回填充了数据的分页对象
+        return page;
+    }
+}

yami-shop-service/src/main/java/com/yami/shop/service/impl/NoticeServiceImpl.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
+ *
+ * https://www.mall4j.com/
+ *
+ * 未经允许，不可做商业用途！
+ *
+ * 版权所有，侵权必究！
+ */
+
+package com.yami.shop.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.yami.shop.bean.app.dto.NoticeDto;
+import com.yami.shop.bean.model.Notice;
+import com.yami.shop.dao.NoticeMapper;
+import com.yami.shop.service.NoticeService;
+import lombok.AllArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * NoticeServiceImpl 是 NoticeService 接口的具体实现类。
+ * 它继承自 MyBatis-Plus 提供的 ServiceImpl，并实现了 NoticeService 中定义的方法。
+ * 该服务负责处理与公告（Notice）相关的业务逻辑。
+ *
+ * @author hzm
+ * @date 2019-04-18 21:21:40
+ */
+@Service
+@AllArgsConstructor // Lombok 注解，自动生成所有构造函数，简化依赖注入
+public class NoticeServiceImpl extends ServiceImpl<NoticeMapper, Notice> implements NoticeService {
+
+    private final NoticeMapper noticeMapper; // 使用构造器注入 DAO 层组件
+
+    /**
+     * listNotice 方法用于获取有效的、置顶的公告列表，并按照发布时间降序排列。
+     * 使用了 @Cacheable 注解来启用缓存，以提高性能。
+     *
+     * @return 返回一个包含符合条件的公告对象列表。
+     */
+    @Override
+    @Cacheable(cacheNames = "notices", key = "'notices'")
+    public List<Notice> listNotice() {
+        return noticeMapper.selectList(new LambdaQueryWrapper<Notice>()
+                .eq(Notice::getStatus, 1) // 状态为1表示有效
+                .eq(Notice::getIsTop, 1)  // 是否置顶为1表示置顶
+                .orderByDesc(Notice::getPublishTime)); // 按发布时间降序排序
+    }
+
+    /**
+     * removeNoticeList 方法用于清除公告列表的缓存。
+     * 使用了 @CacheEvict 注解，在调用此方法时会清除指定名称的缓存。
+     */
+    @Override
+    @CacheEvict(cacheNames = "notices", key = "'notices'")
+    public void removeNoticeList() {
+        // 方法体为空，因为实际的缓存清除工作由 @CacheEvict 注解完成。
+    }
+
+    /**
+     * pageNotice 方法用于分页查询公告信息。
+     *
+     * @param page 分页参数，包含了当前页码、每页显示记录数等信息。
+     *             该参数也作为返回结果的一部分，用来封装分页后的数据。
+     * @return 返回一个 IPage<NoticeDto> 对象，其中包含分页后的公告信息列表，
+     *         以及与分页相关的元数据（如总记录数、总页数等）。
+     */
+    @Override
+    public Page<NoticeDto> pageNotice(Page<NoticeDto> page) {
+        return noticeMapper.pageNotice(page);
+    }
+
+    /**
+     * getNoticeById 方法根据给定的公告ID获取公告详情。
+     * 使用了 @Cacheable 注解来启用缓存，以提高性能。
+     *
+     * @param noticeId 公告唯一标识符，用于确定要查询的公告。
+     * @return 返回一个 Notice 对象，代表指定ID的公告详情。
+     */
+    @Override
+    @Cacheable(cacheNames = "notice", key = "#noticeId")
+    public Notice getNoticeById(Long noticeId) {
+        return noticeMapper.selectById(noticeId);
+    }
+
+    /**
+     * removeNoticeById 方法用于根据给定的公告ID清除公告详情的缓存。
+     * 使用了 @CacheEvict 注解，在调用此方法时会清除指定名称和键值的缓存。
+     *
+     * @param noticeId 公告唯一标识符，用于确定要清除缓存的公告。
+     */
+    @Override
+    @CacheEvict(cacheNames = "notice", key = "#noticeId")
+    public void removeNoticeById(Long noticeId) {
+        // 方法体为空，因为实际的缓存清除工作由 @CacheEvict 注解完成。
+    }
+}

yami-shop-service/src/main/resources/mapper/AreaMapper.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义了XML文档的版本和编码格式 -->
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 这是MyBatis的mapper标签，用于定义一个映射空间 -->
+<mapper namespace="com.yami.shop.dao.AreaMapper">
+    <!-- 定义了一个resultMap，用于映射数据库表字段到Java对象的属性 -->
+    <resultMap id="BaseResultMap" type="com.yami.shop.bean.model.Area">
+        <!-- 以下注释是MyBatis Generator自动生成的警告信息 -->
+        <!--
+          WARNING - @mbg.generated
+        -->
+        <!-- 定义了id字段的映射，column指定数据库表的列名，jdbcType指定列的数据类型，property指定Java对象的属性名 -->
+        <id column="area_id" jdbcType="BIGINT" property="areaId"/>
+        <!-- 定义了普通字段的映射 -->
+        <result column="area_name" jdbcType="VARCHAR" property="areaName"/>
+        <result column="parent_id" jdbcType="BIGINT" property="parentId"/>
+        <result column="level" jdbcType="INTEGER" property="level"/>
+    </resultMap>
+</mapper>

yami-shop-service/src/main/resources/mapper/AttachFileMapper.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义了XML文档的版本和编码格式 -->
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 这是MyBatis的mapper标签，用于定义一个映射空间 -->
+<mapper namespace="com.yami.shop.dao.AttachFileMapper">
+  <!-- 定义了一个resultMap，用于映射数据库表字段到Java对象的属性 -->
+  <resultMap id="BaseResultMap" type="com.yami.shop.bean.model.AttachFile">
+    <!-- 以下注释是MyBatis Generator自动生成的警告信息 -->
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <!-- 定义了id字段的映射，column指定数据库表的列名，jdbcType指定列的数据类型，property指定Java对象的属性名 -->
+    <id column="file_id" jdbcType="BIGINT" property="fileId"/>
+    <!-- 定义了普通字段的映射 -->
+    <result column="file_path" jdbcType="VARCHAR" property="filePath"/>
+    <result column="file_type" jdbcType="VARCHAR" property="fileType"/>
+    <result column="file_size" jdbcType="INTEGER" property="fileSize"/>
+    <result column="file_join_id" jdbcType="BIGINT" property="fileJoinId"/>
+    <result column="file_join_type" jdbcType="INTEGER" property="fileJoinType"/>
+    <result column="upload_time" jdbcType="TIMESTAMP" property="uploadTime"/>
+  </resultMap>
+</mapper>

yami-shop-service/src/main/resources/mapper/BasketMapper.xml

@@ -0,0 +1,83 @@
+<?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.yami.shop.dao.BasketMapper">
+    <!-- 定义了一个名为 BaseResultMap 的 resultMap，它描述了数据库列和 Basket 类属性之间的映射 -->
+    <resultMap id="BaseResultMap" type="com.yami.shop.bean.model.Basket">
+        <!--
+          WARNING - @mbg.generated
+          此注释通常由 MyBatis Generator 自动生成代码时添加，表示此段代码是由工具生成的。
+        -->
+        <id column="basket_id" jdbcType="BIGINT" property="basketId"/> <!-- 主键映射 -->
+        <result column="shop_id" jdbcType="BIGINT" property="shopId"/>
+        <result column="prod_id" jdbcType="BIGINT" property="prodId"/>
+        <result column="sku_id" jdbcType="BIGINT" property="skuId"/>
+        <result column="user_id" jdbcType="VARCHAR" property="userId"/>
+        <result column="basket_count" jdbcType="INTEGER" property="basketCount"/>
+        <result column="basket_date" jdbcType="TIMESTAMP" property="basketDate"/>
+        <result column="discount_id" jdbcType="BIGINT" property="discountId"/>
+        <result column="distribution_card_no" jdbcType="VARCHAR" property="distributionCardNo"/>
+    </resultMap>
+
+    <!-- 查询用户的购物车商品项，并返回 ShopCartItemDto 对象列表 -->
+    <select id="getShopCartItems" resultType="com.yami.shop.bean.app.dto.ShopCartItemDto">
+        SELECT tb.*,tb.basket_count as prod_count,tsd.shop_name,IFNULL(ts.pic,tp.pic)AS pic,ts.price,ts.ori_price,tp.brief,ts.properties,ts.prod_name,ts.sku_name
+        FROM tz_basket tb
+                 LEFT JOIN tz_shop_detail tsd ON tb.shop_id = tsd.shop_id
+                 LEFT JOIN tz_prod tp ON tb.prod_id = tp.prod_id
+                 LEFT JOIN tz_sku ts ON tb.sku_id = ts.sku_id
+        WHERE tp.status = 1 AND ts.status =1 AND tb.user_id = #{userId}
+        ORDER BY tb.`basket_id` DESC
+    </select>
+
+    <!-- 根据用户ID和购物车项ID列表删除购物车中的项目 -->
+    <delete id="deleteShopCartItemsByBasketIds">
+        delete from tz_basket where user_id = #{userId} and basket_id in
+        <foreach collection="basketIds" item="basketId" open="(" separator="," close=")">
+            #{basketId}
+        </foreach>
+    </delete>
+
+    <!-- 删除指定用户的所有购物车项 -->
+    <delete id="deleteAllShopCartItems">
+        delete from tz_basket where user_id = #{userId}
+    </delete>
+
+    <!-- 获取已过期的商品项 -->
+    <select id="getShopCartExpiryItems" resultType="com.yami.shop.bean.app.dto.ShopCartItemDto">
+        SELECT tb.*,tb.basket_count AS prod_count,tsd.shop_name,tp.pic,tp.price,tp.ori_price,tp.brief,ts.properties,ts.prod_name,ts.sku_name
+        FROM tz_basket tb
+                 LEFT JOIN tz_shop_detail tsd ON tb.shop_id = tsd.shop_id
+                 LEFT JOIN tz_prod tp ON tb.prod_id = tp.prod_id
+                 LEFT JOIN tz_sku ts ON tb.sku_id = ts.sku_id
+        WHERE (tp.status = 0 OR ts.status =0) AND tb.user_id = #{userId}
+    </select>
+
+    <!-- 清理所有状态为非激活的产品条目 -->
+    <delete id="cleanExpiryProdList">
+        DELETE FROM tz_basket
+        WHERE basket_id IN(
+            SELECT basket_id FROM (
+                                      SELECT tb.basket_id basket_id
+                                      FROM tz_basket tb
+                                               LEFT JOIN tz_shop_detail tsd
+                                                         ON tb.shop_id = tsd.shop_id
+                                               LEFT JOIN tz_prod tp
+                                                         ON tb.prod_id = tp.prod_id
+                                               LEFT JOIN tz_sku ts
+                                                         ON tb.sku_id = ts.sku_id
+                                      WHERE (tp.status = 0 OR ts.status = 0) AND tb.user_id = #{userId}) AS temp)
+    </delete>
+
+    <!-- 更新购物车项的折扣项ID -->
+    <update id="updateDiscountItemId">
+        <foreach collection="basketIdShopCartParamMap" index="key" item="shopCartParam" separator=";">
+            UPDATE tz_basket SET discount_id = #{shopCartParam.discountId} where basket_id = #{key} and user_id = #{userId}
+        </foreach>
+    </update>
+
+    <!-- 根据产品ID列出拥有该产品的用户ID -->
+    <select id="listUserIdByProdId" resultType="java.lang.String">
+        select user_id from tz_basket where prod_id = #{prodId}
+    </select>
+
+</mapper>