LiiuZeYu_branch

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

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();
+        }
+    }
+}