添加注释

snailmall-api-gateway/src/main/java/com/njupt/swg/cache/CommonCacheUtil.java

@@ -12,44 +12,61 @@ import redis.clients.jedis.JedisPool;
  * @Date 2019/1/1 15:03
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类是一个通用的缓存工具类，用于与Redis进行交互，实现缓存相关的操作，
+ * 例如缓存数据、获取缓存数据、设置带过期时间的缓存以及删除缓存等操作。
+ * 它依赖于JedisPoolWrapper来获取Jedis连接池。
  */
 @Component
 @Slf4j
 public class CommonCacheUtil {
 
+    // 自动注入JedisPoolWrapper，用于获取Jedis连接池，通过它来操作Redis
     @Autowired
     private JedisPoolWrapper jedisPoolWrapper;
 
-
     /**
      * 缓存永久key
+     * 此方法用于将给定的键值对以永久有效的方式存入Redis缓存中。
+     * 如果在操作过程中出现异常，会记录错误日志并抛出SnailmallException异常表示Redis操作报错。
+     * @param key 要存入缓存的键
+     * @param value 要存入缓存对应键的值
      */
     public void cache(String key, String value) {
         try {
+            // 获取Jedis连接池
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
-                try (Jedis Jedis = pool.getResource()) {
-                    Jedis.select(0);
-                    Jedis.set(key, value);
+            if (pool!= null) {
+                // 从连接池中获取Jedis资源，使用try-with-resources语句自动关闭资源
+                try (Jedis jedis = pool.getResource()) {
+                    // 选择Redis的第0个数据库（通常可以根据实际情况选择不同的数据库）
+                    jedis.select(0);
+                    // 将键值对存入Redis
+                    jedis.set(key, value);
                 }
             }
         } catch (Exception e) {
+            // 记录Redis存值失败的错误日志
             log.error("redis存值失败", e);
+            // 抛出SnailmallException异常表示Redis报错
             throw new SnailmallException("redis报错");
         }
     }
 
     /**
      * 获取缓存key
+     * 此方法用于从Redis缓存中根据给定的键获取对应的值。
+     * 如果出现异常，会记录错误日志并抛出SnailmallException异常表示Redis操作报错，最后返回获取到的值（可能为null）。
+     * @param key 要获取值的缓存键
+     * @return 缓存中对应键的值，如果不存在则返回null
      */
     public String getCacheValue(String key) {
         String value = null;
         try {
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
-                try (Jedis Jedis = pool.getResource()) {
-                    Jedis.select(0);
-                    value = Jedis.get(key);
+            if (pool!= null) {
+                try (Jedis jedis = pool.getResource()) {
+                    jedis.select(0);
+                    value = jedis.get(key);
                 }
             }
         } catch (Exception e) {
@@ -61,12 +78,19 @@ public class CommonCacheUtil {
 
     /**
      * 过期key
+     * 此方法用于向Redis缓存中存入键值对，并设置该键的过期时间（以秒为单位）。
+     * 先尝试使用SETNX命令设置键值对（只有键不存在时才设置成功），然后设置过期时间。
+     * 如果操作过程中出现异常，会记录错误日志并抛出SnailmallException异常表示Redis操作报错，最后返回SETNX操作的结果。
+     * @param key 要存入缓存的键
+     * @param value 要存入缓存对应键的值
+     * @param expire 键的过期时间，单位为秒
+     * @return SETNX操作的结果，1表示设置成功（键不存在时），0表示键已存在设置失败
      */
     public long cacheNxExpire(String key, String value, int expire) {
         long result = 0;
         try {
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
+            if (pool!= null) {
                 try (Jedis jedis = pool.getResource()) {
                     jedis.select(0);
                     result = jedis.setnx(key, value);
@@ -83,10 +107,13 @@ public class CommonCacheUtil {
 
     /**
      * 删除缓存key
+     * 此方法用于从Redis缓存中删除指定的键。
+     * 如果在删除过程中出现异常，会记录错误日志并抛出SnailmallException异常表示Redis操作报错。
+     * @param key 要删除的缓存键
      */
     public void delKey(String key) {
         JedisPool pool = jedisPoolWrapper.getJedisPool();
-        if (pool != null) {
+        if (pool!= null) {
             try (Jedis jedis = pool.getResource()) {
                 jedis.select(0);
                 try {
@@ -98,7 +125,4 @@ public class CommonCacheUtil {
             }
         }
     }
-
-
-
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/cache/JedisPoolWrapper.java

@@ -13,31 +13,65 @@ import javax.annotation.PostConstruct;
  * @Author swg.
  * @Date 2019/1/1 15:00
  * @CONTACT 317758022@qq.com
- * @DESC 只做了单个redis，但是课程中实现的redis客户端集群，要掌握一致性hash算法
+ * @DESC 本类旨在对JedisPool进行封装管理，当前实现仅针对单个Redis实例进行连接池的配置与初始化操作。
+ * 不过在相关课程中涉及了redis客户端集群相关内容，在那种场景下需要掌握一致性hash算法来更好地进行数据分布等操作。
+ * 本类作为Spring的一个组件，通过依赖注入获取配置参数，并在初始化阶段构建JedisPool连接池，后续提供获取该连接池的方法供其他类使用。
  */
 @Component
 @Slf4j
 public class JedisPoolWrapper {
+
+    // 通过Spring的依赖注入机制，自动注入Parameters对象。
+    // Parameters类应该是用于存放各类配置参数的，在这里主要用于获取与Redis连接相关的配置信息。
     @Autowired
     private Parameters parameters;
 
+    // 用于保存JedisPool实例，初始化为null，会在后续的初始化方法中根据配置情况进行实例化。
+    // 这个连接池对象是与Redis服务器建立连接、获取Jedis客户端实例的关键所在。
     private JedisPool jedisPool = null;
 
+    /**
+     * @PostConstruct注解修饰的方法会在当前类实例化且依赖注入完成后自动执行。
+     * 此方法主要负责初始化JedisPool连接池，通过读取配置参数来设置连接池的各项属性，并创建JedisPool实例。
+     * 如果在初始化过程中出现任何异常，会记录详细的错误日志信息，方便排查问题。
+     */
     @PostConstruct
-    public void init(){
+    public void init() {
         try {
+            // 创建JedisPoolConfig对象，它用于配置JedisPool连接池的各种行为和参数限制。
             JedisPoolConfig config = new JedisPoolConfig();
+
+            // 设置JedisPool连接池允许创建的最大连接数量。
+            // 通过从注入的Parameters对象中获取对应的配置参数值来进行设置，确保连接池的规模符合预期配置。
             config.setMaxTotal(parameters.getRedisMaxTotal());
+
+            // 设置JedisPool连接池中最大的空闲连接数量。
+            // 空闲连接可以被重复利用，合理设置该值有助于提高资源利用效率，同样从Parameters获取配置值进行设置。
             config.setMaxIdle(parameters.getRedisMaxIdle());
+
+            // 设置当从连接池中获取连接时，如果没有可用连接，最长等待的时间（单位为毫秒）。
+            // 防止因为长时间等待连接导致应用程序阻塞，这里也是依据Parameters中的配置来设定。
             config.setMaxWaitMillis(parameters.getRedisMaxWaitMillis());
-            jedisPool = new JedisPool(config,parameters.getRedisHost(),parameters.getRedisPort(),2000,"xxx");
+
+            // 使用配置好的JedisPoolConfig对象，以及从Parameters获取的Redis服务器主机地址、端口号、超时时间（这里设置为2000毫秒）和密码（此处示例密码为"xxx"，实际应替换为真实密码）等信息，创建JedisPool实例。
+            // 这个实例将作为后续与Redis服务器进行交互的基础，通过它可以获取Jedis客户端来执行各种Redis操作。
+            jedisPool = new JedisPool(config, parameters.getRedisHost(), parameters.getRedisPort(), 2000, "xxx");
+
+            // 如果初始化过程顺利，记录一条信息日志，表明Redis连接池初始化成功，方便在运行时查看初始化状态。
             log.info("【初始化redis连接池成功】");
-        }catch (Exception e){
-            log.error("【初始化redis连接池失败】",e);
+        } catch (Exception e) {
+            // 如果在初始化JedisPool连接池过程中出现异常，记录一条错误日志，包含详细的异常信息（通过e参数传递异常堆栈等内容）。
+            // 这样在排查问题时可以快速定位到是在初始化连接池时出现的错误，并根据异常详情分析具体原因。
+            log.error("【初始化redis连接池失败】", e);
         }
     }
 
+    /**
+     * 对外提供获取JedisPool连接池对象的方法。
+     * 其他需要与Redis进行交互的类可以调用此方法来获取JedisPool实例，进而从连接池中获取Jedis客户端来执行诸如数据读写、键值操作等各种Redis相关操作。
+     * @return 返回已经初始化好的JedisPool对象，如果初始化过程中出现问题导致jedisPool仍为null，则返回null。
+     */
     public JedisPool getJedisPool() {
         return jedisPool;
     }
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/common/Parameters.java

@@ -11,23 +11,44 @@ import java.util.List;
  * @Date 2019/1/1 14:27
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（Parameters）主要用于存放应用程序中的各类配置参数，通过Spring的依赖注入机制（@Value注解）从配置文件（通常是application.properties或application.yml等）中读取相应的值进行赋值。
+ * 它被标记为Spring的组件（@Component注解），方便在其他需要使用这些配置参数的地方通过依赖注入获取该类的实例。
+ * 同时使用了Lombok的@Data注解，自动生成了常用的Getter、Setter、toString等方法，方便对类中的属性进行操作和展示。
  */
 @Component
 @Data
 public class Parameters {
+
+    /**
+     * Redis配置相关参数部分开始
+     * 以下是用于配置与Redis服务器连接相关的各项参数，通过@Value注解结合配置文件中的对应属性键来获取具体的值并赋值给相应的成员变量。
+     */
     /*****redis config start*******/
+    // 从配置文件中读取Redis服务器的主机地址配置，对应的配置文件中的属性键为"redis.host"
     @Value("${redis.host}")
     private String redisHost;
+
+    // 从配置文件中读取Redis服务器的端口号配置，对应的配置文件中的属性键为"redis.port"，会被自动解析并赋值为整数类型
     @Value("${redis.port}")
     private int redisPort;
+
+    // 此处变量名可能存在混淆，按照语义理解应该是获取Redis连接池的最大空闲连接数，但变量名写的是redisMaxTotal，可能需要确认是否准确。
+    // 从配置文件中读取对应配置，配置文件中的属性键为"redis.max-idle"，赋值为整数类型
     @Value("${redis.max-idle}")
     private int redisMaxTotal;
+
+    // 此处同样变量名可能存在混淆，按照语义理解应该是获取Redis连接池的最大连接数，但变量名写的是redisMaxIdle，可能需要核对准确性。
+    // 从配置文件中读取对应配置，配置文件中的属性键为"redis.max-total"，赋值为整数类型
     @Value("${redis.max-total}")
     private int redisMaxIdle;
+
+    // 从配置文件中读取获取Redis连接时的最大等待时间（单位为毫秒）配置，对应的配置文件中的属性键为"redis.max-wait-millis"，赋值为整数类型
     @Value("${redis.max-wait-millis}")
     private int redisMaxWaitMillis;
     /*****redis config end*******/
 
+    // 用于存放不需要安全验证的管理员路径列表配置，从配置文件中读取以逗号分隔的字符串，并通过split方法解析为List<String>类型。
+    // 配置文件中对应的属性键为"security.noneSecurityAdminPaths"
     @Value("#{'${security.noneSecurityAdminPaths}'.split(',')}")
     private List<String> noneSecurityAdminPaths;
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/config/CorsConfig.java

@@ -9,24 +9,44 @@ import org.springframework.web.filter.CorsFilter;
 import java.util.Arrays;
 
 /**
- * 跨域配置 允许所有的接口都可以跨域
- * C - Cross  O - Origin  R - Resource  S - Sharing
+ * 跨域配置类，其目的是允许所有的接口都可以跨域访问。
+ * CORS是"Cross-Origin Resource Sharing"（跨域资源共享）的缩写，通过配置相关规则来控制不同源之间的资源共享情况。
+ * 此类使用Spring的配置相关注解，用于在Spring应用中定义跨域相关的配置逻辑，并将其作为一个Bean注入到Spring容器中供其他组件使用。
  */
 @Configuration
 public class CorsConfig {
 
+	/**
+	 * @Bean注解用于将方法返回的对象作为一个Bean注册到Spring容器中，在这里返回的是CorsFilter对象。
+	 * 这个CorsFilter对象用于处理跨域请求时的过滤逻辑，基于配置好的跨域规则来决定是否允许跨域访问等操作。
+	 */
 	@Bean
 	public CorsFilter corsFilter() {
+		// 创建一个基于URL的CorsConfigurationSource对象，它用于根据不同的URL路径来配置对应的CorsConfiguration（跨域配置）。
 		final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+		// 创建一个CorsConfiguration对象，用于具体设置跨域相关的各项配置参数，比如允许的源、请求头、请求方法等。
 		final CorsConfiguration config = new CorsConfiguration();
 
+		// 设置是否允许跨域请求中包含认证信息（如Cookie等），这里设置为true，表示允许携带认证信息进行跨域访问。
 		config.setAllowCredentials(true);
-		config.setAllowedOrigins(Arrays.asList("*")); //http:www.a.com
+
+		// 设置允许的跨域请求源（Origin），这里使用Arrays.asList("*")表示允许所有来源的请求进行跨域访问。
+		// 在实际更严格的场景下，通常应该明确指定具体的域名等来源，例如Arrays.asList("http://www.a.com")只允许来自该域名的跨域请求。
+		config.setAllowedOrigins(Arrays.asList("*"));
+
+		// 设置允许的请求头信息，使用Arrays.asList("*")表示允许所有类型的请求头进行跨域请求，不过在实际应用中，也可以根据需求明确列出允许的具体请求头列表。
 		config.setAllowedHeaders(Arrays.asList("*"));
+
+		// 设置允许的请求方法（如GET、POST、PUT等），同样通过Arrays.asList("*")表示允许所有的请求方法进行跨域访问，也可以按需具体指定。
 		config.setAllowedMethods(Arrays.asList("*"));
+
+		// 设置预检请求（OPTIONS请求）的有效期，单位为秒，这里设置为300秒，表示在这个时间范围内，相同配置的跨域请求不需要再次发送预检请求。
 		config.setMaxAge(300l);
 
+		// 将配置好的CorsConfiguration应用到所有路径（"/**"表示匹配所有的URL路径）上，也就是对整个应用的所有接口都应用此跨域配置。
 		source.registerCorsConfiguration("/**", config);
+
+		// 创建并返回CorsFilter对象，这个对象会在Spring Web应用中对进入的请求进行过滤，根据配置好的跨域规则来处理跨域相关的逻辑。
 		return new CorsFilter(source);
 	}
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/constants/Constants.java

@@ -5,42 +5,75 @@ package com.njupt.swg.constants;
  * @Date 2019/1/1 13:19
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（Constants）主要用于定义整个应用程序中常用的常量。
+ * 通过将这些常量集中在此类中进行统一管理，方便在代码的各个地方进行引用，提高代码的可读性和可维护性，避免了硬编码一些常数值的情况。
  */
 public class Constants {
+
+    /**
+     * 自定义状态码相关常量部分开始
+     * 以下定义了一系列在应用中用于表示不同响应状态的自定义状态码，方便在处理请求返回结果等场景下统一使用和判断。
+     */
     /**自定义状态码 start**/
+    // 表示请求成功的状态码，对应HTTP状态码中的200，表示操作顺利完成，符合预期。
     public static final int RESP_STATUS_OK = 200;
 
+    // 表示未授权的状态码，对应HTTP状态码中的401，通常用于用户在没有提供有效认证信息（如未登录或者权限不足等情况）访问受保护资源时返回该状态码。
     public static final int RESP_STATUS_NOAUTH = 401;
 
+    // 表示服务器内部错误的状态码，对应HTTP状态码中的500，意味着服务器在处理请求过程中出现了不可预期的错误情况。
     public static final int RESP_STATUS_INTERNAL_ERROR = 500;
 
+    // 表示请求参数错误的状态码，对应HTTP状态码中的400，常用于客户端发送的请求参数不符合要求、格式错误等场景。
     public static final int RESP_STATUS_BADREQUEST = 400;
-
     /**自定义状态码 end**/
 
+    /**
+     * Redis中与用户相关的键（key）的前缀定义，后续在Redis中存储用户相关的数据时，键名通常会以此前缀开头，便于统一管理和识别用户相关的缓存数据。
+     */
     /***redis user相关的key以这个打头**/
     public static final String TOKEN_PREFIX = "user_";
 
+    /**
+     * 用于定义与用户登录信息在Redis中缓存的过期时间相关的常量。
+     * 通过接口内部定义常量的方式，使得这个过期时间相关的值在逻辑上更加清晰、独立，方便后续可能的修改和维护。
+     */
     /**
      * 用户登陆redis的过期时间
      */
-    public interface RedisCacheExtime{
-        int REDIS_SESSION_EXTIME = 60* 30;//30分钟
+    public interface RedisCacheExtime {
+        // 定义用户登录信息在Redis中的缓存过期时间为30分钟，这里通过计算将分钟换算成秒（60秒 * 30分钟）进行表示。
+        int REDIS_SESSION_EXTIME = 60 * 30; // 30分钟
     }
 
+    /**
+     * 用户注册判断重复时涉及的参数类型相关常量部分开始
+     * 以下定义了在用户注册过程中，用于判断哪些参数是否重复的相关常量字符串，比如判断邮箱、用户名是否已被使用等情况。
+     */
     /** 用户注册判断重复的参数类型 start **/
+    // 表示用于判断用户注册时邮箱是否重复的参数类型对应的字符串常量，方便在相关验证逻辑中统一使用该标识。
     public static final String EMAIL = "email";
 
+    // 表示用于判断用户注册时用户名是否重复的参数类型对应的字符串常量，同样便于在用户名重复性验证逻辑中统一引用。
     public static final String USERNAME = "username";
     /** 用户注册判断重复的参数类型 end **/
 
+    /**
+     * 用户角色相关的常量定义部分开始
+     * 以下通过接口内部定义常量的方式，定义了不同用户角色对应的整数值，方便在权限判断、用户分类等场景下进行使用，以区分不同类型的用户角色。
+     */
     /** 用户角色 **/
-    public interface Role{
-        int ROLE_CUSTOME = 0;//普通用户
-        int ROLE_ADMIN = 1;//管理员用户
+    public interface Role {
+        // 表示普通用户角色对应的整数值为0，用于在系统中标识具有普通权限的用户类型。
+        int ROLE_CUSTOME = 0; // 普通用户
+
+        // 表示管理员用户角色对应的整数值为1，用于区分具有管理权限、可进行系统管理操作的用户类型。
+        int ROLE_ADMIN = 1; // 管理员用户
     }
 
+    /**
+     * 用于定义用户注册过程中分布式锁相关的路径字符串常量，在涉及到分布式环境下对用户注册操作进行并发控制时，通过这个路径来标识对应的分布式锁资源。
+     */
     /**用户注册分布式锁路径***/
     public static final String USER_REGISTER_DISTRIBUTE_LOCK_PATH = "/user_reg";
-
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/controller/ErrorHandleController.java

@@ -11,17 +11,31 @@ import org.springframework.web.bind.annotation.RestController;
  * @Date 2019/1/2 21:21
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（ErrorHandleController）是一个Spring MVC中的控制器类，用于处理应用程序中的错误情况。
+ * 它实现了Spring Boot提供的ErrorController接口，意味着它负责定义和处理应用中发生错误时的相关逻辑，例如当用户未登录或者权限不足等情况导致的错误。
+ * 通过使用@RestController注解，表明这个类中的方法返回的结果会直接以JSON等格式响应给客户端，而不是返回视图页面等。
  */
 @RestController
 public class ErrorHandleController implements ErrorController {
+
+    /**
+     * 实现ErrorController接口中定义的方法，用于指定处理错误的路径。
+     * 返回的路径（"/error"）就是当应用出现错误时，请求会被转发到的默认路径，后续会在这个路径对应的方法中进行具体的错误处理逻辑。
+     * @return 返回处理错误的默认路径字符串，即"/error"。
+     */
     @Override
     public String getErrorPath() {
         return "/error";
     }
 
+    /**
+     * 使用@RequestMapping注解将这个方法映射到"/error"路径上，意味着当请求访问到"/error"这个路径时，就会执行此方法。
+     * 此方法主要用于构建并返回一个ServerResponse对象，来告知客户端出现的错误情况，这里是返回一个表示用户未登录或者权限不足的错误响应。
+     * 通过调用ServerResponse的静态方法createByErrorCodeMessage，使用从ResponseEnum中获取的错误代码以及对应的错误提示信息来构造响应对象。
+     * @return 返回一个ServerResponse对象，其中包含了错误代码以及对应的提示信息，告知客户端用户未登录或者权限不足的错误状态。
+     */
     @RequestMapping("/error")
     public ServerResponse error() {
-        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登陆或者权限不足");
+        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登陆或者权限不足");
     }
-
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/entity/User.java

@@ -12,32 +12,44 @@ import java.util.Date;
  * @Author swg.
  * @Date 2018/12/31 21:01
  * @CONTACT 317758022@qq.com
- * @DESC 用户实体类
+ * @DESC 用户实体类，用于在应用程序中对用户相关信息进行建模和封装。
+ * 它对应着数据库中存储用户数据的表结构，每个属性代表了用户的一项具体信息，方便在业务逻辑处理中进行操作、传递以及持久化等操作。
+ * 通过实现Serializable接口，使得该类的对象可以被序列化，便于在网络传输、对象存储（比如存入文件或缓存等场景）时进行相应的处理，确保数据的完整性和可恢复性。
+ * 同时使用了Lombok提供的几个注解来简化代码编写，自动生成常用的方法，提高代码的简洁性和可读性。
  */
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 @ToString
 public class User implements Serializable {
+
+    // 用户的唯一标识符，通常对应数据库表中的主键字段，用于区分不同的用户个体。
     private Integer id;
 
+    // 用户登录时使用的用户名，具有唯一性，方便用户进行身份认证和在系统中标识自己。
     private String username;
 
+    // 用户登录时使用的密码，用于验证用户身份的重要信息，需要进行妥善的加密存储和安全处理。
     private String password;
 
+    // 用户的电子邮箱地址，可用于账号找回、信息通知等功能，也需要保证其唯一性以及格式的有效性。
     private String email;
 
+    // 用户的手机号码，同样可用于多种业务场景，比如短信验证、联系用户等，格式上需要符合手机号码的规范要求。
     private String phone;
 
+    // 用户设置的密保问题，用于在忘记密码等情况下辅助验证用户身份，增加账号的安全性。
     private String question;
 
+    // 用户针对密保问题设置的答案，与question属性配合使用，用于验证用户身份的真实性。
     private String answer;
 
-    //角色0-管理员,1-普通用户
+    // 用于标识用户在系统中的角色，0表示管理员角色，拥有较高的系统管理权限；1表示普通用户角色，权限相对受限，只能进行普通的业务操作。
     private Integer role;
 
+    // 用户账号创建的时间，记录了用户首次注册进入系统的时间节点，通常由系统自动生成并赋值。
     private Date createTime;
 
+    // 用户信息最近一次更新的时间，每当用户修改个人信息等操作后，该时间会相应更新，便于跟踪用户信息的变更情况。
     private Date updateTime;
-
 }

snailmall-api-gateway/src/main/java/com/njupt/swg/exception/SnailmallException.java

@@ -8,18 +8,36 @@ import lombok.Getter;
  * @Date 2019/1/1 13:18
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（SnailmallException）是一个自定义的异常类，继承自Java的RuntimeException，属于运行时异常。
+ * 它主要用于在应用程序特定的业务逻辑中抛出和处理异常情况，使得异常信息能够更好地贴合业务需求，方便进行统一的异常处理和错误提示展示等操作。
+ * 通过使用Lombok的@Getter注解，自动生成了获取exceptionStatus属性的Getter方法，方便在其他地方获取该异常类中定义的异常状态码。
  */
 @Getter
-public class SnailmallException extends RuntimeException{
+public class SnailmallException extends RuntimeException {
+
+    // 用于存储异常对应的状态码，默认初始化为ResponseEnum.ERROR.getCode()，也就是使用预定义的错误状态码值，不过可以通过构造方法进行重新赋值。
     private int exceptionStatus = ResponseEnum.ERROR.getCode();
 
-    public SnailmallException(String msg){
+    /**
+     * 构造方法之一，接收一个字符串类型的参数msg，用于创建一个SnailmallException异常实例。
+     * 这个msg参数会传递给父类（RuntimeException）的构造方法，作为异常的详细描述信息，方便在日志或者错误提示中展示具体的错误原因等内容。
+     * 此构造方法创建的异常实例会使用默认的异常状态码。
+     * @param msg 异常的详细描述信息，用于说明出现异常的具体原因等情况。
+     */
+    public SnailmallException(String msg) {
         super(msg);
     }
 
-    public SnailmallException(int code,String msg){
+    /**
+     * 另一个构造方法，接收两个参数，一个整数类型的code和一个字符串类型的msg。
+     * code参数用于指定该异常对应的状态码，可根据不同的业务异常情况设置不同的状态码，以便于准确区分和处理各种异常。
+     * msg参数同样传递给父类（RuntimeException）的构造方法，作为异常的详细描述信息。
+     * 通过这个构造方法创建的异常实例可以自定义异常状态码，更灵活地适应业务中的不同异常场景。
+     * @param code 异常对应的状态码，用于区分不同类型的业务异常情况。
+     * @param msg 异常的详细描述信息，用于说明出现异常的具体原因等情况。
+     */
+    public SnailmallException(int code, String msg) {
         super(msg);
         exceptionStatus = code;
     }
-
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/filter/AdminUserFilter.java

@@ -26,43 +26,67 @@ import static org.springframework.cloud.netflix.zuul.filters.support.FilterConst
  * @Author swg.
  * @Date 2019/1/3 10:21
  * @CONTACT 317758022@qq.com
- * @DESC 关于后台管理系统，登陆不需要拦截，对于需要认证的富文本上传，需要特定的格式，所以，这里先对富文本放开，到controller里面进行特别处理
- * 前台，就不再在这里进行处理了，因为前台需要防止用户同级的攻击，所以需要userID,放到这里，controller那边不好处理
+ * @DESC 关于后台管理系统，登陆不需要拦截，对于需要认证的富文本上传，需要特定的格式，所以，这里先对富文本放开，到controller里面进行特别处理。
+ * 前台，就不再在这里进行处理了，因为前台需要防止用户同级的攻击，所以需要userID，放到这里，controller那边不好处理。
+ * 这个类（AdminUserFilter）是一个ZuulFilter的实现类，用于在Zuul网关中对请求进行过滤处理，主要针对进入后台管理系统的请求进行权限校验等相关操作。
+ * 通过Spring的@Component注解将其注册为一个Spring组件，方便进行依赖注入等操作，并且使用了@Slf4j注解来记录相关的日志信息，便于跟踪请求处理过程和排查问题。
  */
 @Slf4j
 @Component
 public class AdminUserFilter extends ZuulFilter {
+
+    // 自动注入CommonCacheUtil，用于从缓存（如Redis）中获取相关数据，比如用户信息等，辅助进行权限校验等操作。
     @Autowired
     private CommonCacheUtil commonCacheUtil;
+
+    // 自动注入Parameters对象，用于获取应用程序的配置参数，例如获取不需要进行安全校验的路径等配置信息。
     @Autowired
     private Parameters parameters;
 
+    /**
+     * 定义过滤器的类型，这里返回PRE_TYPE，表示这是一个前置过滤器，会在请求路由之前执行，用于在请求到达目标服务之前进行一些预处理操作，比如权限校验等。
+     * @return 返回过滤器类型，固定为PRE_TYPE，表示前置过滤器。
+     */
     @Override
     public String filterType() {
         return PRE_TYPE;
     }
 
+    /**
+     * 定义过滤器的执行顺序，通过返回一个整数值来指定其在同类型（这里是前置过滤器）过滤器中的执行先后顺序。
+     * 返回的值是在预定义的PRE_DECORATION_FILTER_ORDER基础上减1，表示此过滤器在相关的前置过滤器序列中相对靠前执行，以便尽早进行权限校验等操作。
+     * @return 返回过滤器的执行顺序值。
+     */
     @Override
     public int filterOrder() {
-        return PRE_DECORATION_FILTER_ORDER-1;
+        return PRE_DECORATION_FILTER_ORDER - 1;
     }
 
+    /**
+     * 判断当前过滤器是否需要对请求进行过滤处理。
+     * 首先获取当前请求的上下文以及对应的HttpServletRequest对象，然后获取请求的URL路径。
+     * 根据不同的URL条件来决定是否需要进行权限校验：如果请求的URL不包含"manage"（意味着不是后台管理系统相关的请求），则直接放过，不需要进行后续的权限校验；
+     * 如果URL包含"upload"（可能是特定的富文本上传等不需要权限校验的请求情况），也直接放过；
+     * 对于从配置文件获取的需要校验的路径，如果当前请求URL包含在特定的不需要校验的路径中，同样放过。
+     * 其他情况下（即属于后台管理系统且不在特定放过列表中的请求），则需要进行权限校验，返回true。
+     * @return 返回布尔值，true表示需要进行过滤处理（进行权限校验等），false表示直接放过当前请求，不进行后续过滤操作。
+     */
     @Override
     public boolean shouldFilter() {
         RequestContext requestContext = RequestContext.getCurrentContext();
         HttpServletRequest request = requestContext.getRequest();
-        //获取当前请求的url
+        // 获取当前请求的url
         String url = request.getRequestURI();
-        //前端的路径不在这里校验，直接放过
-        if (!url.contains("manage")){
-            log.info("【{}不需要进行权限校验】",url);
+        // 前端的路径不在这里校验，直接放过
+        if (!url.contains("manage")) {
+            log.info("【{}不需要进行权限校验】", url);
             return false;
         }
-        if(url.contains("upload")){
-            log.info("【{}不需要进行权限校验】",url);
+        if (url.contains("upload")) {
+            log.info("【{}不需要进行权限校验】", url);
             return false;
         }
-        //从配置文件获取所有门户需要校验的路径
+        // 从配置文件获取所有门户需要校验的路径
 //        String[] passUrls = parameters.getNoneSecurityAdminPaths().toArray(new String[parameters.getNoneSecurityAdminPaths().size()]);
 //        for(String str:passUrls){
 //            //指定的路径比较特殊，也不在这里校验
@@ -71,47 +95,57 @@ public class AdminUserFilter extends ZuulFilter {
 //                return false;
 //            }
 //        }
-        log.info("【{}----需要进行权限校验，必须是管理员身份才可以进入】",url);
+        log.info("【{}----需要进行权限校验，必须是管理员身份才可以进入】", url);
         return true;
     }
 
+    /**
+     * 过滤器的核心执行逻辑方法，当shouldFilter方法返回true时，此方法会被执行，用于进行实际的权限校验等操作。
+     * 首先获取请求上下文和HttpServletRequest对象，然后校验是否为管理员身份：
+     * 先从Cookie中读取登录令牌（loginToken），如果令牌为空，表示用户未登录，进行相应的错误处理（如设置不进行路由、返回错误状态码、返回错误提示信息等）；
+     * 如果令牌不为空，则从Redis缓存中通过该令牌获取用户信息，如果获取不到用户信息，同样进行错误处理；
+     * 如果获取到了用户信息，并且请求的是后台管理系统相关的URL（包含"manage"），则进一步校验当前用户是否为管理员角色，如果不是管理员角色，则进行相应的错误处理。
+     * 如果所有校验都通过，则返回null，表示请求可以正常路由到目标服务进行后续处理。
+     * @return 返回ServerResponse对象（这里在出现错误情况时返回相应的错误提示响应，校验通过则返回null），或者抛出ZuulException异常（当前代码中未抛出，不过保留了相关机制）。
+     * @throws ZuulException 可抛出此异常用于处理Zuul网关相关的异常情况，当前代码实现中暂未抛出此异常。
+     */
     @Override
     public ServerResponse run() throws ZuulException {
         RequestContext requestContext = RequestContext.getCurrentContext();
         HttpServletRequest request = requestContext.getRequest();
-        //校验是否为管理员身份
+        // 校验是否为管理员身份
         String loginToken = CookieUtil.readLoginToken(request);
-        log.info("【获取cookie----{}】",loginToken);
-        if(StringUtils.isEmpty(loginToken)){
+        log.info("【获取cookie----{}】", loginToken);
+        if (StringUtils.isEmpty(loginToken)) {
 //            // 过滤该请求，不对其进行路由
 //            requestContext.setSendZuulResponse(false);
 //            //返回错误代码
 //            requestContext.setResponseStatusCode(Constants.RESP_STATUS_NOAUTH);
 //            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息");
             this.returnMsg(requestContext);
-            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息");
-            //throw new SnailmallException("用户未登录,无法获取当前用户信息");
+            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登录,无法获取当前用户信息");
+            // throw new SnailmallException("用户未登录,无法获取当前用户信息");
         }
-        //2.从redis中获取用户信息
+        // 2.从redis中获取用户信息
         String userStr = commonCacheUtil.getCacheValue(loginToken);
-        log.info("【从redis中获取用户信息:{}】",userStr);
-        if(userStr == null){
+        log.info("【从redis中获取用户信息:{}】", userStr);
+        if (userStr == null) {
 //            // 过滤该请求，不对其进行路由
 //            requestContext.setSendZuulResponse(false);
 //            //返回错误代码
 //            requestContext.setResponseStatusCode(Constants.RESP_STATUS_NOAUTH);
 //            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息"); //SnailmallException(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息");
             this.returnMsg(requestContext);
-            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息");
+            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登录,无法获取当前用户信息");
         }
         String url = request.getRequestURI();
-        log.info("【获取当前url:{}】",url);
-        if(url.contains("manage")){
+        log.info("【获取当前url:{}】", url);
+        if (url.contains("manage")) {
             log.info("【来到了管理后台，需要校验权限】");
-            User currentUser = JsonUtil.Str2Obj(userStr,User.class);
-            log.info("【当前登陆的用户为:{}】",currentUser);
-            if(!currentUser.getRole().equals(Constants.Role.ROLE_ADMIN)){
-                //不是管理员报错
+            User currentUser = JsonUtil.Str2Obj(userStr, User.class);
+            log.info("【当前登陆的用户为:{}】", currentUser);
+            if (!currentUser.getRole().equals(Constants.Role.ROLE_ADMIN)) {
+                // 不是管理员报错
                 log.error("【当前登陆用户不是管理员身份】");
                 // 过滤该请求，不对其进行路由
 //                requestContext.setSendZuulResponse(false);
@@ -119,18 +153,25 @@ public class AdminUserFilter extends ZuulFilter {
 //                requestContext.setResponseStatusCode(Constants.RESP_STATUS_NOAUTH);
 //                return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息");
                 this.returnMsg(requestContext);
-                return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息");
-                //throw new SnailmallException("用户权限不够");
+                return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登录,无法获取当前用户信息");
+                // throw new SnailmallException("用户权限不够");
             }
         }
         return null;
     }
 
-    //返回没权限消息
-    private void returnMsg(RequestContext ctx){
+    /**
+     * 用于返回没有权限相关的提示消息的私有方法，主要进行一些响应相关的设置操作。
+     * 设置响应的内容类型为JSON格式（"application/json; charset=utf-8"），然后令Zuul过滤该请求，不进行路由（即阻止请求继续向后端服务转发）。
+     * 设置响应的状态码（这里设置为Constants.RESP_STATUS_OK，不过从语义上可能需要进一步确认是否合适，也许应该设置为对应的权限错误状态码等），
+     * 最后将包含错误提示信息的ServerResponse对象转换为JSON字符串，并设置为响应体内容，以便返回给客户端相应的错误提示。
+     * @param ctx 请求上下文对象，用于设置响应相关的各种属性信息。
+     */
+    // 返回没权限消息
+    private void returnMsg(RequestContext ctx) {
         ctx.getResponse().setContentType("application/json; charset=utf-8");
-        ctx.setSendZuulResponse(false); //令zuul过滤该请求，不对其进行路由
+        ctx.setSendZuulResponse(false); // 令zuul过滤该请求，不对其进行路由
         ctx.setResponseStatusCode(Constants.RESP_STATUS_OK);
-        ctx.setResponseBody(JsonUtil.obj2String(ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登录,无法获取当前用户信息")));
+        ctx.setResponseBody(JsonUtil.obj2String(ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登录,无法获取当前用户信息")));
     }
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/filter/RateLimitFilter.java

@@ -15,38 +15,64 @@ import static org.springframework.cloud.netflix.zuul.filters.support.FilterConst
  * @Author swg.
  * @Date 2019/1/3 11:21
  * @CONTACT 317758022@qq.com
- * @DESC 令牌桶法限流 具体测试没做
+ * @DESC 这个类（RateLimitFilter）是一个基于ZuulFilter实现的过滤器，用于在Zuul网关中实现限流功能，采用的是令牌桶算法来控制请求流量。
+ * 不过需要注意的是，注释中提到具体测试没做，意味着其实际限流效果可能还未经过充分验证。它被注册为Spring的一个组件（通过@Component注解），方便在Spring应用中被自动扫描并实例化。
  */
 @Component
 public class RateLimitFilter extends ZuulFilter {
-    //放100个令牌
-    private static final RateLimiter RATE_LIMITER = RateLimiter.create(100);
 
+    // 使用Google Guava库中的RateLimiter来创建一个令牌桶，这里设置令牌桶的初始令牌数量为100个，意味着一开始桶里有100个令牌可供请求获取，用于控制请求速率。
+    // RateLimiter是基于令牌桶算法实现的一个限流器，通过控制令牌的发放和获取来限制请求的频率。
+    private static final RateLimiter RATE_LIMITER = RateLimiter.create(100);
 
+    /**
+     * 定义过滤器的类型，返回PRE_TYPE，表示这是一个前置过滤器，会在请求路由之前执行。
+     * 前置过滤器适合用于在请求到达目标服务之前进行一些预处理操作，在这里就是进行限流相关的判断，决定请求是否能够继续向后端服务发送。
+     * @return 返回表示过滤器类型的字符串，固定为PRE_TYPE，表示前置过滤器。
+     */
     @Override
     public String filterType() {
         return PRE_TYPE;
     }
 
+    /**
+     * 定义过滤器的执行顺序，通过返回一个整数值来指定其在同类型（这里是前置过滤器）过滤器中的执行先后顺序。
+     * 返回的值是在预定义的SERVLET_DETECTION_FILTER_ORDER基础上减1，表示此过滤器在相关的前置过滤器序列中相对靠前执行，以便尽早进行限流判断，避免不必要的后续处理。
+     * @return 返回过滤器的执行顺序值。
+     */
     @Override
     public int filterOrder() {
         return SERVLET_DETECTION_FILTER_ORDER - 1;
     }
 
+    /**
+     * 判断当前过滤器是否需要对请求进行过滤处理，这里直接返回true，表示对所有请求都要进行限流相关的检查，
+     * 即每一个经过Zuul网关的请求都会进入到这个过滤器的run方法中进行是否获取到令牌的判断，来决定请求是否能继续路由。
+     * @return 返回布尔值，true表示需要进行过滤处理（进行限流判断等），false表示直接放过当前请求，不进行后续过滤操作，这里始终返回true。
+     */
     @Override
     public boolean shouldFilter() {
         return true;
     }
 
+    /**
+     * 过滤器的核心执行逻辑方法，当shouldFilter方法返回true时，此方法会被执行，用于进行实际的限流操作判断。
+     * 首先获取当前请求的上下文以及对应的HttpServletRequest对象，然后尝试从令牌桶（通过RATE_LIMITER对象表示）中获取一个令牌，
+     * 如果能够获取到令牌（即RATE_LIMITER.tryAcquire()返回true），说明当前请求在速率限制范围内，请求可以继续向后端服务路由；
+     * 如果没有获取到令牌（RATE_LIMITER.tryAcquire()返回false），则表示请求过于频繁，超过了限流设置，此时可以进行相应的错误处理，
+     * 这里简单地在请求上下文中设置了一些错误相关的信息（如状态码和错误消息），用于后续可能的处理（比如返回给前端相应的提示信息等），不过当前代码并没有完整地将错误信息返回给前端的逻辑，可能需要进一步完善。
+     * @return 返回null，表示如果请求通过限流判断（获取到令牌），则正常进行后续路由等操作，不需要额外返回特定的对象；如果未通过限流判断（没获取到令牌），当前代码只是设置了错误信息，也返回null。
+     * @throws ZuulException 可抛出此异常用于处理Zuul网关相关的异常情况，当前代码实现中暂未抛出此异常，只是进行了简单的错误信息设置。
+     */
     @Override
     public Object run() throws ZuulException {
         RequestContext context = RequestContext.getCurrentContext();
         HttpServletRequest request = context.getRequest();
-        if(!RATE_LIMITER.tryAcquire()){
-            //没有取到一个令牌的话，可以这样返回信息给前端
-            context.set("状态码",401);
-            context.set("error.message","用户没有获取到令牌");
+        if (!RATE_LIMITER.tryAcquire()) {
+            // 没有取到一个令牌的话，可以这样返回信息给前端（当前只是简单设置了上下文信息，还需完善后续返回给前端的完整逻辑）
+            context.set("状态码", 401);
+            context.set("error.message", "用户没有获取到令牌");
         }
         return null;
     }
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/resp/ResponseEnum.java

@@ -6,20 +6,39 @@ import lombok.Getter;
  * @Author swg.
  * @Date 2018/12/31 20:15
  * @CONTACT 317758022@qq.com
- * @DESC 基本的返回状态描述
+ * @DESC 这个枚举类（ResponseEnum）主要用于定义应用程序中基本的返回状态描述，将不同的状态码及其对应的描述信息进行统一管理。
+ * 通过使用枚举的方式，可以方便地在整个代码中引用这些预定义的状态，增强代码的可读性和可维护性，避免了硬编码状态码和描述信息的情况。
+ * 同时使用了Lombok的@Getter注解，自动生成了获取code和desc属性的Getter方法，方便在其他地方获取枚举实例中定义的状态码和描述信息。
  */
 @Getter
 public enum ResponseEnum {
-    SUCCESS(0,"SUCCESS"),
-    ERROR(1,"ERROR"),
-    ILLEGAL_ARGUMENTS(2,"ILLEGAL_ARGUMENTS"),
-    NEED_LOGIN(10,"NEED_LOGIN");
 
+    // 表示操作成功的状态，状态码为0，对应的描述信息为"SUCCESS"，通常用于在业务逻辑处理成功后返回给客户端等场景，表示请求顺利完成。
+    SUCCESS(0, "SUCCESS"),
+
+    // 表示通用的错误状态，状态码为1，描述信息为"ERROR"，可以用于各种未明确细分的错误情况，作为一个笼统的错误标识返回给客户端等。
+    ERROR(1, "ERROR"),
+
+    // 表示请求参数不合法的状态，状态码为2，描述信息为"ILLEGAL_ARGUMENTS"，常用于客户端发送的请求参数不符合要求、格式错误等场景，方便进行参数校验相关的错误提示。
+    ILLEGAL_ARGUMENTS(2, "ILLEGAL_ARGUMENTS"),
+
+    // 表示需要用户登录的状态，状态码为10，描述信息为"NEED_LOGIN"，一般用于当用户未提供有效登录信息却访问需要认证的资源时，提示客户端用户需要先登录才能继续操作。
+    NEED_LOGIN(10, "NEED_LOGIN");
+
+    // 用于存储每个枚举实例对应的状态码，不同的枚举值有不同的状态码，用于区分不同的返回情况。
     private int code;
+
+    // 用于存储每个枚举实例对应的状态描述信息，直观地展示该状态所代表的含义，方便客户端等使用者理解具体的情况。
     private String desc;
 
-    ResponseEnum(int code,String desc){
+    /**
+     * 枚举的构造方法，用于初始化每个枚举实例的状态码和描述信息。
+     * 当定义每个枚举值（如SUCCESS、ERROR等）时，会调用这个构造方法来传入对应的状态码和描述信息进行实例化。
+     * @param code 状态码，用于唯一标识该种返回状态，在业务逻辑中可以根据这个状态码进行不同的处理。
+     * @param desc 状态描述信息，用于向客户端等说明当前返回状态所代表的具体含义。
+     */
+    ResponseEnum(int code, String desc) {
         this.code = code;
         this.desc = desc;
     }
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/resp/ServerResponse.java

@@ -10,66 +10,156 @@ import java.io.Serializable;
  * @Author swg.
  * @Date 2018/12/31 20:11
  * @CONTACT 317758022@qq.com
- * @DESC 作为本项目的通用的返回封装类
+ * @DESC 这个类（ServerResponse）作为本项目的通用的返回封装类，用于对服务端返回给客户端的数据进行统一的格式封装。
+ * 它可以包含响应的状态码、提示消息以及具体的业务数据等信息，方便客户端清晰地解析和处理服务端返回的结果，同时提高了整个项目返回数据格式的规范性和一致性。
+ * 通过实现Serializable接口，使得该类的对象可以被序列化，便于在网络传输、缓存存储等场景下进行操作，确保数据能够正确地传递和保存。
+ * 并且使用了Lombok的@Getter注解自动生成获取属性的Getter方法，以及使用了Jackson相关的注解来控制JSON序列化时的行为，例如排除值为null的字段等。
  */
 @Getter
 @JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
 public class ServerResponse<T> implements Serializable {
+
+    // 用于存储响应的状态码，通过不同的状态码来告知客户端请求的处理结果情况，例如成功、失败以及具体的错误类型等。
     private int status;
+
+    // 用于存储响应的提示消息，是对状态码含义的一种文字描述，方便客户端直观地了解请求处理的相关情况，比如操作成功的提示或者错误原因说明等。
     private String msg;
+
+    // 用于存储具体的业务数据，其类型是泛型参数T，意味着可以根据不同的业务场景返回不同类型的数据，比如可以是一个用户对象、商品列表等具体的业务相关实体数据。
     private T data;
 
-    private ServerResponse(int status){
+    /**
+     * 私有构造方法之一，只接收状态码作为参数，用于创建一个ServerResponse实例，通常在已知状态码且不需要额外设置提示消息和业务数据时使用，
+     * 比如在一些内部逻辑中根据固定的状态码来构造返回对象，后续可能会根据需要再进一步完善其他属性。
+     * @param status 响应的状态码，用于标识请求处理的结果情况。
+     */
+    private ServerResponse(int status) {
         this.status = status;
     }
-    private ServerResponse(int status,String msg){
+
+    /**
+     * 私有构造方法之二，接收状态码和提示消息作为参数，用于创建一个包含特定状态码和对应提示消息的ServerResponse实例，
+     * 在需要明确告知客户端某个状态以及对应的详细说明时使用，例如返回错误状态并附上具体的错误原因描述等情况。
+     * @param status 响应的状态码，用于标识请求处理的结果情况。
+     * @param msg 响应的提示消息，用于详细说明状态码所代表的含义。
+     */
+    private ServerResponse(int status, String msg) {
         this.status = status;
         this.msg = msg;
     }
-    private ServerResponse(int status,T data){
+
+    /**
+     * 私有构造方法之三，接收状态码和业务数据作为参数，用于创建一个包含特定状态码以及对应业务数据的ServerResponse实例，
+     * 常用于请求处理成功并且有具体数据需要返回给客户端的场景，比如查询操作成功后返回查询到的结果数据等情况。
+     * @param status 响应的状态码，用于标识请求处理的结果情况。
+     * @param data 具体的业务数据，类型为泛型参数T，根据不同业务场景可以是不同类型的数据。
+     */
+    private ServerResponse(int status, T data) {
         this.status = status;
         this.data = data;
     }
-    private ServerResponse(int status,String msg,T data){
+
+    /**
+     * 私有构造方法之四，接收状态码、提示消息和业务数据作为参数，用于创建一个完整包含状态码、提示消息以及业务数据的ServerResponse实例，
+     * 这种情况可以更全面地向客户端传达请求处理的结果，既包含了处理状态、详细说明又有具体的数据内容，适用于多种复杂的业务返回场景。
+     * @param status 响应的状态码，用于标识请求处理的结果情况。
+     * @param msg 响应的提示消息，用于详细说明状态码所代表的含义。
+     * @param data 具体的业务数据，类型为泛型参数T，根据不同业务场景可以是不同类型的数据。
+     */
+    private ServerResponse(int status, String msg, T data) {
         this.status = status;
         this.msg = msg;
         this.data = data;
     }
 
+    /**
+     * 使用@JsonIgnore注解标记此方法，意味着在进行JSON序列化时，该方法不会被包含在序列化结果中。
+     * 这个方法用于判断当前ServerResponse实例所表示的响应是否为成功状态，通过比较实例中的状态码与ResponseEnum中定义的成功状态码（SUCCESS的状态码）是否相等来判断。
+     * @return 返回布尔值，true表示响应是成功状态，false表示响应是失败或者其他非成功的状态。
+     */
     @JsonIgnore
-    public boolean isSuccess(){
+    public boolean isSuccess() {
         return this.status == ResponseEnum.SUCCESS.getCode();
     }
 
     /**
-     * 成功的方法
+     * 以下是一系列静态方法，用于方便地创建表示成功状态的ServerResponse实例，根据不同的业务需求提供了多种创建方式，增强了灵活性。
+
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码和对应的描述信息进行实例化，
+     * 适用于简单告知客户端操作成功，不需要额外传递具体消息和业务数据的场景。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，这里创建实例时暂未指定具体数据类型。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码和描述信息。
      */
-    public static <T>ServerResponse<T> createBySuccess(){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),ResponseEnum.SUCCESS.getDesc());
-    }
-    public static <T>ServerResponse<T> createBySuccessMessage(String message){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),message);
-    }
-    public static <T>ServerResponse<T> createBySuccess(T data){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),data);
-    }
-    public static <T>ServerResponse<T> createBySuccess(String message,T data){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),message,data);
+    public static <T> ServerResponse<T> createBySuccess() {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), ResponseEnum.SUCCESS.getDesc());
     }
 
     /**
-     * 失败的方法
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码，并传入自定义的提示消息进行实例化，
+     * 适用于操作成功但需要向客户端传递一些额外的说明信息的场景，比如操作成功后的一些提示语等。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，这里创建实例时暂未指定具体数据类型。
+     * @param message 自定义的提示消息，用于向客户端传达更详细的成功相关信息。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码和传入的提示消息。
      */
-    public static <T>ServerResponse<T> createByError(){
-        return new ServerResponse<>(ResponseEnum.ERROR.getCode(),ResponseEnum.ERROR.getDesc());
+    public static <T> ServerResponse<T> createBySuccessMessage(String message) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), message);
     }
-    public static <T>ServerResponse<T> createByErrorMessage(String msg){
-        return new ServerResponse<>(ResponseEnum.ERROR.getCode(),msg);
+
+    /**
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码，并传入具体的业务数据进行实例化，
+     * 适用于操作成功且有具体业务数据需要返回给客户端的场景，比如查询操作成功后返回查询到的数据等情况。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，这里创建实例时指定了具体的数据类型，由传入的参数data决定。
+     * @param data 具体的业务数据，类型为泛型参数T，根据不同业务场景可以是不同类型的数据。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码和传入的具体业务数据。
+     */
+    public static <T> ServerResponse<T> createBySuccess(T data) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), data);
     }
-    public static <T>ServerResponse<T> createByErrorCodeMessage(int code,String msg){
-        return new ServerResponse<>(code,msg);
+
+    /**
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码，并传入自定义的提示消息和具体的业务数据进行实例化，
+     * 适用于操作成功且既有需要向客户端传递的额外说明信息，又有具体业务数据需要返回的复杂场景，比如查询操作成功后返回查询到的数据以及一些相关的提示等情况。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，这里创建实例时指定了具体的数据类型，由传入的参数data决定。
+     * @param message 自定义的提示消息，用于向客户端传达更详细的成功相关信息。
+     * @param data 具体的业务数据，类型为泛型参数T，根据不同业务场景可以是不同类型的数据。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码、传入的提示消息和具体业务数据。
+     */
+    public static <T> ServerResponse<T> createBySuccess(String message, T data) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), message, data);
     }
 
+    /**
+     * 以下是一系列静态方法，用于方便地创建表示失败状态的ServerResponse实例，同样根据不同的业务需求提供了多种创建方式，便于在不同的错误场景下返回合适的错误信息。
+
+     * 创建一个表示通用失败状态的ServerResponse实例，使用ResponseEnum中定义的默认失败状态码和对应的描述信息进行实例化，
+     * 适用于一些未明确细分的错误情况，作为一个笼统的错误返回给客户端，告知客户端请求处理出现了问题。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，这里创建实例时暂未指定具体数据类型。
+     * @return 返回一个表示失败状态的ServerResponse实例，包含默认的失败状态码和描述信息。
+     */
+    public static <T> ServerResponse<T> createByError() {
+        return new ServerResponse<>(ResponseEnum.ERROR.getCode(), ResponseEnum.ERROR.getDesc());
+    }
 
+    /**
+     * 创建一个表示失败状态的ServerResponse实例，使用ResponseEnum中定义的默认失败状态码，并传入自定义的提示消息进行实例化，
+     * 适用于已知具体错误原因，需要向客户端传递详细错误信息的场景，通过传入的msg参数告知客户端出现错误的具体情况。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，这里创建实例时暂未指定具体数据类型。
+     * @param msg 自定义的提示消息，用于向客户端传达具体的错误原因等相关信息。
+     * @return 返回一个表示失败状态的ServerResponse实例，包含默认的失败状态码和传入的提示消息。
+     */
+    public static <T> ServerResponse<T> createByErrorMessage(String msg) {
+        return new ServerResponse<>(ResponseEnum.ERROR.getCode(), msg);
+    }
 
-}
+    /**
+     * 创建一个表示失败状态的ServerResponse实例，传入自定义的状态码和提示消息进行实例化，
+     * 适用于需要根据不同的业务逻辑返回特定的错误状态码以及对应的详细错误信息的场景，通过传入的code和msg参数灵活地构建错误返回对象。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，这里创建实例时暂未指定具体数据类型。
+     * @param code 自定义的状态码，用于标识具体的错误情况，根据业务逻辑可以设置不同的值。
+     * @param msg 自定义的提示消息，用于向客户端传达具体的错误原因等相关信息。
+     * @return 返回一个表示失败状态的ServerResponse实例，包含传入的状态码和提示消息。
+     */
+    public static <T> ServerResponse<T> createByErrorCodeMessage(int code, String msg) {
+        return new ServerResponse<>(code, msg);
+    }
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/utils/CookieUtil.java

@@ -8,67 +8,109 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 /**
- * cookie读写
+ * @Author 作者信息
+ * @Date 创建日期
+ * @CONTACT 联系方式
+ * @DESC 这个类（CookieUtil）主要用于处理与Cookie相关的操作，包括向客户端写入登录相关的Cookie、从客户端请求中读取登录的Cookie以及在注销时删除相应的Cookie等功能。
+ * 它通过使用一些固定的域名、Cookie名称等配置信息，来统一管理项目中登录相关的Cookie操作，同时借助相关的设置来保障Cookie的安全性以及有效性等，并且使用了@Slf4j注解来记录操作过程中的相关日志信息，便于跟踪和排查问题。
  */
 @Slf4j
 public class CookieUtil {
+
+    // 定义Cookie的域名，用于指定该Cookie在哪个域名下有效，这里固定设置为"oursnail.cn"，意味着只有访问该域名下的页面时，对应的Cookie才会被携带和使用。
     private final static String COOKIE_DOMAIN = "oursnail.cn";
-    private final static String COOKIE_NAME = "snailmall_login_token";
 
+    // 定义Cookie的名称，用于标识登录相关的Cookie，在整个项目中通过这个固定的名称来获取和操作对应的Cookie，这里设置为"snailmall_login_token"。
+    private final static String COOKIE_NAME = "snailmall_login_token";
 
     /**
-     * 登陆的时候写入cookie
-     * @param response
-     * @param token
+     * 此方法用于在用户登录的时候向客户端（浏览器）写入登录相关的Cookie。
+     * 通过创建一个新的Cookie对象，设置其域名、路径、是否仅HTTP访问以及有效期等属性，然后将该Cookie添加到响应对象中，使得浏览器能够接收到并保存这个Cookie信息。
+     * @param response HttpServletResponse对象，用于向客户端发送响应，通过它来添加要写入的Cookie信息。
+     * @param token 要写入Cookie的具体值，通常是代表用户登录认证的令牌等相关信息，用于后续识别用户身份等操作。
      */
-    public static void writeLoginToken(HttpServletResponse response,String token){
-        Cookie ck = new Cookie(COOKIE_NAME,token);
+    public static void writeLoginToken(HttpServletResponse response, String token) {
+        // 创建一个新的Cookie对象，名称为固定的COOKIE_NAME，值为传入的token参数
+        Cookie ck = new Cookie(COOKIE_NAME, token);
+
+        // 设置Cookie的域名，使其在指定的域名（COOKIE_DOMAIN）下有效，确保只有访问该域名的页面时，浏览器才会发送这个Cookie到服务器端。
         ck.setDomain(COOKIE_DOMAIN);
-        ck.setPath("/");//设值在根目录
-        ck.setHttpOnly(true);//不允许通过脚本访问cookie,避免脚本攻击
-        ck.setMaxAge(60*60*24*365);//一年，-1表示永久,单位是秒，maxage不设置的话，cookie就不会写入硬盘，只会写在内存，只在当前页面有效
-        log.info("write cookieName:{},cookieValue:{}",ck.getName(),ck.getValue());
+
+        // 设置Cookie的路径为根目录（"/"），意味着该Cookie在该域名下的所有页面路径都会被携带，方便在整个网站范围内都能使用这个Cookie进行相关操作。
+        ck.setPath("/");
+
+        // 设置Cookie为HttpOnly属性为true，这样可以防止通过JavaScript等脚本语言来访问该Cookie，避免了可能的脚本攻击风险，提高了Cookie的安全性。
+        ck.setHttpOnly(true);
+
+        // 设置Cookie的最大存活时间，这里设置为一年（以秒为单位进行换算，60秒 * 60分钟 * 24小时 * 365天），表示该Cookie在客户端浏览器上保存的时长，超过这个时间后浏览器会自动删除该Cookie。
+        // 如果设置为-1则表示永久有效，若不设置这个属性（maxAge不设置），Cookie就不会写入硬盘，只会保存在内存中，仅在当前页面会话有效，关闭页面后就会失效。
+        ck.setMaxAge(60 * 60 * 24 * 365);
+
+        // 记录写入的Cookie的名称和值的日志信息，方便在调试或者查看操作记录时了解具体情况。
+        log.info("write cookieName:{},cookieValue:{}", ck.getName(), ck.getValue());
+
+        // 将设置好的Cookie添加到响应对象中，这样浏览器在接收到响应时，就会保存这个Cookie信息。
         response.addCookie(ck);
     }
 
     /**
-     * 读取登陆的cookie
-     * @param request
-     * @return
+     * 此方法用于从客户端发送的HTTP请求中读取登录相关的Cookie信息。
+     * 它首先获取请求中的所有Cookie数组，然后遍历该数组，通过比较Cookie的名称是否与预定义的登录Cookie名称（COOKIE_NAME）相等，来找到对应的登录Cookie，并返回其值，如果没有找到则返回null。
+     * @param request HttpServletRequest对象，用于获取客户端发送的请求信息，从中读取Cookie相关内容。
+     * @return 返回找到的登录Cookie的值，如果不存在则返回null，该值通常是之前写入的代表用户登录认证的令牌等相关信息。
      */
-    public static String readLoginToken(HttpServletRequest request){
+    public static String readLoginToken(HttpServletRequest request) {
+        // 获取请求中的所有Cookie数组，如果没有Cookie则返回null
         Cookie[] cks = request.getCookies();
-        if(cks != null){
-            for(Cookie ck:cks){
-                log.info("cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
-                if(StringUtils.equals(ck.getName(),COOKIE_NAME)){
-                    log.info("return cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
+
+        if (cks!= null) {
+            for (Cookie ck : cks) {
+                // 记录每个Cookie的名称和值的日志信息，方便查看请求中携带的Cookie情况
+                log.info("cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
+
+                // 通过比较Cookie的名称与预定义的登录Cookie名称（COOKIE_NAME）是否相等，来判断是否为我们要找的登录Cookie
+                if (StringUtils.equals(ck.getName(), COOKIE_NAME)) {
+                    // 如果找到对应的登录Cookie，记录其名称和值的日志信息，并返回其值
+                    log.info("return cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
                     return ck.getValue();
                 }
             }
         }
+
         return null;
     }
 
     /**
-     * 注销的时候进行删除
-     * @param request
-     * @param response
+     * 此方法用于在用户注销操作时，从客户端删除对应的登录Cookie信息。
+     * 它先获取请求中的所有Cookie数组，然后遍历查找名称与预定义登录Cookie名称（COOKIE_NAME）相同的Cookie，找到后通过设置其最大存活时间为0（表示立即删除），并将修改后的Cookie添加回响应对象中，从而实现删除该Cookie的目的。
+     * @param request HttpServletRequest对象，用于获取客户端发送的请求信息，从中查找要删除的Cookie。
+     * @param response HttpServletResponse对象，用于向客户端发送响应，通过它将修改后的Cookie（设置为删除状态）发送回客户端，使得客户端浏览器能够删除对应的Cookie。
      */
-    public static void delLoginToken(HttpServletRequest request,HttpServletResponse response){
+    public static void delLoginToken(HttpServletRequest request, HttpServletResponse response) {
+        // 获取请求中的所有Cookie数组，如果没有Cookie则返回null
         Cookie[] cks = request.getCookies();
-        if(cks != null){
-            for(Cookie ck:cks) {
-                if(StringUtils.equals(ck.getName(),COOKIE_NAME)){
+
+        if (cks!= null) {
+            for (Cookie ck : cks) {
+                // 通过比较Cookie的名称与预定义的登录Cookie名称（COOKIE_NAME）是否相等，来判断是否为我们要删除的登录Cookie
+                if (StringUtils.equals(ck.getName(), COOKIE_NAME)) {
+                    // 设置要删除的Cookie的域名，确保与之前设置的域名一致，以便准确删除对应的Cookie
                     ck.setDomain(COOKIE_DOMAIN);
+
+                    // 设置Cookie的路径为根目录（"/"），与之前写入时的路径设置保持一致，确保删除的是对应的那个Cookie
                     ck.setPath("/");
-                    ck.setMaxAge(0);//0表示消除此cookie
-                    log.info("del cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
+
+                    // 设置Cookie的最大存活时间为0，表示让浏览器立即删除这个Cookie
+                    ck.setMaxAge(0);
+
+                    // 记录要删除的Cookie的名称和值的日志信息，方便查看操作情况
+                    log.info("del cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
+
+                    // 将设置好要删除状态的Cookie添加到响应对象中，浏览器接收到这个响应后，就会删除对应的Cookie
                     response.addCookie(ck);
                     return;
                 }
             }
         }
     }
-
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/utils/DateTimeUtil.java

@@ -10,59 +10,99 @@ import java.text.SimpleDateFormat;
 import java.util.Date;
 
 /**
- * @DESC 时间转换的工具类
+ * @DESC 这个类（DateTimeUtil）是一个时间转换的工具类，主要用于在字符串、日期对象（Date）以及时间戳之间进行相互转换操作，方便在不同的业务场景下对时间相关的数据进行处理和格式化展示等。
+ * 它借助了Joda-Time库来实现更灵活便捷的日期时间操作，同时也使用了Java标准库中的相关类（如SimpleDateFormat等）来完成部分功能，并且定义了一些常用的时间格式相关的方法和常量。
  */
 public class DateTimeUtil {
-    //joda-time
 
-    //str->Date
-    //Date->str
+    // joda-time
+    // 以下定义了一个常量，表示时间格式化的标准格式，用于在没有指定特定格式时，按照此通用格式进行日期时间的字符串与Date对象之间的转换操作，格式为"yyyy-MM-dd HH:mm:ss"，符合常见的日期时间展示格式要求。
+    // str->Date
+    // Date->str
     public static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
 
-
-
-    public static Date strToDate(String dateTimeStr, String formatStr){
+    /**
+     * 将指定格式的日期时间字符串转换为Date对象的方法。
+     * 首先根据传入的格式字符串（formatStr）创建一个DateTimeFormatter对象，用于解析日期时间字符串，然后使用该格式化器解析传入的日期时间字符串（dateTimeStr）得到一个DateTime对象，最后将DateTime对象转换为Java标准的Date对象并返回。
+     * @param dateTimeStr 要转换的日期时间字符串，其格式需要与传入的formatStr参数指定的格式相匹配。
+     * @param formatStr 用于解析日期时间字符串的格式字符串，例如"yyyy-MM-dd HH:mm:ss"等，指定了日期时间各部分的排列和表示方式。
+     * @return 返回解析后的Date对象，如果解析过程出现问题则可能抛出异常（由Joda-Time库内部处理相关异常情况）。
+     */
+    public static Date strToDate(String dateTimeStr, String formatStr) {
         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(formatStr);
         DateTime dateTime = dateTimeFormatter.parseDateTime(dateTimeStr);
         return dateTime.toDate();
     }
 
-    public static String dateToStr(Date date,String formatStr){
-        if(date == null){
+    /**
+     * 将Date对象转换为指定格式的日期时间字符串的方法。
+     * 如果传入的Date对象为null，则返回一个空字符串。否则，先根据传入的Date对象创建一个DateTime对象，然后按照指定的格式字符串（formatStr）将其转换为对应的日期时间字符串并返回。
+     * @param date 要转换的Date对象，如果为null则返回空字符串。
+     * @param formatStr 用于将Date对象转换为字符串时的格式字符串，决定了生成的日期时间字符串的格式表现形式。
+     * @return 返回转换后的日期时间字符串，如果传入的Date对象为null则返回空字符串，否则按照指定格式返回对应的字符串表示。
+     */
+    public static String dateToStr(Date date, String formatStr) {
+        if (date == null) {
             return StringUtils.EMPTY;
         }
         DateTime dateTime = new DateTime(date);
         return dateTime.toString(formatStr);
     }
 
-    //固定好格式
-    public static Date strToDate(String dateTimeStr){
+    /**
+     * 将符合标准格式（"yyyy-MM-dd HH:mm:ss"）的日期时间字符串转换为Date对象的方法。
+     * 内部先基于预定义的标准格式（STANDARD_FORMAT）创建一个DateTimeFormatter对象，然后使用该格式化器解析传入的日期时间字符串得到一个DateTime对象，最后将其转换为Date对象并返回。
+     * 此方法适用于已知日期时间字符串符合标准格式的情况，无需额外传入格式字符串参数，方便快捷地进行转换操作。
+     * @param dateTimeStr 要转换的日期时间字符串，其格式需要符合预定义的标准格式（"yyyy-MM-dd HH:mm:ss"）。
+     * @return 返回解析后的Date对象，如果解析过程出现问题则可能抛出异常（由Joda-Time库内部处理相关异常情况）。
+     */
+    public static Date strToDate(String dateTimeStr) {
         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(STANDARD_FORMAT);
         DateTime dateTime = dateTimeFormatter.parseDateTime(dateTimeStr);
         return dateTime.toDate();
     }
 
-    public static String dateToStr(Date date){
-        if(date == null){
+    /**
+     * 将Date对象转换为符合标准格式（"yyyy-MM-dd HH:mm:ss"）的日期时间字符串的方法。
+     * 如果传入的Date对象为null，则返回一个空字符串。否则，先根据传入的Date对象创建一个DateTime对象，然后按照标准格式（STANDARD_FORMAT）将其转换为对应的日期时间字符串并返回。
+     * 此方法适用于需要将Date对象按照通用的标准格式转换为字符串展示的场景，方便统一日期时间的字符串表示形式。
+     * @param date 要转换的Date对象，如果为null则返回空字符串。
+     * @return 返回转换后的日期时间字符串，如果传入的Date对象为null则返回空字符串，否则按照标准格式返回对应的字符串表示。
+     */
+    public static String dateToStr(Date date) {
+        if (date == null) {
             return StringUtils.EMPTY;
         }
         DateTime dateTime = new DateTime(date);
         return dateTime.toString(STANDARD_FORMAT);
     }
 
-    //Date -> 时间戳
+    /**
+     * 将Date对象转换为时间戳（从1970年1月1日00:00:00 UTC到指定日期时间的毫秒数）的方法。
+     * 如果传入的Date对象为null，则返回null。否则，先创建一个SimpleDateFormat对象，按照标准格式（"yyyy-MM-dd HH:mm:ss"）来格式化Date对象，然后将其解析为一个新的Date对象，最后获取该Date对象对应的时间戳（以毫秒为单位）并返回。
+     * 此方法在需要将日期时间转换为时间戳用于存储、比较或者其他与时间戳相关的业务操作场景下使用。
+     * @param date 要转换的Date对象，如果为null则返回null。
+     * @return 返回对应的时间戳（以毫秒为单位），如果传入的Date对象为null则返回null，否则返回从1970年1月1日00:00:00 UTC到指定日期时间的毫秒数。
+     * @throws ParseException 如果在使用SimpleDateFormat解析日期时间字符串过程中出现格式不匹配等解析错误，则会抛出此异常，需要调用者进行相应的异常处理。
+     */
     public static Long dateToChuo(Date date) throws ParseException {
-        if(date == null){
+        if (date == null) {
             return null;
         }
-        SimpleDateFormat format =   new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         return format.parse(String.valueOf(date)).getTime();
     }
 
+    /**
+     * 主函数，用于简单的测试功能，在这个方法中，创建了一个SimpleDateFormat对象，按照标准格式解析一个给定的日期时间字符串为Date对象，然后输出该Date对象对应的时间戳（以毫秒为单位）。
+     * 可以通过运行这个main方法来验证dateToChuo等相关时间转换方法的部分功能是否正确，不过这只是一个简单的示例测试，实际应用中可能需要更完善的单元测试等方式来全面测试工具类的功能。
+     * @param args 命令行参数，这里在示例中未使用。
+     * @throws ParseException 如果在使用SimpleDateFormat解析日期时间字符串过程中出现格式不匹配等解析错误，则会抛出此异常，需要在调用main方法时进行相应的异常处理。
+     */
     public static void main(String[] args) throws ParseException {
-        SimpleDateFormat format =   new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
-        String time="1970-01-06 11:45:55";
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        String time = "1970-01-06 11:45:55";
         Date date = format.parse(time);
-        System.out.print("Format To times:"+date.getTime());
+        System.out.print("Format To times:" + date.getTime());
     }
-}
+}

snailmall-api-gateway/src/main/java/com/njupt/swg/utils/JsonUtil.java

@@ -13,114 +13,130 @@ import java.io.IOException;
 import java.text.SimpleDateFormat;
 
 /**
- * jackson的序列化和反序列化
+ * @Author 作者信息（如果有）
+ * @Date 创建日期（如果有）
+ * @CONTACT 联系方式（如果有）
+ * @DESC 这个类（JsonUtil）主要用于处理Jackson库相关的序列化和反序列化操作，是对Jackson功能的一个简单封装，方便在项目中统一地将Java对象转换为JSON字符串（序列化）以及将JSON字符串转换为Java对象（反序列化）。
+ * 它通过配置ObjectMapper对象的一些属性来定制序列化和反序列化的行为，例如控制哪些字段参与转换、时间格式的处理以及如何处理一些可能出现的转换错误等情况，并且使用了@Slf4j注解来记录在操作过程中出现的相关警告等日志信息。
  */
 @Slf4j
 public class JsonUtil {
+
+    // 创建一个ObjectMapper对象，它是Jackson库中用于进行JSON序列化和反序列化的核心类，后续通过配置它的各种属性来实现特定的序列化和反序列化规则。
     private static ObjectMapper objectMapper = new ObjectMapper();
 
+    // 静态代码块，在类加载时执行，用于对ObjectMapper对象进行一系列的配置操作，以定制其序列化和反序列化的行为。
     static {
-        //所有字段都列入进行转换
+        // 设置序列化时包含的字段规则，这里设置为JsonSerialize.Inclusion.ALWAYS，表示所有字段都列入进行转换，即无论字段值是否为null，都会包含在序列化生成的JSON字符串中。
         objectMapper.setSerializationInclusion(JsonSerialize.Inclusion.ALWAYS);
-        //取消默认转换timestamp形式
-        objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS,false);
-        //忽略空bean转json的错误
-        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS,false);
-        //统一时间的格式
+
+        // 取消默认将日期类型转换为时间戳（timestamp）形式的行为，这样在序列化日期对象时，会按照后续配置的日期格式进行转换，而不是转换为时间戳格式。
+        objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, false);
+
+        // 忽略在序列化空的Java Bean（即没有属性值的对象）转JSON字符串时可能出现的错误，使得即使对象为空，也能尝试进行序列化操作，避免抛出异常。
+        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
+
+        // 统一设置时间的格式，通过传入一个SimpleDateFormat对象，并指定格式为DateTimeUtil类中定义的标准格式（"yyyy-MM-dd HH:mm:ss"），使得在序列化和反序列化日期对象时，都按照这个标准格式进行处理。
         objectMapper.setDateFormat(new SimpleDateFormat(DateTimeUtil.STANDARD_FORMAT));
-        //忽略json存在属性，但是java对象不存在属性的错误
-        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,false);
+
+        // 忽略在反序列化JSON字符串时，如果JSON中存在的属性但对应的Java对象不存在该属性的这种错误情况，使得即使JSON数据和Java对象结构不完全匹配，也能尽量进行反序列化操作，避免因属性不匹配而抛出异常。
+        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
     }
 
     /**
-     * 序列化方法，将对象转为字符串
-     * @param obj
-     * @param <T>
-     * @return
+     * 序列化方法，用于将Java对象转换为JSON字符串。
+     * 如果传入的对象为null，则直接返回null。如果对象本身就是String类型，则直接返回该字符串（因为本身已经是符合要求的字符串形式了），否则使用ObjectMapper对象将对象转换为JSON字符串，若转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param obj 要进行序列化的Java对象，其类型可以是任意Java类，只要该类能被Jackson库正确序列化（即符合Jackson序列化的相关规则，比如有合适的Getter、Setter方法等）。
+     * @param <T> 泛型参数，表示传入对象的类型，这里主要用于方法定义的通用性，使得可以处理各种类型的对象序列化。
+     * @return 返回序列化后的JSON字符串，如果传入对象为null或者序列化过程出现异常则返回null。
      */
-    public static <T> String obj2String(T obj){
-        if(obj == null){
+    public static <T> String obj2String(T obj) {
+        if (obj == null) {
             return null;
         }
         try {
-            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
+            return obj instanceof String? (String) obj : objectMapper.writeValueAsString(obj);
         } catch (IOException e) {
-            log.warn("parse object to string error",e);
+            log.warn("parse object to string error", e);
             return null;
         }
     }
 
     /**
-     * 序列化方法，同上，只是输出的格式是美化的，便于测试
-     * @param obj
-     * @param <T>
-     * @return
+     * 序列化方法，功能与obj2String方法类似，也是将Java对象转换为JSON字符串，不过这个方法输出的JSON字符串格式是美化后的，更便于查看和测试（例如会进行缩进、换行等格式化处理）。
+     * 如果传入的对象为null，则直接返回null。如果对象本身就是String类型，则直接返回该字符串，否则使用ObjectMapper对象的美化打印功能将对象转换为格式化后的JSON字符串，若转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param obj 要进行序列化的Java对象，其类型可以是任意Java类，只要该类能被Jackson库正确序列化。
+     * @param <T> 泛型参数，表示传入对象的类型，用于方法定义的通用性。
+     * @return 返回序列化后的、经过美化的JSON字符串，如果传入对象为null或者序列化过程出现异常则返回null。
      */
-    public static <T> String obj2StringPretty(T obj){
-        if(obj == null){
+    public static <T> String obj2StringPretty(T obj) {
+        if (obj == null) {
             return null;
         }
         try {
-            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
+            return obj instanceof String? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
         } catch (IOException e) {
-            log.warn("parse object to string error",e);
+            log.warn("parse object to string error", e);
             return null;
         }
     }
 
     /**
-     * 比较简单的反序列化的方法，将字符串转为单个对象
-     * @param str
-     * @param clazz
-     * @param <T>
-     * @return
+     * 比较简单的反序列化方法，用于将JSON字符串转换为单个Java对象。
+     * 如果传入的JSON字符串为空或者要转换的目标Java类（clazz）为null，则直接返回null。如果目标类是String类型，且传入的字符串不为空，则直接将该字符串作为结果返回（因为本身就是符合要求的字符串形式了），否则使用ObjectMapper对象将JSON字符串转换为指定类型的Java对象，若转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param str 要进行反序列化的JSON字符串，需要符合Jackson库反序列化的格式要求，即与对应的Java对象结构能够匹配（根据配置可能允许一定的属性差异情况）。
+     * @param clazz 要转换生成的目标Java对象的类型，通过传入的Class对象来指定具体的类型，以便ObjectMapper能正确地将JSON数据转换为对应的Java对象实例。
+     * @param <T> 泛型参数，表示目标Java对象的类型，用于方法定义的通用性，使得可以处理各种类型对象的反序列化。
+     * @return 返回反序列化后的Java对象，如果传入的JSON字符串为空、目标类为null或者转换过程出现异常则返回null。
      */
-    public static <T> T String2Obj(String str,Class<T> clazz){
-        if(StringUtils.isEmpty(str) || clazz == null){
+    public static <T> T String2Obj(String str, Class<T> clazz) {
+        if (StringUtils.isEmpty(str) || clazz == null) {
             return null;
         }
         try {
-            return clazz.equals(String.class)?(T)str:objectMapper.readValue(str,clazz);
+            return clazz.equals(String.class)? (T) str : objectMapper.readValue(str, clazz);
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
 
     /**
-     * 复杂对象的反序列化（通用）
-     * @param str
-     * @param typeReference
-     * @param <T>
-     * @return
+     * 复杂对象的反序列化（通用）方法，用于处理更复杂类型的JSON字符串到Java对象的转换，通过TypeReference来指定复杂的类型信息。
+     * 如果传入的JSON字符串为空或者TypeReference对象为null，则直接返回null。如果TypeReference表示的类型是String类型，且传入的字符串不为空，则直接将该字符串作为结果返回，否则使用ObjectMapper对象根据TypeReference指定的复杂类型信息将JSON字符串转换为对应的Java对象，若转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param str 要进行反序列化的JSON字符串，需要符合对应的复杂类型结构要求以及Jackson库反序列化的相关规则。
+     * @param typeReference TypeReference对象，用于指定复杂的Java对象类型信息，例如可以是包含泛型的集合类型、嵌套的复杂对象类型等，使得ObjectMapper能准确地进行反序列化操作。
+     * @param <T> 泛型参数，表示要转换生成的复杂Java对象的类型，用于方法定义的通用性。
+     * @return 返回反序列化后的复杂Java对象，如果传入的JSON字符串为空、TypeReference对象为null或者转换过程出现异常则返回null。
      */
-    public static <T> T Str2Obj(String str, TypeReference typeReference){
-        if(StringUtils.isEmpty(str) || typeReference == null){
+    public static <T> T Str2Obj(String str, TypeReference typeReference) {
+        if (StringUtils.isEmpty(str) || typeReference == null) {
             return null;
         }
         try {
-            return (T) (typeReference.getType().equals(String.class)?str:objectMapper.readValue(str,typeReference));
+            return (T) (typeReference.getType().equals(String.class)? str : objectMapper.readValue(str, typeReference));
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
 
     /**
-     * 第二种方式实现复杂对象的反序列化
-     * @param str
-     * @param collectionClass
-     * @param elementClasses
-     * @param <T>
-     * @return
+     * 第二种方式实现复杂对象的反序列化方法，通过传入集合类（collectionClass）以及元素类（elementClasses）的Class对象来构建JavaType对象，进而指定复杂的类型结构，然后使用ObjectMapper将JSON字符串转换为对应的复杂Java对象。
+     * 如果转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param str 要进行反序列化的JSON字符串，需要符合根据传入的类型信息构建的复杂类型结构以及Jackson库反序列化的相关规则。
+     * @param collectionClass 表示集合类型的Class对象，例如List.class、Set.class等，用于指定要转换生成的复杂对象中最外层的集合类型。
+     * @param elementClasses 可变参数，表示集合中元素的类型的Class对象，按照顺序依次指定集合中元素的类型，用于构建复杂的嵌套类型结构，例如对于List<String>，第一个参数是List.class，第二个参数是String.class。
+     * @param <T> 泛型参数，表示要转换生成的复杂Java对象的类型，用于方法定义的通用性。
+     * @return 返回反序列化后的复杂Java对象，如果转换过程中出现IO异常则返回null。
      */
-    public static <T> T Str2Obj(String str,Class<?> collectionClass,Class<?>... elementClasses){
-        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass,elementClasses);
+    public static <T> T Str2Obj(String str, Class<?> collectionClass, Class<?>... elementClasses) {
+        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
         try {
-            return objectMapper.readValue(str,javaType);
+            return objectMapper.readValue(str, javaType);
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/cache/CommonCacheUtil.java

@@ -12,22 +12,29 @@ import redis.clients.jedis.JedisPool;
  * @Date 2019/1/1 15:03
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（CommonCacheUtil）是一个工具类，用于对Redis缓存进行常见的操作，例如向缓存中存储数据、获取缓存中的数据、设置带有过期时间的数据以及删除缓存中的数据等操作。
+ * 它依赖于JedisPoolWrapper类来获取JedisPool连接池对象，进而获取Jedis客户端来与Redis服务器进行交互，并且通过使用@Slf4j注解来记录在操作Redis过程中出现的错误等相关日志信息，同时在遇到异常情况时会抛出SnailmallException异常，方便在业务层进行统一的异常处理。
+ * 整体作为Spring的一个组件（通过@Component注解），可以方便地在其他需要操作缓存的地方通过依赖注入来使用它。11
  */
 @Component
 @Slf4j
 public class CommonCacheUtil {
 
+    // 自动注入JedisPoolWrapper对象，用于获取JedisPool连接池，以此来建立与Redis服务器的连接并获取Jedis客户端实例，从而进行后续的缓存操作。
     @Autowired
     private JedisPoolWrapper jedisPoolWrapper;
 
-
     /**
-     * 缓存永久key
+     * 此方法用于向Redis缓存中存储一个永久有效的键值对（即没有设置过期时间）。
+     * 首先通过JedisPoolWrapper获取JedisPool连接池，如果连接池不为空，则从连接池中获取一个Jedis客户端资源，然后选择Redis的第0个数据库（通过Jedis.select(0)操作，通常可以根据实际需求选择不同的数据库编号），最后使用Jedis客户端的set方法将指定的键（key）和值（value）存储到Redis中。
+     * 如果在操作过程中出现任何异常，会记录错误日志，并抛出SnailmallException异常，向外传递Redis操作出现错误的信息。
+     * @param key 要存储到Redis中的键，通常是一个唯一标识缓存数据的字符串。
+     * @param value 要存储到Redis中对应键的值，类型为字符串，可以是各种序列化后的对象数据、文本信息等，只要符合Redis存储要求即可。
      */
     public void cache(String key, String value) {
         try {
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
+            if (pool!= null) {
                 try (Jedis Jedis = pool.getResource()) {
                     Jedis.select(0);
                     Jedis.set(key, value);
@@ -40,13 +47,17 @@ public class CommonCacheUtil {
     }
 
     /**
-     * 获取缓存key
+     * 此方法用于从Redis缓存中获取指定键（key）对应的缓存值。
+     * 先尝试通过JedisPoolWrapper获取JedisPool连接池，若连接池不为空，则从中获取Jedis客户端资源，接着选择Redis的第0个数据库，然后使用Jedis客户端的get方法获取指定键对应的缓存值，并将其赋值给本地变量value，最后返回该值。
+     * 如果在操作过程中出现异常，会记录错误日志，并抛出SnailmallException异常，向外传递Redis操作出错的信息。
+     * @param key 要从Redis中获取缓存值对应的键，需确保该键在Redis中已存在（否则将返回null），其类型为字符串。
+     * @return 返回从Redis中获取到的对应键的缓存值，如果获取失败或者键不存在则返回null，返回值类型为字符串，需要根据业务情况进行相应的反序列化等后续处理（如果存储的是序列化后的对象等情况）。
      */
     public String getCacheValue(String key) {
         String value = null;
         try {
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
+            if (pool!= null) {
                 try (Jedis Jedis = pool.getResource()) {
                     Jedis.select(0);
                     value = Jedis.get(key);
@@ -60,13 +71,19 @@ public class CommonCacheUtil {
     }
 
     /**
-     * 过期key
+     * 此方法用于向Redis缓存中存储一个带有过期时间的键值对，并且只有在键不存在时才进行存储（通过setnx操作实现）。
+     * 首先获取JedisPool连接池，若不为空则获取Jedis客户端资源，选择第0个数据库后，先使用setnx方法尝试设置键值对（如果键已经存在则设置失败，返回0；如果键不存在则设置成功，返回1），然后立即使用expire方法为该键设置指定的过期时间（以秒为单位），最后返回setnx操作的结果（即表示是否成功设置键值对）。
+     * 如果在操作过程中出现异常，会记录错误日志，并抛出SnailmallException异常，向外传递Redis操作出现错误的信息。
+     * @param key 要存储到Redis中的键，类型为字符串，需确保符合业务逻辑下的唯一性等要求（因为setnx基于键的唯一性判断是否设置成功）。
+     * @param value 要存储到Redis中对应键的值，类型为字符串，同样可以是各种序列化后的对象数据等符合Redis存储要求的内容。
+     * @param expire 要设置的过期时间，单位为秒，表示该键值对在Redis中有效的时长，超过这个时间后Redis会自动删除对应的键值对。
+     * @return 返回setnx操作的结果，1表示设置键值对成功（即键原本不存在），0表示设置失败（键已存在）。
      */
     public long cacheNxExpire(String key, String value, int expire) {
         long result = 0;
         try {
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
+            if (pool!= null) {
                 try (Jedis jedis = pool.getResource()) {
                     jedis.select(0);
                     result = jedis.setnx(key, value);
@@ -82,11 +99,13 @@ public class CommonCacheUtil {
     }
 
     /**
-     * 删除缓存key
+     * 此方法用于从Redis缓存中删除指定的键（key）对应的键值对。
+     * 先获取JedisPool连接池，若不为空则获取Jedis客户端资源，选择第0个数据库后，使用Jedis客户端的del方法尝试删除指定的键值对，若删除过程中出现异常，会记录错误日志，并抛出SnailmallException异常，向外传递Redis操作出现错误的信息。
+     * @param key 要从Redis中删除的键，需确保该键在Redis中已存在（否则删除操作无实际效果），其类型为字符串。.
      */
     public void delKey(String key) {
         JedisPool pool = jedisPoolWrapper.getJedisPool();
-        if (pool != null) {
+        if (pool!= null) {
             try (Jedis jedis = pool.getResource()) {
                 jedis.select(0);
                 try {
@@ -98,7 +117,4 @@ public class CommonCacheUtil {
             }
         }
     }
-
-
-
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/cache/JedisPoolWrapper.java

@@ -12,31 +12,58 @@ import javax.annotation.PostConstruct;
  * @Author swg.
  * @Date 2019/1/1 15:00
  * @CONTACT 317758022@qq.com
- * @DESC 只做了单个redis，但是课程中实现的redis客户端集群，要掌握一致性hash算法
+ * @DESC 这个类（JedisPoolWrapper）主要用于创建和管理JedisPool（Jedis连接池）对象，通过从配置参数中获取相关的Redis连接配置信息来初始化连接池。
+ * 虽然当前代码只实现了针对单个Redis的连接池配置，但注释中提到课程中涉及了Redis客户端集群以及要掌握一致性Hash算法，意味着后续可能有扩展到集群相关配置的需求。
+ * 它是一个Spring的组件（通过@Component注解），可以被自动扫描并注入到其他需要使用JedisPool的地方，并且使用了@Slf4j注解来记录在初始化连接池过程中的相关日志信息，方便查看初始化是否成功以及出现问题时进行排查。
  */
 @Component
 @Slf4j
 public class JedisPoolWrapper {
+
+    // 自动注入Parameters对象，该对象应该包含了Redis相关的配置参数，例如Redis服务器的主机地址、端口号以及连接池的一些配置参数（最大连接数、最大空闲连接数、最大等待时间等），用于后续初始化JedisPool连接池。
     @Autowired
     private Parameters parameters;
 
+    // 用于存储创建好的JedisPool对象，初始化为null，在init方法中会根据配置参数进行实例化，后续通过getJedisPool方法向外提供这个连接池对象，供其他代码获取并使用来与Redis服务器建立连接。
     private JedisPool jedisPool = null;
 
+    /**
+     * @PostConstruct注解标记的方法会在对象实例化且依赖注入完成后自动执行，用于进行一些初始化的操作。
+     * 在这里，此方法（init）的主要功能是根据从Parameters对象中获取的Redis配置参数来创建并初始化JedisPool连接池对象，具体步骤包括创建JedisPoolConfig对象并设置相应的连接池配置参数，然后基于这个配置对象以及Redis的主机地址、端口号等信息创建JedisPool对象。
+     * 如果初始化过程出现异常，会记录错误日志信息，方便后续排查问题。
+     */
     @PostConstruct
-    public void init(){
+    public void init() {
         try {
+            // 创建一个JedisPoolConfig对象，用于配置JedisPool连接池的各种属性，比如连接池的最大连接数、最大空闲连接数、最大等待时间等，以控制连接池的行为和性能。
             JedisPoolConfig config = new JedisPoolConfig();
+
+            // 从Parameters对象中获取Redis连接池的最大连接数配置参数，并设置到JedisPoolConfig对象中，用于限制连接池中总共可以创建的最大连接数量。
             config.setMaxTotal(parameters.getRedisMaxTotal());
+
+            // 从Parameters对象中获取Redis连接池的最大空闲连接数配置参数，并设置到JedisPoolConfig对象中，用于限制连接池中处于空闲状态的最大连接数量。
             config.setMaxIdle(parameters.getRedisMaxIdle());
+
+            // 从Parameters对象中获取获取Redis连接时的最大等待时间（单位为毫秒）配置参数，并设置到JedisPoolConfig对象中，用于指定当连接池中的连接都被占用时，获取连接最多等待的时间，超过这个时间则会抛出异常。
             config.setMaxWaitMillis(parameters.getRedisMaxWaitMillis());
-            jedisPool = new JedisPool(config,parameters.getRedisHost(),parameters.getRedisPort(),2000,"xxx");
+
+            // 使用配置好的JedisPoolConfig对象，以及从Parameters对象中获取的Redis服务器的主机地址（parameters.getRedisHost()）、端口号（parameters.getRedisPort()）等信息创建JedisPool对象，
+            // 这里的2000表示连接超时时间（单位为毫秒），"xxx"表示连接Redis服务器的密码（实际应用中应替换为真实的密码），通过这个构造方法实例化JedisPool连接池，完成初始化工作。
+            jedisPool = new JedisPool(config, parameters.getRedisHost(), parameters.getRedisPort(), 2000, "xxx");
+
+            // 记录初始化Redis连接池成功的日志信息，便于在查看日志时确认连接池是否正常初始化完成。
             log.info("【初始化redis连接池成功】");
-        }catch (Exception e){
-            log.error("【初始化redis连接池失败】",e);
+        } catch (Exception e) {
+            // 如果在初始化过程中出现异常，记录初始化Redis连接池失败的错误日志信息，并将异常对象e传递进去，方便查看详细的异常堆栈信息，用于排查初始化失败的原因。
+            log.error("【初始化redis连接池失败】", e);
         }
     }
 
+    /**
+     * 这个方法用于对外提供创建好的JedisPool连接池对象，供其他代码获取并使用，以便通过获取的连接池来获取Jedis客户端实例，进而与Redis服务器进行交互操作，比如执行数据的存储、获取、删除等操作。
+     * @return 返回创建好的JedisPool对象，如果初始化失败（即init方法执行出现异常导致jedisPool仍为null），则返回null，调用者需要进行相应的空值判断等处理。
+     */
     public JedisPool getJedisPool() {
         return jedisPool;
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/cache/Parameters.java

@@ -9,25 +9,39 @@ import org.springframework.stereotype.Component;
  * @Date 2019/1/1 14:27
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（Parameters）是一个用于存储应用程序配置参数的实体类，通过使用Spring的`@Value`注解从配置文件（通常是`application.properties`或`application.yml`等）中读取相应的配置值，并将其注入到对应的属性中。
+ * 它被标记为Spring的组件（通过`@Component`注解），可以方便地在其他需要使用这些配置参数的类中通过依赖注入的方式获取该对象，从而获取到具体的配置值。
+ * 同时使用了Lombok的`@Data`注解，自动生成了属性的Getter、Setter、ToString、EqualsAndHashCode等方法，简化了代码编写，方便对这些配置参数进行操作和使用。
  */
 @Component
 @Data
 public class Parameters {
+
     /*****redis config start*******/
+    // 使用`@Value("${redis.host}")`注解从配置文件中读取`redis.host`属性对应的值，并将其注入到`redisHost`属性中，用于存储Redis服务器的主机地址。
     @Value("${redis.host}")
     private String redisHost;
+
+    // 同样通过`@Value("${redis.port}")`注解从配置文件获取`redis.port`属性的值，注入到`redisPort`属性，用于存储Redis服务器的端口号。
     @Value("${redis.port}")
     private int redisPort;
+
+    // 此处注解可能存在书写错误，按照语义推测，应该是`@Value("${redis.max-total}")`用于获取Redis连接池的最大连接数配置参数，注入到`redisMaxTotal`属性中。
     @Value("${redis.max-idle}")
     private int redisMaxTotal;
+
+    // 按照正确的语义，`@Value("${redis.max-idle}")`应该是用于获取Redis连接池的最大空闲连接数配置参数，注入到`redisMaxIdle`属性，这里的注解与语义上的属性对应可能弄反了，实际使用时需留意修正。
     @Value("${redis.max-total}")
     private int redisMaxIdle;
+
+    // 使用`@Value("${redis.max-wait-millis}")`注解从配置文件读取Redis连接时最大等待时间（单位为毫秒）的配置参数，并注入到`redisMaxWaitMillis`属性中，用于控制获取连接的等待时长限制。
     @Value("${redis.max-wait-millis}")
     private int redisMaxWaitMillis;
     /*****redis config end*******/
 
     /*****curator config start*******/
+    // 通过`@Value("${zk.host}")`注解从配置文件获取`zk.host`属性对应的值，注入到`zkHost`属性中，用于存储Zookeeper服务器的主机地址，可能用于与Zookeeper相关的操作配置（比如分布式相关的协调等场景）。
     @Value("${zk.host}")
     private String zkHost;
     /*****curator config end*******/
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/clients/ProductClient.java

@@ -10,14 +10,28 @@ import org.springframework.web.bind.annotation.RequestParam;
  * @Date 2019/1/5 14:57
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个接口（ProductClient）是基于Spring Cloud OpenFeign框架定义的一个客户端接口，用于声明对名为"product-service"的服务进行远程调用的相关方法。
+ * 通过使用@FeignClient注解指定了要调用的服务名称（"product-service"），然后在接口中定义的各个方法上使用@RequestMapping注解来映射到对应服务中的具体端点路径，并且通过@RequestParam注解来指定请求参数，实现了以一种声明式的方式进行HTTP请求的发送以及响应的接收，方便在微服务架构中进行服务间的通信。
  */
 @FeignClient("product-service")
 public interface ProductClient {
 
+    /**
+     * 此方法声明了一个对"product-service"服务中"/product/detail.do"端点的远程调用，用于获取产品的详细信息。
+     * 通过@RequestParam("productId")注解指定了一个名为"productId"的请求参数，其类型为Integer，意味着在实际调用时需要传入产品的ID作为参数，然后期望接收到一个ServerResponse类型的响应对象，该对象包含了服务端返回的产品详细信息以及对应的状态码、提示消息等内容。
+     * @param productId 产品的唯一标识符，用于指定要获取详细信息的具体产品，其类型为Integer。
+     * @return 返回一个ServerResponse对象，其中封装了从"product-service"服务获取到的产品详细信息以及相关的响应状态码、提示消息等内容。
+     */
     @RequestMapping("/product/detail.do")
-    ServerResponse getProductDetail(@RequestParam("productId") Integer productId);
+    ServerResponse getProductDetail(@RequestParam("productId") Integer productId) ;
 
 
+    /**
+     * 此方法声明了一个对"product-service"服务中"/product/queryProduct.do"端点的远程调用，用于查询产品信息。
+     * 同样通过@RequestParam("productId")注解指定了名为"productId"的请求参数（类型为Integer），即需要传入产品ID作为参数进行查询操作，最终期望得到一个ServerResponse类型的响应对象，里面包含了查询到的产品相关信息以及对应的响应状态码、提示消息等情况。
+     * @param productId 产品的唯一标识符，用于指定要查询的具体产品，其类型为Integer。
+     * @return 返回一个ServerResponse对象，其中包含了从"product-service"服务查询到的产品相关信息以及相关的响应状态码、提示消息等内容。
+     */
     @RequestMapping("/product/queryProduct.do")
     ServerResponse queryProduct(@RequestParam("productId") Integer productId);
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/constants/Constants.java

@@ -5,38 +5,58 @@ package com.njupt.swg.common.constants;
  * @Date 2019/1/1 13:19
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（Constants）主要用于定义项目中的各种常量，通过将常量集中管理在一个类中，方便在整个项目中统一引用，提高代码的可维护性和可读性，避免了常量值的硬编码分散在各个地方，使得代码更易于理解和修改。
+ * 它包含了自定义的状态码、购物车相关的常量、产品状态相关的常量以及与Redis中产品库存等相关的前缀字符串常量等不同类型的常量定义。
  */
 public class Constants {
+
     /**自定义状态码 start**/
+    // 表示请求成功的状态码，通常在服务端成功处理请求并返回正常结果时使用，符合HTTP状态码中200表示成功的语义，方便在项目中统一表示成功的响应情况。
     public static final int RESP_STATUS_OK = 200;
 
+    // 表示未授权（用户未登录或者权限不足等情况）的状态码，对应HTTP状态码中的401，用于在需要进行权限校验的场景下，当用户没有相应权限访问资源时返回该状态码，告知客户端需要进行认证授权操作。
     public static final int RESP_STATUS_NOAUTH = 401;
 
+    // 表示服务器内部错误的状态码，等同于HTTP状态码中的500，当服务端在处理请求过程中出现了未预期的错误，例如代码运行时异常等情况时，返回这个状态码给客户端，表示服务端出现了问题，需要进一步排查和修复。
     public static final int RESP_STATUS_INTERNAL_ERROR = 500;
 
+    // 表示请求的语法错误或者参数等不符合要求的状态码，对应HTTP状态码中的400，常用于客户端发送的请求格式不正确、缺少必要参数等情况，提示客户端检查并修正请求内容。
     public static final int RESP_STATUS_BADREQUEST = 400;
 
     /**自定义状态码 end**/
 
-    public interface Cart{
-        int CHECKED = 1;//即购物车选中状态
-        int UN_CHECKED = 0;//购物车中未选中状态
+    // 以下是一个内部接口（Cart），用于定义与购物车相关的常量，将购物车相关的常量集中在这个内部接口中进行管理，使得代码结构更清晰，方便对购物车相关逻辑中使用的常量进行统一维护。
+    public interface Cart {
+        // 表示购物车中商品处于选中状态的常量，值为1，在处理购物车中商品的选中与否逻辑时，可以通过这个常量来判断和设置商品的选中状态。
+        int CHECKED = 1;
+
+        // 表示购物车中商品处于未选中状态的常量，值为0，与CHECKED常量相对应，用于区分商品在购物车中的不同选中情况。
+        int UN_CHECKED = 0;
 
+        // 表示在购物车中对商品数量限制操作失败时的提示信息常量，其值为"LIMIT_NUM_FAIL"，可用于在业务逻辑中当商品数量限制相关操作（比如添加商品数量超过限制等情况）失败时，返回给客户端相应的提示信息。
         String LIMIT_NUM_FAIL = "LIMIT_NUM_FAIL";
+
+        // 表示在购物车中对商品数量限制操作成功时的提示信息常量，值为"LIMIT_NUM_SUCCESS"，用于在商品数量限制相关操作成功后，向客户端反馈相应的成功提示消息。
         String LIMIT_NUM_SUCCESS = "LIMIT_NUM_SUCCESS";
     }
 
+    // 内部接口（Product）用于定义与产品状态相关的常量，将产品不同状态对应的常量集中在此处管理，便于在涉及产品状态判断、更新等业务逻辑中统一使用和维护这些常量。
     /** 产品的状态 **/
-    public interface Product{
+    public interface Product {
+        // 表示产品处于上架、可销售状态的常量，值为1，在业务逻辑中可以通过这个常量来判断产品是否可供用户购买等情况。
         int PRODUCT_ON = 1;
+
+        // 表示产品处于下架状态的常量，值为2，用于标识产品暂时不可销售，例如库存不足、商品调整等原因导致下架时使用该常量来表示其状态。
         int PRODUCT_OFF = 2;
+
+        // 表示产品已被删除的状态常量，值为3，当产品从系统中彻底删除后，通过这个常量来体现其在业务层面的最终状态，方便在数据查询、过滤等操作中基于这个状态进行相关处理。
         int PRODUCT_DELETED = 3;
     }
 
     /***redis product stock**/
+    // 用于定义在Redis中存储产品库存相关数据时的键（key）的前缀字符串常量，方便在Redis操作中统一管理和区分不同产品的库存相关数据，后续实际的键可以在此前缀基础上添加具体的产品标识等信息来构成完整的键。
     public static final String PRODUCT_TOKEN_STOCK_PREFIX = "product__stock_";
 
+    // 用于定义在Redis中存储产品相关数据（除库存外可能还有其他产品相关属性等情况）时的键（key）的前缀字符串常量，同样起到统一管理和区分不同产品数据在Redis中的存储的作用，便于根据这个前缀构建完整的Redis键来进行数据的读写操作。
     public static final String PRODUCT_TOKEN_PREFIX = "product__";
-
-
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/exception/ExceptionHandlerAdvice.java

@@ -1,6 +1,5 @@
 package com.njupt.swg.common.exception;
 
-
 import com.njupt.swg.common.constants.Constants;
 import com.njupt.swg.common.resp.ServerResponse;
 import lombok.extern.slf4j.Slf4j;
@@ -12,22 +11,35 @@ import org.springframework.web.bind.annotation.ResponseBody;
  * @Author swg.
  * @Date 2019/1/1 13:21
  * @CONTACT 317758022@qq.com
- * @DESC 全局异常处理
+ * @DESC 这个类（ExceptionHandlerAdvice）用于实现全局异常处理，它借助了Spring框架提供的相关注解来拦截并处理在整个应用程序运行过程中出现的异常情况，将异常统一转化为合适的响应结果返回给客户端，提高了应用程序的稳定性和用户体验。
+ * 通过使用@ControllerAdvice注解，表明这是一个全局的控制器增强类，能够对多个控制器中的异常进行统一处理。结合@ResponseBody注解，使得处理异常后返回的结果能够直接以JSON等格式写入到响应体中，方便客户端解析和处理。并且使用了@Slf4j注解来记录异常相关的详细信息，便于后续排查问题。
  */
 @ControllerAdvice
 @ResponseBody
 @Slf4j
 public class ExceptionHandlerAdvice {
+
+    /**
+     * 此方法是一个异常处理方法，使用了@ExceptionHandler(Exception.class)注解来指定它能够处理的异常类型为所有的Exception及其子类（也就是几乎所有的运行时异常和非运行时异常情况）。
+     * 当应用程序中出现未被其他更具体的异常处理器捕获的异常时，这个方法就会被调用。它首先会记录异常的详细信息（包括异常消息和堆栈信息等）到日志中，然后返回一个ServerResponse对象，该对象通过调用ServerResponse的静态方法createByErrorCodeMessage，使用预定义的表示服务器内部错误的状态码（Constants.RESP_STATUS_INTERNAL_ERROR）以及相应的提示消息（"系统异常，请稍后再试"）来构建一个统一的错误响应，告知客户端系统出现了异常情况，需要稍后再次尝试操作。
+     * @param e 捕获到的Exception类型的异常对象，包含了异常发生时的详细信息，例如异常消息、堆栈轨迹等，通过对这个对象的处理可以获取到具体的异常情况用于记录日志等操作。
+     * @return 返回一个ServerResponse对象，作为处理异常后的响应结果，其中包含了表示服务器内部错误的状态码以及相应的提示消息，用于告知客户端系统出现异常，让客户端进行相应的处理（如提示用户等）。
+     */
     @ExceptionHandler(Exception.class)
-    public ServerResponse handleException(Exception e){
-        log.error(e.getMessage(),e);
-        return ServerResponse.createByErrorCodeMessage(Constants.RESP_STATUS_INTERNAL_ERROR,"系统异常，请稍后再试");
+    public ServerResponse handleException(Exception e) {
+        log.error(e.getMessage(), e);
+        return ServerResponse.createByErrorCodeMessage(Constants.RESP_STATUS_INTERNAL_ERROR, "系统异常，请稍后再试");
     }
 
+    /**
+     * 此方法同样是一个异常处理方法，使用@ExceptionHandler(SnailmallException.class)注解指定它专门用于处理SnailmallException类型的异常，这种异常通常是项目中自定义的业务相关异常。
+     * 当抛出SnailmallException异常时，这个方法会被调用，它先将异常的详细信息记录到日志中，然后返回一个ServerResponse对象，通过调用ServerResponse的静态方法createByErrorCodeMessage，使用SnailmallException异常对象中携带的异常状态码（通过e.getExceptionStatus()获取）以及异常消息（e.getMessage()）来构建一个符合业务逻辑的错误响应，向客户端准确反馈具体的业务异常情况以及对应的错误提示信息。
+     * @param e 捕获到的SnailmallException类型的异常对象，包含了自定义业务异常发生时的具体状态码以及详细的异常消息等信息，用于构建合适的错误响应返回给客户端。
+     * @return 返回一个ServerResponse对象，作为处理SnailmallException异常后的响应结果，其中包含了从异常对象中获取的异常状态码以及对应的异常消息，用于告知客户端具体的业务异常情况，让客户端知晓并进行相应的处理（如根据错误提示修正操作等）。
+     */
     @ExceptionHandler(SnailmallException.class)
-    public ServerResponse handleException(SnailmallException e){
-        log.error(e.getMessage(),e);
-        return ServerResponse.createByErrorCodeMessage(e.getExceptionStatus(),e.getMessage());
+    public ServerResponse handleException(SnailmallException e) {
+        log.error(e.getMessage(), e);
+        return ServerResponse.createByErrorCodeMessage(e.getExceptionStatus(), e.getMessage());
     }
-
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/exception/SnailmallException.java

@@ -8,18 +8,32 @@ import lombok.Getter;
  * @Date 2019/1/1 13:18
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（SnailmallException）是自定义的异常类，继承自Java的RuntimeException，意味着它属于运行时异常，不需要在方法声明中显式地抛出或者捕获（当然也可以根据具体业务需求选择捕获处理），方便在业务逻辑中遇到特定的错误情况时抛出，以表示业务相关的异常状况。
+ * 通过使用Lombok的@Getter注解，自动生成了获取exceptionStatus属性的Getter方法，该属性用于存储异常对应的状态码，方便在全局异常处理等地方获取并使用这个状态码来构建合适的错误响应信息返回给客户端等操作。
  */
 @Getter
-public class SnailmallException extends RuntimeException{
+public class SnailmallException extends RuntimeException {
+
+    // 用于存储该异常对应的状态码，默认初始化为ResponseEnum中定义的通用错误状态码（ERROR的状态码），可以在构造方法中根据具体业务需求重新赋值，以此来区分不同类型的业务异常情况，便于在统一处理异常时进行针对性的响应。
     private int exceptionStatus = ResponseEnum.ERROR.getCode();
 
-    public SnailmallException(String msg){
+    /**
+     * 构造方法之一，接收一个字符串类型的参数msg，用于创建一个SnailmallException实例，在构造时调用父类（RuntimeException）的构造方法传入msg参数，设置异常的详细消息内容，同时使用默认的异常状态码（即ResponseEnum.ERROR.getCode()）。
+     * 适用于只需要简单传递异常消息，不需要指定特定状态码的业务异常情况，例如一般性的业务逻辑错误等场景。
+     * @param msg 异常的详细消息内容，用于描述出现异常的具体原因等信息，会在日志记录、向客户端反馈错误信息等场景下使用。
+     */
+    public SnailmallException(String msg) {
         super(msg);
     }
 
-    public SnailmallException(int code,String msg){
+    /**
+     * 构造方法之二，接收一个整数类型的参数code和一个字符串类型的参数msg，用于创建一个SnailmallException实例，在构造时调用父类（RuntimeException）的构造方法传入msg参数来设置异常的详细消息内容，同时将传入的code参数赋值给exceptionStatus属性，以此来指定该异常对应的特定状态码。
+     * 适用于需要根据不同的业务逻辑错误情况，设置不同的状态码以及相应的异常消息，方便在全局异常处理等环节根据状态码和消息准确地反馈具体的异常信息给客户端或者进行相应的业务处理的场景，例如不同模块的业务验证失败等情况可以对应不同的状态码和消息。
+     * @param code 异常对应的状态码，用于区分不同类型的业务异常，可根据业务需求自定义不同的值，通常会和项目中预定义的状态码体系（如ResponseEnum中定义的各种状态码）相关联。
+     * @param msg 异常的详细消息内容，用于描述出现异常的具体原因等信息，会在日志记录、向客户端反馈错误信息等场景下使用。
+     */
+    public SnailmallException(int code, String msg) {
         super(msg);
         exceptionStatus = code;
     }
-
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/resp/ResponseEnum.java

@@ -6,20 +6,38 @@ import lombok.Getter;
  * @Author swg.
  * @Date 2018/12/31 20:15
  * @CONTACT 317758022@qq.com
- * @DESC 基本的返回状态描述
+ * @DESC 这个枚举类（ResponseEnum）用于定义项目中基本的返回状态描述，通过将不同的返回状态码及其对应的文字描述进行统一封装在枚举值里，使得在整个项目中可以方便、规范地使用这些预定义的返回状态，增强了代码的可读性和可维护性。
+ * 并且使用了Lombok的@Getter注解，这样就能自动生成获取code和desc属性的方法，方便在其他地方获取枚举实例中定义的状态码和描述信息，用于构建相应的返回结果或者进行状态判断等操作。
  */
 @Getter
 public enum ResponseEnum {
-    SUCCESS(0,"SUCCESS"),
-    ERROR(1,"ERROR"),
-    ILLEGAL_ARGUMENTS(2,"ILLEGAL_ARGUMENTS"),
-    NEED_LOGIN(10,"NEED_LOGIN");
 
+    // 表示操作成功的枚举值，状态码为0，对应的描述信息是"SUCCESS"，通常在业务逻辑处理成功，需要向客户端返回成功标识及相关提示时使用这个枚举值来代表成功状态。
+    SUCCESS(0, "SUCCESS"),
+
+    // 表示出现错误的通用枚举值，状态码为1，描述信息为"ERROR"，用于在各种未详细区分的错误场景下，作为一个笼统的错误返回状态，告知客户端请求处理出现了问题，但没有具体指明是哪种错误类型。
+    ERROR(1, "ERROR"),
+
+    // 代表请求参数不合法的枚举值，状态码为2，描述信息是"ILLEGAL_ARGUMENTS"，常用于客户端发送的请求参数不符合业务规则、格式不正确等情况时，通过返回这个枚举值对应的状态码和描述来提示客户端参数存在问题，需要进行修正后重新请求。
+    ILLEGAL_ARGUMENTS(2, "ILLEGAL_ARGUMENTS"),
+
+    // 表示需要用户登录的枚举值，状态码为10，描述信息为"NEED_LOGIN"，当客户端尝试访问需要登录认证才能访问的资源，但未提供有效登录凭证时，服务端可以返回这个枚举值对应的状态码和描述信息，提示客户端需要先进行登录操作，然后再发起请求。
+    NEED_LOGIN(10, "NEED_LOGIN");
+
+    // 用于存储每个枚举值对应的状态码，不同的枚举值有不同的状态码，以此来区分不同的返回状态情况，方便在业务逻辑中根据状态码进行不同的处理逻辑分支判断。
     private int code;
+
+    // 用于存储每个枚举值对应的文字描述信息，直观地展示该返回状态所代表的具体含义，便于客户端或者其他开发人员理解返回结果具体表示的情况，辅助进行相应的后续操作（如提示用户、进行日志记录等）。
     private String desc;
 
-    ResponseEnum(int code,String desc){
+    /**
+     * 枚举的构造方法，用于初始化每个枚举值对应的状态码和描述信息。
+     * 在定义每个枚举值（如SUCCESS、ERROR等）时，会调用这个构造方法并传入相应的状态码和描述信息参数，来完成枚举值的实例化，使得每个枚举值都有其特定的状态码和对应的描述内容。
+     * @param code 状态码，用于唯一标识该种返回状态，在整个项目的业务逻辑中可以依据这个状态码来判断请求处理的结果情况，进而执行不同的后续操作，比如返回不同的响应内容给客户端等。
+     * @param desc 描述信息，用于详细说明状态码所代表的含义，让使用者（客户端或者其他开发人员查看代码时）能够清楚地知晓返回这个状态具体意味着什么情况，方便进行相应的处理。
+     */
+    ResponseEnum(int code, String desc) {
         this.code = code;
         this.desc = desc;
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/resp/ServerResponse.java

@@ -10,68 +10,158 @@ import java.io.Serializable;
  * @Author swg.
  * @Date 2018/12/31 20:11
  * @CONTACT 317758022@qq.com
- * @DESC 作为本项目的通用的返回封装类
+ * @DESC 这个类（ServerResponse）作为本项目的通用的返回封装类，用于对服务端返回给客户端的数据进行统一格式的封装，使得返回结果具有统一的结构，方便客户端解析和处理，同时也提高了整个项目返回数据的规范性和可读性。
+ * 它实现了Serializable接口，这样该类的实例就能够被序列化，便于在网络传输、缓存存储等场景下进行数据的传递和持久化操作，确保数据可以正确地在不同的环境中流转。
+ * 利用了Lombok的@Getter注解自动生成获取类中属性的方法，并且通过@JsonSerialize注解配置了JSON序列化的相关行为，排除值为null的字段不进行序列化，以减少不必要的数据传输，优化网络资源利用。
  */
 @Getter
 @JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
 public class ServerResponse<T> implements Serializable {
+
+    // 用于存储返回结果的状态码，通过不同的状态码来标识请求处理的结果情况，例如成功、失败以及不同类型的错误等，方便客户端根据状态码来判断后续的操作逻辑，一般会与项目中定义的状态码枚举（如ResponseEnum）相对应。
     private int status;
+
+    // 用于存储返回结果的提示消息，是对状态码含义的文字描述，更直观地向客户端传达请求处理的相关情况，比如操作成功的提示语或者出现错误时的具体原因说明等内容，有助于客户端更好地向用户展示相应的信息。
     private String msg;
+
+    // 用于存储具体的业务数据，其类型为泛型参数T，意味着可以根据不同的业务场景返回不同类型的数据，例如可以是用户信息对象、商品列表、订单详情等各种与业务相关的实体数据，灵活性较高，能够满足多样化的业务需求。
     private T data;
 
-    public ServerResponse(){}
+    // 默认的无参构造方法，主要用于在一些特定情况下（如反序列化等）创建对象实例，虽然当前类中暂时没有复杂的初始化逻辑依赖于这个构造方法，但遵循Java Bean规范保留了它。
+    public ServerResponse() {}
 
-    private ServerResponse(int status){
+    /**
+     * 私有构造方法之一，接收一个状态码作为参数，用于创建一个ServerResponse实例，通常在已知状态码且不需要额外设置提示消息和业务数据时使用，
+     * 比如在一些内部逻辑判断中，根据固定的状态码来构造返回对象，后续可能会根据具体需求再进一步完善其他属性的值，该构造方法提供了一种灵活构建返回对象的方式。
+     * @param status 传入的状态码，用于标识请求处理的结果情况，会赋值给当前实例的status属性。
+     */
+    private ServerResponse(int status) {
         this.status = status;
     }
-    private ServerResponse(int status,String msg){
+
+    /**
+     * 私有构造方法之二，接收一个状态码和一个提示消息作为参数，用于创建一个包含特定状态码和对应提示消息的ServerResponse实例，
+     * 在需要明确告知客户端某个状态以及对应的详细说明时使用，例如返回错误状态并附上具体的错误原因描述等情况，方便客户端准确知晓请求处理出现的问题所在。
+     * @param status 传入的状态码，用于标识请求处理的结果情况，会赋值给当前实例的status属性。
+     * @param msg 传入的提示消息，用于详细说明状态码所代表的含义，会赋值给当前实例的msg属性。
+     */
+    private ServerResponse(int status, String msg) {
         this.status = status;
         this.msg = msg;
     }
-    private ServerResponse(int status,T data){
+
+    /**
+     * 私有构造方法之三，接收一个状态码和具体的业务数据作为参数，用于创建一个包含特定状态码以及对应业务数据的ServerResponse实例，
+     * 常用于请求处理成功并且有具体数据需要返回给客户端的场景，比如查询操作成功后返回查询到的结果数据等情况，使得客户端能够获取到业务相关的数据进行后续展示或处理。
+     * @param status 传入的状态码，用于标识请求处理的结果情况，会赋值给当前实例的status属性。
+     * @param data 传入的具体业务数据，类型为泛型参数T，会赋值给当前实例的data属性，代表需要返回给客户端的业务相关内容。
+     */
+    private ServerResponse(int status, T data) {
         this.status = status;
         this.data = data;
     }
-    private ServerResponse(int status,String msg,T data){
+
+    /**
+     * 私有构造方法之四，接收一个状态码、一个提示消息和具体的业务数据作为参数，用于创建一个完整包含状态码、提示消息以及业务数据的ServerResponse实例，
+     * 这种情况可以更全面地向客户端传达请求处理的结果，既包含了处理状态、详细说明又有具体的数据内容，适用于多种复杂的业务返回场景，比如查询操作成功后返回查询到的数据以及一些相关的提示等情况。
+     * @param status 传入的状态码，用于标识请求处理的结果情况，会赋值给当前实例的status属性。
+     * @param msg 传入的提示消息，用于详细说明状态码所代表的含义，会赋值给当前实例的msg属性。
+     * @param data 传入的具体业务数据，类型为泛型参数T，会赋值给当前实例的data属性，代表需要返回给客户端的业务相关内容。
+     */
+    private ServerResponse(int status, String msg, T data) {
         this.status = status;
         this.msg = msg;
         this.data = data;
     }
 
+    /**
+     * 使用@JsonIgnore注解标记此方法，表示在进行JSON序列化时，该方法不会被包含在序列化结果中，主要用于在不需要向客户端暴露该方法的场景下（比如该方法只是内部用于判断逻辑）。
+     * 这个方法用于判断当前ServerResponse实例所表示的返回结果是否为成功状态，通过比较实例中的状态码与ResponseEnum中定义的成功状态码（即SUCCESS的状态码）是否相等来进行判断，方便在业务逻辑中快速确定请求是否成功处理。
+     * @return 返回一个布尔值，如果状态码与成功状态码相等则返回true，表示返回结果为成功状态；否则返回false，表示返回结果为失败或者其他非成功的状态。
+     */
     @JsonIgnore
-    public boolean isSuccess(){
+    public boolean isSuccess() {
         return this.status == ResponseEnum.SUCCESS.getCode();
     }
 
     /**
-     * 成功的方法
+     * 以下是一系列静态方法，用于方便地创建表示成功状态的ServerResponse实例，根据不同的业务需求提供了多种创建方式，增强了在返回成功结果时的灵活性，使得可以根据具体情况选择合适的方式构建返回对象。
+
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码和对应的描述信息进行实例化，
+     * 适用于简单告知客户端操作成功，不需要额外传递具体消息和业务数据的场景，例如一些简单的操作，只需要让客户端知道请求已顺利完成即可。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，在这里创建实例时暂未指定具体的数据类型，只是表明该方法可以用于创建各种类型数据对应的成功返回结果。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码和描述信息，且无具体业务数据。
      */
-    public static <T>ServerResponse<T> createBySuccess(){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),ResponseEnum.SUCCESS.getDesc());
-    }
-    public static <T>ServerResponse<T> createBySuccessMessage(String message){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),message);
-    }
-    public static <T>ServerResponse<T> createBySuccess(T data){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),data);
-    }
-    public static <T>ServerResponse<T> createBySuccess(String message,T data){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),message,data);
+    public static <T> ServerResponse<T> createBySuccess() {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), ResponseEnum.SUCCESS.getDesc());
     }
 
     /**
-     * 失败的方法
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码，并传入自定义的提示消息进行实例化，
+     * 适用于操作成功但需要向客户端传递一些额外的说明信息的场景，比如操作成功后的一些提示语、相关说明等，使得客户端可以根据这些消息进行更合适的后续处理或者展示给用户。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，在这里创建实例时暂未指定具体的数据类型，只是表明该方法可以用于创建各种类型数据对应的成功返回结果。
+     * @param message 传入的自定义提示消息，用于向客户端传达更详细的成功相关信息，会赋值给创建的ServerResponse实例的msg属性。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码和传入的提示消息，且无具体业务数据。
      */
-    public static <T>ServerResponse<T> createByError(){
-        return new ServerResponse<>(ResponseEnum.ERROR.getCode(),ResponseEnum.ERROR.getDesc());
+    public static <T> ServerResponse<T> createBySuccessMessage(String message) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), message);
     }
-    public static <T>ServerResponse<T> createByErrorMessage(String msg){
-        return new ServerResponse<>(ResponseEnum.ERROR.getCode(),msg);
+
+    /**
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码，并传入具体的业务数据进行实例化，
+     * 适用于操作成功且有具体业务数据需要返回给客户端的场景，比如查询操作成功后返回查询到的数据、获取用户信息成功后返回用户详细信息等情况，方便客户端获取到业务相关的数据进行后续处理。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，在这里创建实例时指定了具体的数据类型，由传入的参数data决定，会赋值给创建的ServerResponse实例的data属性。
+     * @param data 传入的具体业务数据，类型为泛型参数T，代表需要返回给客户端的业务相关内容。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码和传入的具体业务数据，无额外的提示消息。
+     */
+    public static <T> ServerResponse<T> createBySuccess(T data) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), data);
     }
-    public static <T>ServerResponse<T> createByErrorCodeMessage(int code,String msg){
-        return new ServerResponse<>(code,msg);
+
+    /**
+     * 创建一个表示成功状态的ServerResponse实例，使用ResponseEnum中定义的默认成功状态码，并传入自定义的提示消息和具体的业务数据进行实例化，
+     * 适用于操作成功且既有需要向客户端传递的额外说明信息，又有具体业务数据需要返回的复杂场景，比如查询操作成功后返回查询到的数据以及一些相关的提示等情况，使得客户端能够全面了解请求处理的结果并获取到业务相关的数据进行后续处理。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，在这里创建实例时指定了具体的数据类型，由传入的参数data决定，会赋值给创建的ServerResponse实例的data属性。
+     * @param message 传入的自定义提示消息，用于向客户端传达更详细的成功相关信息，会赋值给创建的ServerResponse实例的msg属性。
+     * @param data 传入的具体业务数据，类型为泛型参数T，代表需要返回给客户端的业务相关内容。
+     * @return 返回一个表示成功状态的ServerResponse实例，包含默认的成功状态码、传入的提示消息和具体业务数据。
+     */
+    public static <T> ServerResponse<T> createBySuccess(String message, T data) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), message, data);
     }
 
+    /**
+     * 以下是一系列静态方法，用于方便地创建表示失败状态的ServerResponse实例，同样根据不同的业务需求提供了多种创建方式，便于在不同的错误场景下返回合适的错误信息，使得客户端能够清楚地知晓请求出现的问题所在。
+
+     * 创建一个表示通用失败状态的ServerResponse实例，使用ResponseEnum中定义的默认失败状态码和对应的描述信息进行实例化，
+     * 适用于一些未明确细分的错误情况，作为一个笼统的错误返回给客户端，告知客户端请求处理出现了问题，但没有具体指明是哪种错误类型，让客户端知晓请求未成功处理。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，在这里创建实例时暂未指定具体的数据类型，只是表明该方法可以用于创建各种类型数据对应的失败返回结果。
+     * @return 返回一个表示失败状态的ServerResponse实例，包含默认的失败状态码和描述信息，且无具体业务数据。
+     */
+    public static <T> ServerResponse<T> createByError() {
+        return new ServerResponse<>(ResponseEnum.ERROR.getCode(), ResponseEnum.ERROR.getDesc());
+    }
 
+    /**
+     * 创建一个表示失败状态的ServerResponse实例，使用ResponseEnum中定义的默认失败状态码，并传入自定义的提示消息进行实例化，
+     * 适用于已知具体错误原因，需要向客户端传递详细错误信息的场景，通过传入的msg参数告知客户端出现错误的具体情况，方便客户端根据错误信息进行相应的处理，比如提示用户修改输入内容等。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，在这里创建实例时暂未指定具体的数据类型，只是表明该方法可以用于创建各种类型数据对应的失败返回结果。
+     * @param msg 传入的自定义提示消息，用于向客户端传达具体的错误原因等相关信息，会赋值给创建的ServerResponse实例的msg属性。
+     * @return 返回一个表示失败状态的ServerResponse实例，包含默认的失败状态码和传入的提示消息，且无具体业务数据。
+     */
+    public static <T> ServerResponse<T> createByErrorMessage(String msg) {
+        return new ServerResponse<>(ResponseEnum.ERROR.getCode(), msg);
+    }
 
-}
+    /**
+     * 创建一个表示失败状态的ServerResponse实例，传入自定义的状态码和提示消息进行实例化，
+     * 适用于需要根据不同的业务逻辑返回特定的错误状态码以及对应的详细错误信息的场景，通过传入的code和msg参数灵活地构建错误返回对象，使得可以针对不同的错误情况进行精准的返回，方便客户端准确处理相应的问题。
+     * @param <T> 泛型参数，表示可以返回不同类型的业务数据，在这里创建实例时暂未指定具体的数据类型，只是表明该方法可以用于创建各种类型数据对应的失败返回结果。
+     * @param code 传入的自定义状态码，用于标识具体的错误情况，根据业务逻辑可以设置不同的值，会赋值给创建的ServerResponse实例的status属性。
+     * @param msg 传入的自定义提示消息，用于向客户端传达具体的错误原因等相关信息，会赋值给创建的ServerResponse实例的msg属性。
+     * @return 返回一个表示失败状态的ServerResponse实例，包含传入的状态码和提示消息，且无具体业务数据。
+     */
+    public static <T> ServerResponse<T> createByErrorCodeMessage(int code, String msg) {
+        return new ServerResponse<>(code, msg);
+    }
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/utils/BigDecimalUtil.java

@@ -6,37 +6,67 @@ import java.math.BigDecimal;
  * @Author swg.
  * @Date 2019/1/5 15:20
  * @CONTACT 317758022@qq.com
- * @DESC 将数值转换为字符串类型，然后传入BigDecimal中进行处理，防止精度丢失
+ * @DESC 这个工具类（BigDecimalUtil）主要用于对数值进行高精度的数学运算操作，通过先将传入的double类型数值转换为字符串形式，再传入BigDecimal类中进行处理，以此来防止在进行数值运算（特别是涉及到小数运算）时可能出现的精度丢失问题。
+ * 它提供了加、减、乘、除四种基本的数学运算方法，方便在需要高精度数值计算的业务场景中进行准确的数值处理，并且将构造方法私有化，避免了类被实例化，符合工具类的设计规范，强调其功能性的使用方式。
  */
 public class BigDecimalUtil {
-    private BigDecimalUtil(){
+
+    // 将构造方法私有化，这样外部就不能通过new关键字来创建这个类的实例，因为这个类作为工具类，只提供静态方法供使用，不需要实例化对象来调用方法，从而保证了工具类使用方式的规范性。
+    private BigDecimalUtil() {
 
     }
 
-    public static BigDecimal add(double v1, double v2){
+    /**
+     * 实现两个double类型数值相加的方法，用于高精度的加法运算，避免精度丢失。
+     * 首先将传入的两个double类型数值v1和v2分别转换为字符串形式，然后使用这些字符串创建对应的BigDecimal对象b1和b2，最后调用BigDecimal的add方法对这两个BigDecimal对象进行加法运算，并返回运算结果。
+     * @param v1 参与加法运算的第一个double类型数值，例如商品价格、数量等需要进行精确加法计算的数值。
+     * @param v2 参与加法运算的第二个double类型数值，与v1共同参与加法运算，获取精确的相加结果。
+     * @return 返回一个BigDecimal对象，表示v1和v2相加后的精确结果，可用于后续需要高精度数值结果的业务逻辑处理，比如计算总价、累计金额等场景。
+     */
+    public static BigDecimal add(double v1, double v2) {
         BigDecimal b1 = new BigDecimal(Double.toString(v1));
         BigDecimal b2 = new BigDecimal(Double.toString(v2));
         return b1.add(b2);
     }
 
-    public static BigDecimal sub(double v1,double v2){
+    /**
+     * 实现两个double类型数值相减的方法，用于高精度的减法运算，防止精度丢失。
+     * 具体操作是先把传入的两个double类型数值v1和v2转换为字符串，以此创建对应的BigDecimal对象b1和b2，接着调用BigDecimal的subtract方法对这两个对象进行减法运算，返回相减后的结果。
+     * @param v1 参与减法运算的被减数，为double类型的数值，比如库存数量的减少、金额的扣除等业务场景中作为被减数使用。
+     * @param v2 参与减法运算的减数，同样是double类型数值，用于从v1中减去相应的值，获取精确的差值结果。
+     * @return 返回一个BigDecimal对象，代表v1减去v2后的精确差值，可应用于如计算差价、余量等需要高精度减法结果的业务逻辑场景中。
+     */
+    public static BigDecimal sub(double v1, double v2) {
         BigDecimal b1 = new BigDecimal(Double.toString(v1));
         BigDecimal b2 = new BigDecimal(Double.toString(v2));
         return b1.subtract(b2);
     }
 
-
-    public static BigDecimal mul(double v1,double v2){
+    /**
+     * 实现两个double类型数值相乘的方法，用于高精度的乘法运算，保障运算精度。
+     * 操作流程为先将传入的两个double类型数值v1和v2分别转换为字符串后构建BigDecimal对象b1和b2，随后利用BigDecimal的multiply方法对它们进行乘法运算，并返回乘积结果。
+     * @param v1 参与乘法运算的第一个因数，是double类型的数值，例如计算商品总价（单价乘以数量）等场景中作为其中一个因数参与运算。
+     * @param v2 参与乘法运算的第二个因数，同样为double类型数值，与v1共同参与乘法运算，获取精确的乘积结果。
+     * @return 返回一个BigDecimal对象，为v1和v2相乘后的精确结果，常用于如计算面积、总价等需要高精度乘法结果的业务逻辑处理中。
+     */
+    public static BigDecimal mul(double v1, double v2) {
         BigDecimal b1 = new BigDecimal(Double.toString(v1));
         BigDecimal b2 = new BigDecimal(Double.toString(v2));
         return b1.multiply(b2);
     }
 
-    public static BigDecimal div(double v1,double v2){
+    /**
+     * 实现两个double类型数值相除的方法，用于高精度的除法运算，在保证精度的同时处理了除不尽的情况，默认采用四舍五入的方式保留2位小数。
+     * 先是把传入的两个double类型数值v1和v2转化为字符串来创建对应的BigDecimal对象b1和b2，接着调用BigDecimal的divide方法进行除法运算，传入参数指定了保留小数位数为2以及舍入模式为ROUND_HALF_UP（四舍五入），最后返回除法运算的结果。
+     * @param v1 参与除法运算的被除数，即要被除的double类型数值，比如计算平均价格（总价除以数量）等场景中作为被除数使用。
+     * @param v2 参与除法运算的除数，为double类型数值，且不能为0（若为0会抛出异常，调用者需确保除数非零），用于对v1进行除法运算，获取精确的商值（保留2位小数并四舍五入）。
+     * @return 返回一个BigDecimal对象，代表v1除以v2后的精确结果（四舍五入保留2位小数），适用于如计算比率、平均数值等需要高精度且规范小数位数的除法运算结果的业务场景中。
+     */
+    public static BigDecimal div(double v1, double v2) {
         BigDecimal b1 = new BigDecimal(Double.toString(v1));
         BigDecimal b2 = new BigDecimal(Double.toString(v2));
-        return b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//四舍五入,保留2位小数
+        return b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP); //四舍五入,保留2位小数
 
         //除不尽的情况
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/utils/CookieUtil.java

@@ -8,67 +8,107 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 /**
- * cookie读写
+ * @Author 作者相关信息（若有）
+ * @Date 创建日期（若有）
+ * @CONTACT 联系方式（若有）
+ * @DESC 这个类（CookieUtil）是一个工具类，用于处理与Cookie相关的常见操作，主要围绕项目中登录相关的Cookie进行写入、读取以及注销时删除等操作，通过统一的方法封装，方便在整个项目中对登录Cookie进行规范管理，同时利用日志记录相关操作信息，便于后续的跟踪与排查问题。
  */
 @Slf4j
 public class CookieUtil {
+
+    // 定义了Cookie的域名，限定了该Cookie在哪个域名下能够被识别和使用，这里设置为"oursnail.cn"，意味着只有当访问该域名下的网页时，浏览器才会发送对应的Cookie到服务器端，以此来确保Cookie的作用范围符合项目要求。
     private final static String COOKIE_DOMAIN = "oursnail.cn";
-    private final static String COOKIE_NAME = "snailmall_login_token";
 
+    // 定义了登录相关Cookie的名称，在整个项目中通过这个固定的名称来识别和操作对应的登录Cookie，这里将其命名为"snailmall_login_token"，方便统一管理与登录认证相关的Cookie操作。
+    private final static String COOKIE_NAME = "snailmall_login_token";
 
     /**
-     * 登陆的时候写入cookie
-     * @param response
-     * @param token
+     * 此方法用于在用户登录成功时，向客户端（浏览器）写入登录相关的Cookie信息。
+     * 通过创建一个新的Cookie对象，设置其各项属性（如域名、路径、是否可通过脚本访问以及有效期等），然后将该Cookie添加到响应对象中，使得浏览器能够接收到并保存这个Cookie，以便后续在访问相关页面时携带该Cookie用于身份验证等操作。
+     * @param response HttpServletResponse类型的对象，它代表服务器对客户端的响应，通过这个对象可以向客户端发送各种响应信息，包括添加要写入的Cookie，确保浏览器能获取并保存相应的Cookie信息。
+     * @param token 要写入Cookie的具体值，通常是代表用户登录认证的令牌等关键信息，后续服务器端可以通过读取该Cookie的值来验证用户身份，确认是否已经登录等操作。
      */
-    public static void writeLoginToken(HttpServletResponse response,String token){
-        Cookie ck = new Cookie(COOKIE_NAME,token);
+    public static void writeLoginToken(HttpServletResponse response, String token) {
+        // 创建一个新的Cookie对象，其名称为预先定义的登录Cookie名称（COOKIE_NAME），值为传入的token参数，以此构建一个符合项目要求的登录Cookie实例。
+        Cookie ck = new Cookie(COOKIE_NAME, token);
+
+        // 设置Cookie的域名属性，使其与预先定义的域名（COOKIE_DOMAIN）一致，这样浏览器就能根据该域名来判断何时发送这个Cookie到服务器，确保只有访问指定域名的页面时才会携带该Cookie，保障了Cookie的作用范围准确性。
         ck.setDomain(COOKIE_DOMAIN);
-        ck.setPath("/");//设值在根目录
-        ck.setHttpOnly(true);//不允许通过脚本访问cookie,避免脚本攻击
-        ck.setMaxAge(60*60*24*365);//一年，-1表示永久,单位是秒，maxage不设置的话，cookie就不会写入硬盘，只会写在内存，只在当前页面有效
-        log.info("write cookieName:{},cookieValue:{}",ck.getName(),ck.getValue());
+
+        // 设置Cookie的路径为根目录（"/"），这意味着该Cookie在整个域名下的所有页面路径中都有效，无论用户在该域名下访问哪个具体页面，浏览器都会自动携带这个Cookie发送给服务器，方便在项目的各个页面中都能基于这个Cookie进行相关的登录验证等操作。
+        ck.setPath("/");
+
+        // 将Cookie的HttpOnly属性设置为true，这样可以防止通过JavaScript等脚本语言在客户端对该Cookie进行访问和操作，有效地避免了脚本攻击带来的安全风险，提高了Cookie存储用户信息的安全性。
+        ck.setHttpOnly(true);
+
+        // 设置Cookie的最大存活时间，这里设置为一年（换算成秒，即60秒 * 60分钟 * 24小时 * 365天），表示该Cookie在客户端浏览器上能够保存的时长，超过这个时间后浏览器会自动删除该Cookie。如果设置为 -1 则表示永久有效，若不设置该属性（maxAge不设置），Cookie就只会保存在内存中，不会写入硬盘，且只在当前页面有效，关闭页面后就会失效。
+        ck.setMaxAge(60 * 60 * 24 * 365);
+
+        // 记录要写入的Cookie的名称和值的日志信息，方便在查看日志时了解具体的Cookie写入情况，对于调试或者跟踪Cookie相关操作具有重要作用，比如排查是否正确写入了期望的登录Cookie等问题。
+        log.info("write cookieName:{},cookieValue:{}", ck.getName(), ck.getValue());
+
+        // 将设置好的Cookie添加到响应对象中，浏览器在接收到服务器的响应时，就会根据响应中的这个设置来保存相应的Cookie信息，从而完成登录Cookie的写入操作。
         response.addCookie(ck);
     }
 
     /**
-     * 读取登陆的cookie
-     * @param request
-     * @return
+     * 此方法用于从客户端发送的HTTP请求中读取登录相关的Cookie信息。
+     * 它首先尝试获取请求中包含的所有Cookie数组，然后遍历这个数组，通过比较每个Cookie的名称是否与预先定义的登录Cookie名称（COOKIE_NAME）相等，来找到对应的登录Cookie，并返回其值，如果遍历完整个Cookie数组都没有找到匹配的登录Cookie，则返回null。
+     * @param request HttpServletRequest类型的对象，它代表客户端发送给服务器的请求信息，通过这个对象可以获取请求中携带的各种数据，包括Cookie信息，以便服务器端进行相应的处理，例如验证用户登录状态等操作。
+     * @return 返回找到的登录Cookie的值，如果没有找到对应的登录Cookie则返回null，该值通常是之前写入的代表用户登录认证的令牌等关键信息，后续可用于进一步的身份验证等业务逻辑处理。
      */
-    public static String readLoginToken(HttpServletRequest request){
+    public static String readLoginToken(HttpServletRequest request) {
+        // 获取请求中的所有Cookie数组，如果请求中没有携带任何Cookie，则返回null，否则得到一个包含所有Cookie的数组，用于后续遍历查找登录Cookie的操作。
         Cookie[] cks = request.getCookies();
-        if(cks != null){
-            for(Cookie ck:cks){
-                log.info("cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
-                if(StringUtils.equals(ck.getName(),COOKIE_NAME)){
-                    log.info("return cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
+
+        if (cks!= null) {
+            for (Cookie ck : cks) {
+                // 记录每个Cookie的名称和值的日志信息，有助于在查看日志时了解请求中具体携带了哪些Cookie，方便排查与Cookie相关的问题，比如确认是否正确接收到了期望的登录Cookie等情况。
+                log.info("cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
+
+                // 通过比较当前Cookie的名称与预先定义的登录Cookie名称（COOKIE_NAME）是否相等，来判断该Cookie是否为我们要找的登录Cookie，如果相等则表示找到了对应的登录Cookie。
+                if (StringUtils.equals(ck.getName(), COOKIE_NAME)) {
+                    // 记录找到的登录Cookie的名称和值的详细日志信息，方便后续查看具体找到了哪个登录Cookie及其对应的值，然后返回该Cookie的值，用于后续的业务逻辑处理，比如验证用户身份等操作。
+                    log.info("return cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
                     return ck.getValue();
                 }
             }
         }
+
         return null;
     }
 
     /**
-     * 注销的时候进行删除
-     * @param request
-     * @param response
+     * 此方法用于在用户执行注销操作时，从客户端删除对应的登录Cookie信息。
+     * 它首先获取请求中包含的所有Cookie数组，然后遍历该数组，查找名称与预先定义的登录Cookie名称（COOKIE_NAME）相同的Cookie，找到后通过设置其最大存活时间为0（表示立即删除），并将修改后的Cookie添加回响应对象中，从而通知浏览器删除对应的Cookie，完成注销时删除登录Cookie的操作。
+     * @param request HttpServletRequest类型的对象，用于获取客户端发送的请求信息，从中查找要删除的登录Cookie，以便后续进行相应的删除操作，确保能够准确地从客户端清除对应的登录Cookie。
+     * @param response HttpServletResponse类型的对象，用于向客户端发送响应信息，通过将修改后的（设置为删除状态的）Cookie添加到响应中，告知浏览器需要删除相应的Cookie，实现从客户端删除登录Cookie的目的。
      */
-    public static void delLoginToken(HttpServletRequest request,HttpServletResponse response){
+    public static void delLoginToken(HttpServletRequest request, HttpServletResponse response) {
+        // 获取请求中的所有Cookie数组，如果请求中没有携带Cookie，则返回null，否则得到包含所有Cookie的数组，用于后续遍历查找要删除的登录Cookie的操作。
         Cookie[] cks = request.getCookies();
-        if(cks != null){
-            for(Cookie ck:cks) {
-                if(StringUtils.equals(ck.getName(),COOKIE_NAME)){
+
+        if (cks!= null) {
+            for (Cookie ck : cks) {
+                // 通过比较当前Cookie的名称与预先定义的登录Cookie名称（COOKIE_NAME）是否相等，来判断该Cookie是否为我们要删除的登录Cookie，如果相等则表示找到了对应的登录Cookie，接下来进行删除操作。
+                if (StringUtils.equals(ck.getName(), COOKIE_NAME)) {
+                    // 设置要删除的Cookie的域名属性，使其与预先定义的域名（COOKIE_DOMAIN）一致，确保能够准确地删除对应的登录Cookie，避免误删其他同名但不同域名下的Cookie情况发生。
                     ck.setDomain(COOKIE_DOMAIN);
+
+                    // 设置Cookie的路径为根目录（"/"），与之前写入该Cookie时设置的路径保持一致，这样才能准确地找到并删除对应的登录Cookie，确保删除操作的准确性。
                     ck.setPath("/");
-                    ck.setMaxAge(0);//0表示消除此cookie
-                    log.info("del cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
+
+                    // 设置Cookie的最大存活时间为0，表示让浏览器立即删除这个Cookie，从而实现从客户端清除该登录Cookie的目的，完成注销时的Cookie删除操作。
+                    ck.setMaxAge(0);
+
+                    // 记录要删除的Cookie的名称和值的日志信息，方便在查看日志时了解具体的Cookie删除情况，有助于排查与Cookie删除相关的问题，比如确认是否正确地向浏览器发送了删除登录Cookie的指令等情况。
+                    log.info("del cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
+
+                    // 将设置好要删除状态的Cookie添加到响应对象中，浏览器在接收到服务器的这个响应后，就会根据设置删除对应的Cookie，从而完成从客户端删除登录Cookie的操作。
                     response.addCookie(ck);
                     return;
                 }
             }
         }
     }
-
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/utils/DateTimeUtil.java

@@ -4,65 +4,99 @@ import org.apache.commons.lang3.StringUtils;
 import org.joda.time.DateTime;
 import org.joda.time.format.DateTimeFormat;
 import org.joda.time.format.DateTimeFormatter;
-
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 
 /**
- * @DESC 时间转换的工具类
+ * @DESC 这个类（DateTimeUtil）是一个用于时间转换的工具类，它借助了Joda-Time库以及Java标准库中的日期时间相关类，提供了在字符串、Date对象以及时间戳之间相互转换的功能，方便在不同的业务场景下对时间数据进行处理，使得时间数据的格式能够符合项目的各种需求。
  */
 public class DateTimeUtil {
-    //joda-time
 
-    //str->Date
-    //Date->str
+    // 引入Joda-Time库来进行时间相关的操作，相比Java原生的日期时间处理方式，Joda-Time提供了更方便、灵活且不易出错的接口和功能，适用于各种复杂的时间处理场景。
+    // str->Date 表示可以将表示时间的字符串转换为Date对象；Date->str表示能把Date对象转换为对应的表示时间的字符串，以下定义了一些相关的方法来实现这些转换功能。
+    // 定义了一个表示标准时间格式的常量，格式为"yyyy-MM-dd HH:mm:ss"，符合常见的日期时间展示格式，在没有特别指定其他格式的情况下，很多时间转换操作会默认使用这个格式，保证时间表示的规范性和统一性。
     public static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
 
-
-
-    public static Date strToDate(String dateTimeStr, String formatStr){
+    /**
+     * 将指定格式的日期时间字符串转换为Date对象的方法。
+     * 其实现过程是先根据传入的格式字符串（formatStr）创建一个DateTimeFormatter对象，该对象用于解析符合特定格式的日期时间字符串。然后使用这个格式化器去解析传入的日期时间字符串（dateTimeStr），得到一个DateTime对象，最后将这个DateTime对象转换为Java标准的Date对象并返回，完成从字符串到Date对象的转换。
+     * @param dateTimeStr 要转换的日期时间字符串，其格式需要与传入的formatStr参数指定的格式相匹配，这样才能被正确解析，例如传入的formatStr为"yyyy-MM-dd"，那么dateTimeStr就应该是符合这种格式的日期字符串。
+     * @param formatStr 用于解析日期时间字符串的格式字符串，比如"yyyy-MM-dd HH:mm:ss"、"yyyy-MM-dd"等，它规定了日期时间各部分的排列和表示方式，指导DateTimeFormatter如何解析传入的字符串。
+     * @return 返回解析后的Date对象，如果在解析过程中出现问题（例如字符串格式不符合要求等），则可能会抛出异常（由Joda-Time库内部处理相关异常情况）。
+     */
+    public static Date strToDate(String dateTimeStr, String formatStr) {
         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(formatStr);
         DateTime dateTime = dateTimeFormatter.parseDateTime(dateTimeStr);
         return dateTime.toDate();
     }
 
-    public static String dateToStr(Date date,String formatStr){
-        if(date == null){
+    /**
+     * 将Date对象转换为指定格式的日期时间字符串的方法。
+     * 首先判断传入的Date对象是否为null，如果是null，则返回一个空字符串。若Date对象不为null，就根据传入的Date对象创建一个DateTime对象，然后按照指定的格式字符串（formatStr）将其转换为对应的日期时间字符串并返回，以此实现从Date对象到特定格式字符串的转换。
+     * @param date 要转换的Date对象，如果为null，则直接返回空字符串，表示没有有效的日期时间数据可转换为字符串形式。
+     * @param formatStr 用于将Date对象转换为字符串时的格式字符串，决定了生成的日期时间字符串的格式表现形式，例如传入"yyyy-MM-dd"，则返回的字符串会按照这种年-月-日的简洁格式展示日期。
+     * @return 返回转换后的日期时间字符串，如果传入的Date对象为null则返回空字符串，否则按照指定格式返回对应的字符串表示，用于后续的展示、存储或者传递等操作。
+     */
+    public static String dateToStr(Date date, String formatStr) {
+        if (date == null) {
             return StringUtils.EMPTY;
         }
         DateTime dateTime = new DateTime(date);
         return dateTime.toString(formatStr);
     }
 
-    //固定好格式
-    public static Date strToDate(String dateTimeStr){
+    /**
+     * 将符合标准格式（"yyyy-MM-dd HH:mm:ss"）的日期时间字符串转换为Date对象的方法。
+     * 内部先基于预定义的标准格式（STANDARD_FORMAT）创建一个DateTimeFormatter对象，然后使用该格式化器解析传入的日期时间字符串得到一个DateTime对象，最后将其转换为Date对象并返回。此方法适用于已知日期时间字符串符合标准格式的情况，无需额外传入格式字符串参数，方便快捷地进行转换操作。
+     * @param dateTimeStr 要转换的日期时间字符串，其格式需要符合预定义的标准格式（"yyyy-MM-dd HH:mm:ss"），例如"2024-12-18 10:20:30"这样的字符串才能被正确解析转换。
+     * @return 返回解析后的Date对象，如果解析过程出现问题则可能抛出异常（由Joda-Time库内部处理相关异常情况）。
+     */
+    public static Date strToDate(String dateTimeStr) {
         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(STANDARD_FORMAT);
         DateTime dateTime = dateTimeFormatter.parseDateTime(dateTimeStr);
         return dateTime.toDate();
     }
 
-    public static String dateToStr(Date date){
-        if(date == null){
+    /**
+     * 将Date对象转换为符合标准格式（"yyyy-MM-dd HH:mm:ss"）的日期时间字符串的方法。
+     * 如果传入的Date对象为null，则返回一个空字符串。否则，先根据传入的Date对象创建一个DateTime对象，然后按照标准格式（STANDARD_FORMAT）将其转换为对应的日期时间字符串并返回。此方法适用于需要将Date对象按照通用的标准格式转换为字符串展示的场景，方便统一日期时间的字符串表示形式。
+     * @param date 要转换的Date对象，如果为null则返回空字符串，例如在没有获取到有效日期数据的情况下，返回空字符串以表示无对应的数据展示。
+     * @return 返回转换后的日期时间字符串，如果传入的Date对象为null则返回空字符串，否则按照标准格式返回对应的字符串表示，可用于在界面上统一展示日期时间等业务场景。
+     */
+    public static String dateToStr(Date date) {
+        if (date == null) {
             return StringUtils.EMPTY;
         }
         DateTime dateTime = new DateTime(date);
         return dateTime.toString(STANDARD_FORMAT);
     }
 
-    //Date -> 时间戳
+    /**
+     * 将Date对象转换为时间戳（从1970年1月1日00:00:00 UTC到指定日期时间的毫秒数）的方法。
+     * 如果传入的Date对象为null，则返回null。否则，先创建一个SimpleDateFormat对象，按照标准格式（"yyyy-MM-dd HH:mm:ss"）来格式化Date对象，然后将其解析为一个新的Date对象，最后获取该Date对象对应的时间戳（以毫秒为单位）并返回。此方法在需要将日期时间转换为时间戳用于存储、比较或者其他与时间戳相关的业务操作场景下使用。
+     * @param date 要转换的Date对象，如果为null则返回null，表示没有有效的日期数据可供转换为时间戳，例如在某些业务中，未获取到具体时间时不进行时间戳转换操作。
+     * @return 返回对应的时间戳（以毫秒为单位），如果传入的Date对象为null则返回null，否则返回从1970年1月1日00:00:00 UTC到指定日期时间的毫秒数，用于后续如数据库存储、时间顺序比较等业务逻辑处理。
+     * @throws ParseException 如果在使用SimpleDateFormat解析日期时间字符串过程中出现格式不匹配等解析错误，则会抛出此异常，需要调用者进行相应的异常处理，例如在调用该方法的地方使用try-catch块捕获异常并进行合适的处理（如记录日志、返回默认值等）。
+     */
     public static Long dateToChuo(Date date) throws ParseException {
-        if(date == null){
+        if (date == null) {
             return null;
         }
-        SimpleDateFormat format =   new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         return format.parse(String.valueOf(date)).getTime();
     }
 
+    /**
+     * 主函数，用于简单的测试功能，在这个方法中，创建了一个SimpleDateFormat对象，按照标准格式解析一个给定的日期时间字符串为Date对象，然后输出该Date对象对应的时间戳（以毫秒为单位）。
+     * 可以通过运行这个main方法来验证dateToChuo等相关时间转换方法的部分功能是否正确，不过这只是一个简单的示例测试，实际应用中可能需要更完善的单元测试等方式来全面测试工具类的功能。
+     * @param args 命令行参数，这里在示例中未使用，通常可以用于传入一些外部参数来影响测试的行为或者输入不同的测试数据等情况，但在当前简单示例中没有使用到该功能。
+     * @throws ParseException 如果在使用SimpleDateFormat解析日期时间字符串过程中出现格式不匹配等解析错误，则会抛出此异常，需要在调用main方法时进行相应的异常处理，例如使用try-catch块捕获异常以避免程序异常终止。
+     */
     public static void main(String[] args) throws ParseException {
-        SimpleDateFormat format =   new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
-        String time="1970-01-06 11:45:55";
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        String time = "1970-01-06 11:45:55";
         Date date = format.parse(time);
-        System.out.print("Format To times:"+date.getTime());
+        System.out.print("Format To times:" + date.getTime());
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/utils/JsonUtil.java

@@ -8,119 +8,134 @@ import org.codehaus.jackson.map.SerializationConfig;
 import org.codehaus.jackson.map.annotate.JsonSerialize;
 import org.codehaus.jackson.type.JavaType;
 import org.codehaus.jackson.type.TypeReference;
-
 import java.io.IOException;
 import java.text.SimpleDateFormat;
 
 /**
- * jackson的序列化和反序列化
+ * @Author 作者相关信息（若有）
+ * @Date 创建日期（若有）
+ * @CONTACT 联系方式（若有）
+ * @DESC 这个类（JsonUtil）是一个工具类，主要用于处理Jackson库相关的序列化和反序列化操作。
+ * 通过对Jackson的ObjectMapper进行一系列配置，使其能够按照项目需求，将Java对象转换为JSON字符串（序列化）以及把JSON字符串还原为Java对象（反序列化），并且在操作出现异常时，利用日志记录相关错误信息，方便排查问题。
  */
 @Slf4j
 public class JsonUtil {
+
+    // 创建一个ObjectMapper对象，它是Jackson库中核心的对象，负责实际执行序列化和反序列化的具体操作，后续通过配置它的各种属性来定制序列化和反序列化的行为规则。
     private static ObjectMapper objectMapper = new ObjectMapper();
 
+    // 静态代码块，在类加载时执行，用于对ObjectMapper对象进行一系列的配置操作，使得它符合项目在序列化和反序列化方面的特定要求。
     static {
-        //所有字段都列入进行转换
+        // 设置序列化时包含的字段规则，这里指定为JsonSerialize.Inclusion.ALWAYS，表示在将Java对象序列化为JSON字符串时，无论对象的字段值是否为null，都会把所有字段都包含进转换后的JSON字符串中，确保完整地表示对象的结构和数据。
         objectMapper.setSerializationInclusion(JsonSerialize.Inclusion.ALWAYS);
-        //取消默认转换timestamp形式
-        objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS,false);
-        //忽略空bean转json的错误
-        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS,false);
-        //统一时间的格式
+
+        // 取消默认将日期类型转换为时间戳（timestamp）形式的行为。通常情况下，Jackson默认会把日期对象转换为时间戳进行序列化，通过设置这个配置为false，就可以按照后续指定的日期格式进行序列化，更符合常见的日期展示需求。
+        objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, false);
+
+        // 忽略在序列化空的Java Bean（即没有属性值或者属性值都为null的对象）转JSON字符串时可能出现的错误。这样即使对象为空，也能尝试进行序列化操作，避免因为空对象而抛出异常，使得序列化过程更加健壮。
+        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
+
+        // 统一设置时间的格式，通过传入一个SimpleDateFormat对象，并指定格式为DateTimeUtil类中定义的标准格式（通常是"yyyy-MM-dd HH:mm:ss"这种常见的日期时间格式），使得在序列化和反序列化涉及日期类型的对象时，都按照这个统一的格式进行处理，便于数据的一致性和可读性。
         objectMapper.setDateFormat(new SimpleDateFormat(DateTimeUtil.STANDARD_FORMAT));
-        //忽略json存在属性，但是java对象不存在属性的错误
-        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,false);
+
+        // 忽略在反序列化JSON字符串时，如果JSON中存在的属性但对应的Java对象不存在该属性的这种错误情况。这样即使JSON数据和Java对象结构不完全匹配（例如JSON有多余的字段），也能尽量进行反序列化操作，避免因属性不匹配而直接抛出异常，增强了反序列化的兼容性。
+        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
     }
 
     /**
-     * 序列化方法，将对象转为字符串
-     * @param obj
-     * @param <T>
-     * @return
+     * 序列化方法，用于将Java对象转换为JSON字符串。
+     * 如果传入的对象为null，则直接返回null。若对象本身就是String类型，则直接返回该字符串（因为本身已经符合JSON字符串的要求了），否则使用配置好的ObjectMapper对象将对象转换为JSON字符串，若在转换过程中出现IO异常，则记录警告日志，并返回null表示转换失败。
+     * @param obj 要进行序列化的Java对象，其可以是任意符合Jackson序列化规则的Java类实例（例如有合适的Getter、Setter方法等），类型通过泛型参数<T>表示，体现了方法的通用性，可处理各种类型的对象序列化需求。
+     * @param <T> 泛型参数，用于指定传入对象的类型，使得该方法可以适用于不同类型的Java对象序列化，增强了方法的通用性和灵活性。
+     * @return 返回序列化后的JSON字符串，如果传入对象为null或者序列化过程出现异常则返回null，返回的字符串符合JSON格式规范，可用于网络传输、存储等需要JSON数据表示的场景。
      */
-    public static <T> String obj2String(T obj){
-        if(obj == null){
+    public static <T> String obj2String(T obj) {
+        if (obj == null) {
             return null;
         }
         try {
-            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
+            return obj instanceof String? (String) obj : objectMapper.writeValueAsString(obj);
         } catch (IOException e) {
-            log.warn("parse object to string error",e);
+            log.warn("parse object to string error", e);
             return null;
         }
     }
 
     /**
-     * 序列化方法，同上，只是输出的格式是美化的，便于测试
-     * @param obj
-     * @param <T>
-     * @return
+     * 序列化方法，功能与obj2String方法类似，同样是将Java对象转换为JSON字符串，但这个方法输出的JSON字符串格式是经过美化的，更便于查看和测试。
+     * 例如会进行缩进、换行等格式化处理，使得JSON结构更加清晰直观。如果传入的对象为null，则直接返回null，若对象本身是String类型则直接返回该字符串，否则使用ObjectMapper的美化打印功能将对象转换为格式化后的JSON字符串，若转换出现IO异常，则记录警告日志并返回null。
+     * @param obj 要进行序列化的Java对象，类型可以是任意符合Jackson序列化要求的Java类实例，通过泛型参数<T>来体现方法对不同类型对象的通用性支持，可用于各种需要将对象转换为美观JSON格式字符串的场景，比如调试、展示示例数据等。
+     * @param <T> 泛型参数，用于指定传入对象的类型，使得方法能够处理各种类型对象的序列化并输出美化后的JSON字符串，方便在不同业务场景下根据具体需求进行使用。
+     * @return 返回序列化后且经过美化的JSON字符串，如果传入对象为null或者序列化过程出现异常则返回null，返回的美化后的字符串更适合人工查看和分析JSON结构内容。
      */
-    public static <T> String obj2StringPretty(T obj){
-        if(obj == null){
+    public static <T> String obj2StringPretty(T obj) {
+        if (obj == null) {
             return null;
         }
         try {
-            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
+            return obj instanceof String? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
         } catch (IOException e) {
-            log.warn("parse object to string error",e);
+            log.warn("parse object to string error", e);
             return null;
         }
     }
 
     /**
-     * 比较简单的反序列化的方法，将字符串转为单个对象
-     * @param str
-     * @param clazz
-     * @param <T>
-     * @return
+     * 比较简单的反序列化方法，用于将JSON字符串转换为单个Java对象。
+     * 如果传入的JSON字符串为空或者要转换的目标Java类（clazz）为null，则直接返回null。若目标类是String类型，且传入的字符串不为空，则直接将该字符串作为结果返回（因为本身就是符合要求的字符串形式了），否则使用配置好的ObjectMapper对象将JSON字符串转换为指定类型的Java对象，若转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param str 要进行反序列化的JSON字符串，需要符合Jackson反序列化的格式要求以及与目标Java类的结构匹配规则（根据配置可能允许一定的属性差异情况），该字符串通常来源于网络请求、文件读取等获取JSON数据的途径。
+     * @param clazz 要转换生成的目标Java对象的类型，通过传入的Class对象来明确指定具体的类型，以便ObjectMapper能准确地将JSON数据转换为对应的Java对象实例，类型通过泛型参数<T>关联，体现了方法对不同类型对象反序列化的通用性支持。
+     * @param <T> 泛型参数，用于指定目标Java对象的类型，使得该方法可以处理各种类型的JSON字符串到Java对象的反序列化需求，方便在不同业务场景下根据实际获取的JSON数据和期望的对象类型进行转换操作。
+     * @return 返回反序列化后的Java对象，如果传入的JSON字符串为空、目标类为null或者转换过程出现异常则返回null，返回的Java对象可用于后续的业务逻辑处理，比如填充到业务模型中进行数据操作等。
      */
-    public static <T> T String2Obj(String str,Class<T> clazz){
-        if(StringUtils.isEmpty(str) || clazz == null){
+    public static <T> T String2Obj(String str, Class<T> clazz) {
+        if (StringUtils.isEmpty(str) || clazz == null) {
             return null;
         }
         try {
-            return clazz.equals(String.class)?(T)str:objectMapper.readValue(str,clazz);
+            return clazz.equals(String.class)? (T) str : objectMapper.readValue(str, clazz);
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
 
     /**
-     * 复杂对象的反序列化（通用）
-     * @param str
-     * @param typeReference
-     * @param <T>
-     * @return
+     * 复杂对象的反序列化（通用）方法，用于处理更复杂类型的JSON字符串到Java对象的转换，通过TypeReference来指定复杂的类型信息。
+     * 这种方式适用于包含泛型、嵌套结构等复杂类型的对象反序列化场景。如果传入的JSON字符串为空或者TypeReference对象为null，则直接返回null。若TypeReference表示的类型是String类型，且传入的字符串不为空，则直接将该字符串作为结果返回，否则使用ObjectMapper对象根据TypeReference指定的复杂类型信息将JSON字符串转换为对应的Java对象，若转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param str 要进行反序列化的JSON字符串，需要符合对应的复杂类型结构要求以及Jackson反序列化的相关规则，通常来源于复杂数据结构的JSON表示，比如包含嵌套对象、泛型集合等的JSON数据。
+     * @param typeReference TypeReference对象，用于详细指定复杂的Java对象类型信息，例如可以是List<String>、Map<Integer, User>等包含泛型的集合类型或者更复杂的嵌套对象类型等，使得ObjectMapper能准确地按照指定的复杂类型进行反序列化操作，泛型参数<T>表示最终要转换生成的复杂Java对象的类型。
+     * @param <T> 泛型参数，用于指定要转换生成的复杂Java对象的类型，使得该方法可以处理各种复杂类型的JSON字符串到Java对象的反序列化需求，满足不同业务场景下对复杂数据结构的反序列化处理要求。
+     * @return 返回反序列化后的复杂Java对象，如果传入的JSON字符串为空、TypeReference对象为null或者转换过程出现异常则返回null，返回的复杂Java对象可用于后续涉及复杂数据结构的业务逻辑处理，如处理嵌套的业务数据、泛型集合数据等操作。
      */
-    public static <T> T Str2Obj(String str, TypeReference typeReference){
-        if(StringUtils.isEmpty(str) || typeReference == null){
+    public static <T> T Str2Obj(String str, TypeReference typeReference) {
+        if (StringUtils.isEmpty(str) || typeReference == null) {
             return null;
         }
         try {
-            return (T) (typeReference.getType().equals(String.class)?str:objectMapper.readValue(str,typeReference));
+            return (T) (typeReference.getType().equals(String.class)? str : objectMapper.readValue(str, typeReference));
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
 
     /**
-     * 第二种方式实现复杂对象的反序列化
-     * @param str
-     * @param collectionClass
-     * @param elementClasses
-     * @param <T>
-     * @return
+     * 第二种方式实现复杂对象的反序列化方法，通过传入集合类（collectionClass）以及元素类（elementClasses）的Class对象来构建JavaType对象，进而指定复杂的类型结构，然后使用ObjectMapper将JSON字符串转换为对应的复杂Java对象。
+     * 这种方式适用于明确知道集合类型以及集合中元素类型的复杂对象反序列化场景，例如要反序列化一个List<User>类型的JSON数据，就可以传入List.class和User.class来构建相应的类型信息进行反序列化操作。若在转换过程中出现IO异常，则记录警告日志并返回null。
+     * @param str 要进行反序列化的JSON字符串，需要符合根据传入的类型信息构建的复杂类型结构以及Jackson反序列化的相关规则，来源通常是与复杂数据结构对应的JSON表示，比如包含特定类型集合数据的JSON内容。
+     * @param collectionClass 表示集合类型的Class对象，例如List.class、Set.class、Map.class等，用于指定要转换生成的复杂对象中最外层的集合类型，明确了整体的集合框架结构，类型通过泛型参数<T>关联，体现了对不同集合类型的复杂对象反序列化的通用性支持。
+     * @param elementClasses 可变参数，表示集合中元素的类型的Class对象，按照顺序依次指定集合中元素的类型，用于构建复杂的嵌套类型结构，比如对于List<User>，第一个参数传入List.class，后面跟着传入User.class来完整描述复杂的类型信息，方便ObjectMapper准确地进行反序列化操作。
+     * @param <T> 泛型参数，用于指定要转换生成的复杂Java对象的类型，使得该方法可以处理各种基于集合和元素类型组合的复杂对象的反序列化需求，适用于不同业务场景下对特定复杂数据结构的反序列化处理，便于后续在业务逻辑中使用反序列化后的复杂对象进行相关操作。
+     * @return 返回反序列化后的复杂Java对象，如果转换过程中出现IO异常则返回null，返回的复杂Java对象可用于后续涉及该复杂数据结构的业务逻辑处理，比如对集合元素进行遍历、修改等操作。
      */
-    public static <T> T Str2Obj(String str,Class<?> collectionClass,Class<?>... elementClasses){
-        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass,elementClasses);
+    public static <T> T Str2Obj(String str, Class<?> collectionClass, Class<?>... elementClasses) {
+        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
         try {
-            return objectMapper.readValue(str,javaType);
+            return objectMapper.readValue(str, javaType);
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/utils/MD5Util.java

@@ -3,9 +3,19 @@ package com.njupt.swg.common.utils;
 import java.security.MessageDigest;
 
 /**
- * MD5加密工具类
+ * @Author 作者相关信息（若有）
+ * @Date 创建日期（若有）
+ * @CONTACT 联系方式（若有）
+ * @DESC 这个类（MD5Util）是一个用于进行MD5加密的工具类，通过Java提供的MessageDigest类实现对输入字符串的MD5加密操作，并提供了方便的方法来获取按照UTF-8编码格式进行加密后的结果。同时内部包含了一些辅助方法用于字节数组与十六进制字符串之间的转换，以完成MD5加密过程中字节数据到最终十六进制表示形式的转换操作。
  */
 public class MD5Util {
+
+    /**
+     * 此私有方法用于将字节数组转换为十六进制字符串表示形式。
+     * 它遍历传入的字节数组，对每个字节调用byteToHexString方法将其转换为对应的十六进制字符串表示，然后将这些十六进制字符串依次拼接起来，最终返回整个字节数组对应的十六进制字符串结果，该方法主要在MD5加密过程中用于将加密后得到的字节数组转换为常见的十六进制格式的字符串，方便展示和使用加密后的结果。
+     * @param b 要转换的字节数组，通常是经过MD5加密算法处理后得到的字节数据，例如MessageDigest的digest方法返回的字节数组结果，需要将其转换为十六进制字符串来作为最终的MD5加密结果展示形式。
+     * @return 返回一个表示字节数组的十六进制字符串，即将字节数组中的每个字节都转换为对应的十六进制表示后拼接而成的字符串，例如加密后的字节数组[10, 20, 30]可能会转换为类似"0a141e"这样的十六进制字符串形式（具体转换结果根据字节实际值而定）。
+     */
     private static String byteArrayToHexString(byte b[]) {
         StringBuffer resultSb = new StringBuffer();
         for (int i = 0; i < b.length; i++)
@@ -14,6 +24,12 @@ public class MD5Util {
         return resultSb.toString();
     }
 
+    /**
+     * 此私有方法用于将单个字节转换为十六进制字符串表示形式。
+     * 首先将传入的字节转换为整数形式（如果字节值为负数，按照Java的规则会加上256进行转换为无符号整数表示），然后将这个整数分别除以16和取模16得到高4位和低4位对应的十六进制数字索引，再从预先定义的十六进制数字字符数组（hexDigits）中获取对应的十六进制字符，最后将这两个字符拼接起来，得到该字节对应的十六进制字符串表示，该方法是byteArrayToHexString方法中对每个字节进行转换的具体实现逻辑。
+     * @param b 要转换的单个字节，其值范围是 -128到127（在Java中字节的表示范围），经过转换后会得到对应的十六进制字符串表示，例如字节值为10，会转换为十六进制字符串"0a"。
+     * @return 返回一个长度为2的十六进制字符串，代表传入字节对应的十六进制表示形式，用于在byteArrayToHexString方法中拼接成完整的字节数组对应的十六进制字符串。
+     */
     private static String byteToHexString(byte b) {
         int n = b;
         if (n < 0)
@@ -24,11 +40,11 @@ public class MD5Util {
     }
 
     /**
-     * 返回大写MD5
-     *
-     * @param origin
-     * @param charsetname
-     * @return
+     * 此私有方法用于执行实际的MD5加密操作，并将加密结果转换为十六进制字符串返回，支持指定字符编码或者使用默认编码（当传入的字符编码为空字符串或null时）。
+     * 首先创建一个MessageDigest实例，指定使用MD5算法进行加密，然后根据传入的字符编码情况，将原始字符串转换为字节数组并传入MessageDigest的digest方法进行加密，得到加密后的字节数组，最后调用byteArrayToHexString方法将字节数组转换为十六进制字符串表示形式，若过程中出现异常则返回null，并且将最终结果转换为大写形式返回，符合常见的MD5加密结果展示规范。
+     * @param origin 要进行MD5加密的原始字符串，例如用户输入的密码、需要加密保存的数据等字符串内容，会经过MD5算法处理转换为加密后的十六进制字符串形式。
+     * @param charsetname 用于指定将原始字符串转换为字节数组时的字符编码名称，例如"utf-8"、"gbk"等，若传入为null或者空字符串，则使用默认的平台字符编码将字符串转换为字节数组进行加密操作，可根据实际业务需求选择合适的编码格式，一般推荐使用统一的编码（如UTF-8）来确保兼容性和一致性。
+     * @return 返回经过MD5加密并转换为大写的十六进制字符串结果，如果在加密过程中出现异常（例如不支持的字符编码、获取MessageDigest实例失败等情况）则返回null，该结果可用于存储加密后的密码、验证数据完整性等业务场景下作为加密后的标识使用。
      */
     private static String MD5Encode(String origin, String charsetname) {
         String resultString = null;
@@ -44,16 +60,26 @@ public class MD5Util {
         return resultString.toUpperCase();
     }
 
+    /**
+     * 此公共方法是对外提供的一个方便的接口，用于按照UTF-8编码格式对输入字符串进行MD5加密，并返回加密后的结果（十六进制大写字符串形式）。
+     * 它内部直接调用MD5Encode方法，传入原始字符串和"utf-8"作为字符编码参数，实现对字符串使用UTF-8编码进行MD5加密操作，同时可以在这个方法内方便地添加“加盐”等额外的加密增强操作（虽然当前代码中只是简单调用MD5Encode方法，但预留了加盐的注释提示，便于后续根据安全需求进行扩展），适用于项目中统一使用UTF-8编码进行MD5加密的常见业务场景，比如对用户密码进行加密存储等情况。
+     * @param origin 要进行MD5加密的原始字符串，会按照UTF-8编码格式进行加密处理，例如用户登录密码等需要加密保存的关键字符串信息。
+     * @return 返回经过UTF-8编码下的MD5加密并转换为大写的十六进制字符串结果，若加密过程出现异常则返回null，该结果可用于后续的密码验证、数据安全存储等业务逻辑处理。
+     */
     public static String MD5EncodeUtf8(String origin) {
         //这里可以加盐
         return MD5Encode(origin, "utf-8");
     }
 
+    /**
+     * 主函数，用于简单的测试功能，在这个方法中调用MD5EncodeUtf8方法对字符串"123456"进行MD5加密，并将加密后的结果输出到控制台，方便在开发过程中快速验证MD5加密功能是否正常工作，不过这只是一个简单的示例测试，实际应用中可能需要更完善的单元测试等方式来全面测试工具类的功能。
+     * @param args 命令行参数，这里在示例中未使用，通常可以用于传入一些外部参数来影响测试的行为或者输入不同的测试数据等情况，但在当前简单示例中没有使用到该功能。
+     */
     public static void main(String[] args) {
         System.out.println(MD5EncodeUtf8("123456"));
     }
 
-
+    // 预先定义的十六进制数字字符数组，用于在将字节转换为十六进制字符串时，根据字节对应的十六进制数字索引获取相应的字符表示，其中包含了0到9以及a到f的十六进制数字字符，按照顺序排列，方便在byteToHexString等方法中进行十六进制转换操作。
     private static final String hexDigits[] = {"0", "1", "2", "3", "4", "5",
             "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/common/utils/PropertiesUtil.java

@@ -12,35 +12,58 @@ import java.util.Properties;
  * @Date 2018/1/10 14:56
  * @DESC
  * @CONTACT 317758022@qq.com
+ * 这个类（PropertiesUtil）是一个工具类，主要用于读取配置文件（parameter.properties）中的属性值，通过静态代码块在类加载时加载配置文件，并提供了方便的方法来获取指定键对应的属性值，在获取过程中进行了一些必要的字符串处理（如去除空白字符等）以及对属性值不存在情况的处理，同时利用日志记录了配置文件读取过程中出现的异常情况，方便排查问题。
  */
 @Slf4j
 public class PropertiesUtil {
+
+    // 用于存储从配置文件中读取的属性信息，是一个Properties对象，它以键值对的形式保存配置文件中的各项配置内容，后续通过键来获取对应的值，实现对配置信息的访问和使用。
     private static Properties props;
 
+    // 静态代码块，在类加载时执行，主要用于加载配置文件（parameter.properties）到Properties对象中，以便后续可以获取其中的配置属性值。
     static {
+        // 指定要加载的配置文件的名称，这里固定为"parameter.properties"，意味着该工具类默认会从类路径下查找这个名称的配置文件进行加载操作，如果实际配置文件名称不同或者路径有变化，需要相应地修改此处。
         String fileName = "parameter.properties";
+
+        // 创建一个新的Properties对象，用于后续存放从配置文件中读取的键值对信息，它提供了加载配置文件以及获取属性值等相关方法，是Java中处理配置文件属性的常用类。
         props = new Properties();
+
         try {
-            props.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName),"UTF-8"));
+            // 通过类加载器获取指定配置文件（fileName）的输入流，然后使用InputStreamReader将其包装为字符流，并指定字符编码为"UTF-8"，最后调用Properties对象的load方法将配置文件的内容加载到props对象中，完成配置文件的读取操作。
+            // 如果在这个过程中出现IO异常（例如配置文件不存在、无法正确读取等情况），则会捕获该异常，并通过日志记录错误信息，方便后续查看和排查配置文件读取失败的原因。
+            props.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName), "UTF-8"));
         } catch (IOException e) {
-            log.error("配置文件读取异常",e);
+            log.error("配置文件读取异常", e);
         }
     }
 
-    public static String getProperty(String key){
+    /**
+     * 此方法用于获取指定键对应的配置文件属性值。
+     * 它首先从已加载的Properties对象（props）中获取指定键（去除前后空白字符后的键）对应的属性值，然后判断获取到的值是否为空（空白字符串或者null），如果为空则返回null，表示没有找到对应的配置属性值，若不为空则去除值的前后空白字符后返回，确保返回的属性值格式规范，便于后续使用。
+     * @param key 要获取属性值的键，是配置文件中定义的属性名称，通过传入该键可以从配置文件中查找对应的属性值，通常用于获取如数据库连接地址、端口号、应用程序的各种参数等配置信息，调用者需要确保传入的键是配置文件中存在的有效键名，否则可能返回null。
+     * @return 返回获取到的配置文件属性值，如果没有找到对应键的属性值或者属性值为空字符串则返回null，否则返回去除前后空白字符后的属性值字符串，可用于后续在业务逻辑中根据配置进行相应的操作，比如设置数据库连接参数等。
+     */
+    public static String getProperty(String key) {
         String value = props.getProperty(key.trim());
-        if(StringUtils.isBlank(value)){
+        if (StringUtils.isBlank(value)) {
             return null;
         }
         return value.trim();
     }
 
-    public static String getProperty(String key,String defaultValue){
+    /**
+     * 此方法用于获取指定键对应的配置文件属性值，与getProperty(String key)方法类似，但增加了默认值的功能。
+     * 首先从已加载的Properties对象（props）中获取指定键（去除前后空白字符后的键）对应的属性值，若获取到的值为空（空白字符串或者null），则将传入的默认值（defaultValue）赋给value变量，最后去除value的前后空白字符后返回，这样即使配置文件中没有定义对应键的属性值，也能返回一个默认的配置值，方便在业务逻辑中使用配置信息时提供一个兜底的默认设置。
+     * @param key 要获取属性值的键，是配置文件中定义的属性名称，通过传入该键尝试从配置文件中查找对应的属性值，若不存在则使用默认值，常用于一些有默认配置需求的场景，比如默认的日志级别、默认的缓存时间等配置参数获取。
+     * @param defaultValue 当配置文件中不存在指定键对应的属性值时，要返回的默认值，由调用者根据业务需求传入相应的默认配置字符串，确保在没有配置文件定义的情况下，业务逻辑能基于默认值正常运行，例如传入"DEBUG"作为默认的日志级别等情况。
+     * @return 返回获取到的配置文件属性值，如果配置文件中没有对应键的属性值则返回传入的默认值（去除前后空白字符后的默认值字符串），若配置文件中有定义则返回去除前后空白字符后的属性值字符串，用于后续在业务逻辑中依据配置进行相应的操作，比如设置系统参数等。
+     */
+    public static String getProperty(String key, String defaultValue) {
 
         String value = props.getProperty(key.trim());
-        if(StringUtils.isBlank(value)){
+        if (StringUtils.isBlank(value)) {
             value = defaultValue;
         }
         return value.trim();
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/controller/BaseController.java

@@ -10,7 +10,6 @@ import com.njupt.swg.entity.User;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
-
 import javax.servlet.http.HttpServletRequest;
 
 /**
@@ -18,23 +17,40 @@ import javax.servlet.http.HttpServletRequest;
  * @Date 2019/1/5 16:19
  * @CONTACT 317758022@qq.com
  * @DESC
+ * 这个类（BaseController）作为一个基础的控制器类，很可能被其他具体的业务控制器继承，用于提供一些通用的、与获取当前用户相关的基础功能。
+ * 它通过依赖注入获取了CommonCacheUtil对象，用于从缓存中获取数据，并且借助CookieUtil和JsonUtil工具类，分别实现从请求中读取登录相关的Cookie以及将缓存中的JSON字符串反序列化为User对象等操作，以此来获取当前登录用户的信息，若在获取过程中出现不符合预期的情况（如未登录、缓存中无对应用户信息等），则会抛出相应的自定义异常。
  */
 @Slf4j
 public class BaseController {
 
+    // 通过Spring的依赖注入机制，自动注入CommonCacheUtil对象，这个对象通常用于和缓存进行交互，比如从缓存中获取存储的用户相关数据等操作，方便在后续获取当前用户信息时使用缓存来提高效率、减少数据库查询等操作。
     @Autowired
     private CommonCacheUtil commonCacheUtil;
 
-    User getCurrentUser(HttpServletRequest httpServletRequest){
+    /**
+     * 此方法用于从HTTP请求中获取当前登录用户的信息，是整个获取当前用户逻辑的核心方法。
+     * 首先通过CookieUtil工具类从传入的HttpServletRequest对象中读取登录相关的Cookie值（登录令牌，通常用于标识用户登录状态），若读取到的登录令牌为空字符串或者null，意味着用户未登录，此时会抛出一个SnailmallException异常，提示用户未登录无法获取当前用户信息。
+     * 接着，如果成功获取到登录令牌，就使用CommonCacheUtil对象根据这个令牌去缓存中获取对应的用户信息的JSON字符串表示形式，若获取到的用户信息JSON字符串为null，表示缓存中不存在该用户的相关信息，可能是登录状态异常等原因，此时会抛出一个带有特定状态码（ResponseEnum.NEED_LOGIN.getCode()）和对应描述信息（ResponseEnum.NEED_LOGIN.getDesc()）的SnailmallException异常，提示需要登录。
+     * 最后，如果从缓存中成功获取到了用户信息的JSON字符串，就利用JsonUtil工具类将这个JSON字符串反序列化为User对象并返回，完成获取当前用户信息的操作，该User对象可用于后续的业务逻辑处理，比如根据用户权限进行不同的操作、展示用户相关数据等情况。
+     * @param httpServletRequest 代表客户端发送过来的HTTP请求对象，包含了请求的各种信息，例如请求头、请求参数以及这里用到的Cookie信息等，通过这个对象可以获取到用于判断用户登录状态的登录令牌等关键信息，是整个获取当前用户操作的基础数据来源。
+     * @return 返回一个User对象，代表当前登录的用户信息，这个对象包含了如用户名、密码、用户角色等各种与用户相关的属性信息，后续可以在继承了BaseController的具体业务控制器中使用该用户对象进行相应的业务逻辑处理。
+     * @throws SnailmallException 如果在获取当前用户信息的过程中出现用户未登录或者缓存中不存在用户信息等不符合预期的情况，会抛出这个自定义异常，由更上层的异常处理机制（比如全局异常处理类）进行统一处理，向客户端返回相应的错误提示信息，告知用户出现的问题情况。
+     */
+    User getCurrentUser(HttpServletRequest httpServletRequest) {
+        // 从请求中读取登录令牌（Cookie中的值），用于后续判断用户是否登录以及从缓存中获取对应的用户信息，若返回为空则表示没有找到登录相关的Cookie，即用户未登录。
         String loginToken = CookieUtil.readLoginToken(httpServletRequest);
-        if(StringUtils.isEmpty(loginToken)){
+        if (StringUtils.isEmpty(loginToken)) {
             throw new SnailmallException("用户未登陆，无法获取当前用户信息");
         }
+
+        // 根据获取到的登录令牌，从缓存中获取对应的用户信息的JSON字符串表示形式，缓存中通常会预先存储用户登录成功后放入的相关用户信息，方便后续快速获取，若返回为null则表示缓存中不存在该用户信息，可能是登录状态失效等原因导致。
         String userJsonStr = commonCacheUtil.getCacheValue(loginToken);
-        if(userJsonStr == null){
-            throw new SnailmallException(ResponseEnum.NEED_LOGIN.getCode(),ResponseEnum.NEED_LOGIN.getDesc());
+        if (userJsonStr == null) {
+            throw new SnailmallException(ResponseEnum.NEED_LOGIN.getCode(), ResponseEnum.NEED_LOGIN.getDesc());
         }
-        User user = JsonUtil.Str2Obj(userJsonStr,User.class);
+
+        // 利用JsonUtil工具类将从缓存中获取到的用户信息的JSON字符串反序列化为User对象，使得可以在后续业务逻辑中直接使用User对象的属性和方法进行相关操作，比如获取用户权限、展示用户详情等操作，完成获取当前用户信息的关键步骤。
+        User user = JsonUtil.Str2Obj(userJsonStr, User.class);
         return user;
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/controller/CartController.java

@@ -1,19 +1,19 @@
 package com.njupt.swg.controller;
 
-import com.njupt.swg.cache.CommonCacheUtil;
-import com.njupt.swg.common.constants.Constants;
-import com.njupt.swg.common.resp.ResponseEnum;
-import com.njupt.swg.common.resp.ServerResponse;
-import com.njupt.swg.common.utils.JsonUtil;
-import com.njupt.swg.entity.User;
-import com.njupt.swg.service.ICartService;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import javax.servlet.http.HttpServletRequest;
-import java.util.Enumeration;
+        import com.njupt.swg.cache.CommonCacheUtil;
+        import com.njupt.swg.common.constants.Constants;
+        import com.njupt.swg.common.resp.ResponseEnum;
+        import com.njupt.swg.common.resp.ServerResponse;
+        import com.njupt.swg.common.utils.JsonUtil;
+        import com.njupt.swg.entity.User;
+        import com.njupt.swg.service.ICartService;
+        import org.apache.commons.lang3.StringUtils;
+        import org.springframework.beans.factory.annotation.Autowired;
+        import org.springframework.web.bind.annotation.RequestMapping;
+        import org.springframework.web.bind.annotation.RestController;
+
+        import javax.servlet.http.HttpServletRequest;
+        import java.util.Enumeration;
 
 /**
  * @Author swg.
@@ -23,168 +23,277 @@ import java.util.Enumeration;
  */
 @RestController
 @RequestMapping("/cart")
-public class CartController extends BaseController{
+// CartController类继承自BaseController类，这意味着它可以继承BaseController中定义的通用方法和属性，
+// 例如获取当前用户信息的相关逻辑等，主要负责处理购物车模块相关的各种业务请求，是购物车功能在后端的具体控制器实现。
+public class CartController extends BaseController {
+
+    // 通过Spring框架的依赖注入功能，自动将实现了ICartService接口的实例注入到这个属性中。
+    // ICartService接口应该定义了一系列用于处理购物车业务逻辑的方法，例如添加商品、更新商品数量等操作对应的方法，
+    // 在本类的各个请求处理方法中会调用该服务层接口的方法来完成具体的业务功能。
     @Autowired
     private ICartService cartService;
+
+    // 同样通过Spring的依赖注入机制，注入CommonCacheUtil实例。
+    // CommonCacheUtil通常用于与缓存系统进行交互，比如从缓存中获取用户相关的数据等操作，
+    // 在某些购物车相关业务处理中（例如需要获取缓存中的用户信息来确定购物车归属等情况）会起到重要作用。
     @Autowired
     private CommonCacheUtil commonCacheUtil;
 
     /**
-     * 1.购物车添加商品
-     * 超过数量会返回这样的标识"limitQuantity"
-     * 失败的：LIMIT_NUM_FAIL 成功的：LIMIT_NUM_SUCCESS
+     * 1. 购物车添加商品方法
+     * 此方法用于处理客户端发起的向购物车中添加商品的HTTP请求。
+     * 在业务逻辑中，如果添加的商品数量超过了预先设定的限制数量，将会返回一个特定标识"limitQuantity"给客户端，
+     * 同时，定义了表示添加操作失败和成功的两个不同标识，分别为LIMIT_NUM_FAIL和LIMIT_NUM_SUCCESS，方便客户端依据返回结果进行相应展示或后续处理。
+     * 该方法首先调用父类BaseController中的getCurrentUser方法来获取当前已经登录的用户信息，
+     * 接着将获取到的用户的唯一标识符（user.getId()）、客户端传递过来的要添加商品的唯一标识符（productId）以及商品的添加数量（count）这三个参数传递给cartService的add方法，
+     * 最后返回由cartService处理完添加业务逻辑后生成的ServerResponse对象，该对象封装了此次添加操作的相关结果信息，包括操作状态码、提示消息以及可能的其他业务相关数据等，供客户端了解操作执行情况。
+     *
+     * @param httpServletRequest 这个参数代表了客户端发送过来的HTTP请求对象，它包含了请求的诸多信息，比如请求头、请求参数等内容。
+     *                           在本方法中，一方面可以从中获取客户端传递过来的productId和count参数，另一方面通过调用父类方法利用其中携带的信息（如Cookie等）来确定当前登录用户是谁，是整个添加商品操作的数据来源和请求上下文基础。
+     * @param productId          表示要添加到购物车中的商品的唯一标识符，其类型为整数类型（Integer），由客户端在发起请求时作为参数传入。
+     *                           购物车相关业务逻辑（例如在cartService的add方法中）会依据这个标识符去查找商品的详细信息、验证商品是否满足添加条件等，以此来决定是否能够成功将该商品添加到购物车中。
+     * @param count              代表要添加到购物车的商品数量，同样是整数类型。客户端指定要添加的该商品的具体数量，
+     *                           在服务端的业务逻辑里会根据系统设定的规则（比如库存数量限制、购物车对同一种商品数量上限等规则）来判断这个数量是否合法，进而确定添加操作能否成功执行。
+     * @return 返回一个ServerResponse对象，该对象是服务端对此次添加商品操作的整体响应封装。
+     *         如果添加操作成功，其中会包含表示成功的状态码（例如可能对应LIMIT_NUM_SUCCESS相关的状态码）、提示添加成功的消息以及可能的其他相关数据（比如添加后购物车最新的商品详情等信息）；
+     *         若添加操作失败，会包含相应的失败状态码（如LIMIT_NUM_FAIL对应的状态码）、提示失败原因的消息等内容，客户端可以根据这个返回对象来判断添加商品操作是否成功，并相应地展示提示信息给用户或者进行其他后续处理。
      */
     @RequestMapping("add.do")
-    public ServerResponse add(HttpServletRequest httpServletRequest, Integer productId, Integer count){
+    public ServerResponse add(HttpServletRequest httpServletRequest, Integer productId, Integer count) {
         User user = getCurrentUser(httpServletRequest);
 
-        return cartService.add(user.getId(),productId,count);
+        return cartService.add(user.getId(), productId, count);
     }
 
     /**
-     * 2.更新购物车某个产品数量
-     * 超过数量会返回这样的标识"limitQuantity"
-     * 失败的：LIMIT_NUM_FAIL 成功的：LIMIT_NUM_SUCCESS
+     * 2. 更新购物车某个产品数量方法
+     * 用于处理更新购物车中某个已有商品数量的HTTP请求。
+     * 当更新后的商品数量超出了业务规则所允许的数量范围时，会返回特定标识"limitQuantity"给客户端，
+     * 并且同样设定了表示操作失败和成功的标识，分别是LIMIT_NUM_FAIL和LIMIT_NUM_SUCCESS，便于客户端根据返回情况做出合适的响应和处理。
+     * 本方法先借助父类的方法获取当前登录用户的信息，随后将用户的唯一标识符（user.getId()）、要更新数量的商品的唯一标识符（productId）以及新的商品数量（count）传递给cartService的update方法，
+     * 由cartService去执行具体的更新商品数量的业务逻辑，最后返回处理后的ServerResponse对象，告知客户端更新操作的执行结果。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，通过它能够获取请求中的各种关键信息，例如请求参数以及借助父类方法利用其中的相关信息来确定当前登录用户，是整个更新商品数量操作的请求基础，为后续操作提供了必要的数据支撑。
+     * @param productId          要更新数量的商品在整个系统中的唯一标识符，是整数类型参数，由客户端在请求时传入。
+     *                           cartService会依据这个productId在购物车中准确找到对应的商品记录，进而去验证新传入的商品数量（count）是否符合业务规则（如不能超过库存、购物车单品最大数量限制等），并执行相应的更新数据库等业务操作。
+     * @param count              代表要更新为的商品数量，为整数类型，是客户端指定的该商品在购物车中将要更新到的新数量值。
+     *                           服务端的业务逻辑会根据系统既定的各种规则来检查这个数量是否合法合规，以此来判定更新操作能否顺利完成，并返回相应的操作结果给客户端。
+     * @return 返回一个ServerResponse对象，该对象包含了此次更新购物车商品数量操作的结果信息。
+     *         如果更新操作成功，里面会包含表示成功的状态码（类似LIMIT_NUM_SUCCESS对应的状态码）、提示更新成功的消息以及可能涉及的其他相关数据（例如更新后购物车中该商品的最新数量情况等信息）；
+     *         要是更新操作失败，则会包含相应的失败状态码（如LIMIT_NUM_FAIL对应的状态码）、提示失败原因的消息等内容，客户端可以根据此返回对象来判断更新操作是否成功，并进行相应的展示提示信息或后续处理工作。
      */
     @RequestMapping("update.do")
-    public ServerResponse update(HttpServletRequest httpServletRequest,Integer productId,Integer count){
+    public ServerResponse update(HttpServletRequest httpServletRequest, Integer productId, Integer count) {
         User user = getCurrentUser(httpServletRequest);
 
-        return cartService.update(user.getId(),productId,count);
+        return cartService.update(user.getId(), productId, count);
     }
 
     /**
-     * 3.移除购物车某个产品
+     * 3. 移除购物车某个产品方法
+     * 此方法用于处理从购物车中移除特定商品的HTTP请求。
+     * 首先会调用父类的方法获取当前登录用户的信息，然后把获取到的用户的唯一标识符（user.getId()）以及表示要移除商品的相关标识信息（productIds）传递给cartService的delete方法，
+     * 这里的productIds参数为字符串类型，其内容格式可能根据业务需求而定，比如可以是单个商品的唯一标识符，也可能是多个商品的唯一标识符按照某种特定的分隔规则拼接而成的字符串，
+     * cartService会依据具体的业务逻辑对这个productIds进行解析和处理，执行相应的从购物车中移除商品的操作，最后返回ServerResponse对象告知客户端移除操作的执行结果。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，它承载了请求的相关信息，在本方法中主要用于获取客户端传入的要移除商品的productIds参数，同时借助父类方法获取当前登录用户信息，是整个移除商品操作的请求依据和数据来源。
+     * @param productIds         表示要从购物车中移除的商品的标识信息，其类型为字符串类型（String），具体内容格式根据业务设计而定，
+     *                           可能是单个商品的ID（如"123"代表某个商品），也可能是多个商品ID按照一定分隔符拼接的形式（如"123,456,789"代表要移除多个商品），cartService会按照既定的业务逻辑对其进行解析和处理，完成从购物车中移除对应商品的操作，并返回相应的结果。
+     * @return 返回一个ServerResponse对象，该对象封装了移除商品操作的结果信息，比如操作成功时会包含表示成功的状态码、提示移除成功的消息以及可能相关的数据（例如移除后购物车剩余商品的情况等信息）；
+     *         若操作失败，则包含相应的失败状态码、提示失败原因的消息等内容，客户端可以根据这个返回对象判断移除操作是否成功，并据此进行相应的展示提示信息或者后续处理等工作。
      */
     @RequestMapping("delete_product.do")
-    public ServerResponse delete_product(HttpServletRequest httpServletRequest,String productIds){
+    public ServerResponse delete_product(HttpServletRequest httpServletRequest, String productIds) {
         User user = getCurrentUser(httpServletRequest);
 
-        return cartService.delete(user.getId(),productIds);
+        return cartService.delete(user.getId(), productIds);
     }
 
     /**
-     * 4.购物车List列表
-     * 价格的单位是元,保留小数后2位
+     * 4. 购物车List列表方法
+     * 用于处理客户端发起的获取购物车商品列表的HTTP请求。
+     * 该方法先通过调用父类的方法获取当前登录用户的信息，然后将获取到的用户的唯一标识符（user.getId()）传递给cartService的list方法，
+     * cartService的list方法会去查询数据库或者其他数据源，获取该用户购物车中所有商品的详细信息，并整理成列表形式返回，返回的结果会封装在ServerResponse对象中，
+     * 同时要求商品价格信息的单位是元，并且保留小数点后2位，这样可以保证返回给客户端的购物车商品列表数据格式规范、便于展示给用户查看购物车中的商品详情以及总价等信息。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，通过它可以借助父类方法获取当前登录用户信息，以此来确定具体是哪个用户的购物车商品列表需要获取，是整个获取购物车列表操作的请求基础，为后续的查询操作提供了关键的数据依据。
+     * @return 返回一个ServerResponse对象，该对象包含了操作的状态码、提示消息以及最重要的购物车商品列表数据。
+     *         其中购物车商品列表数据部分要求商品价格按照规定格式展示，即单位为元且保留2位小数，客户端接收到这个对象后，可以根据其中的数据将购物车中的商品详情、总价等信息展示给用户，方便用户直观地查看购物车内容。
      */
     @RequestMapping("list.do")
-    public ServerResponse list(HttpServletRequest httpServletRequest){
+    public ServerResponse list(HttpServletRequest httpServletRequest) {
         User user = getCurrentUser(httpServletRequest);
 
         return cartService.list(user.getId());
     }
 
-
     /**
      * 5.购物车全选
      */
+    /**
+     * 5. 购物车全选方法
+     * 此方法用于处理将购物车中所有商品全部设置为选中状态的HTTP请求。
+     * 首先，它会调用父类BaseController中的`getCurrentUser`方法，从传入的`httpServletRequest`中获取当前登录用户的信息，
+     * 这是因为后续操作需要明确是哪个用户的购物车进行全选操作，确保操作的针对性和数据准确性。
+     * 然后，将获取到的用户的唯一标识符（`user.getId()`）、表示选中状态的常量（`Constants.Cart.CHECKED`）以及`null`（在这里表示不需要指定特定商品，因为是对所有商品进行操作）作为参数传递给`cartService`的`selectOrUnSelect`方法，
+     * 由`cartService`去执行具体的将购物车所有商品设置为选中状态的业务逻辑，例如更新数据库中对应购物车商品记录的选中标识等操作，最后返回`ServerResponse`对象告知客户端全选操作的执行结果。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，它包含了请求的各种信息，通过调用父类方法利用其中的相关信息（如Cookie等）来确定当前登录用户，是整个购物车全选操作的请求基础，为后续的业务操作提供必要的数据依据。
+     * @return 返回一个`ServerResponse`对象，该对象包含了购物车全选操作的结果信息，例如操作成功时会包含表示成功的状态码、提示全选操作成功的消息等内容，方便客户端根据返回结果判断操作是否成功，并进行相应的后续处理（比如更新界面上购物车商品的选中状态显示等）。
+     */
     @RequestMapping("select_all.do")
-    public ServerResponse select_all(HttpServletRequest httpServletRequest){
+    public ServerResponse select_all(HttpServletRequest httpServletRequest) {
         User user = getCurrentUser(httpServletRequest);
 
-        return cartService.selectOrUnSelect(user.getId(), Constants.Cart.CHECKED,null);
+        return cartService.selectOrUnSelect(user.getId(), Constants.Cart.CHECKED, null);
     }
 
     /**
-     * 6.购物车全不选
+     * 6. 购物车全不选方法
+     * 用于处理将购物车中所有商品全部取消选中（设置为未选中状态）的HTTP请求。
+     * 同样先调用父类的`getCurrentUser`方法从`httpServletRequest`中获取当前登录用户信息，以明确是针对哪个用户的购物车进行操作。
+     * 接着把用户的唯一标识符（`user.getId()`）、表示未选中状态的常量（`Constants.Cart.UN_CHECKED`）以及`null`（因为是对所有商品操作，无需指定特定商品）传递给`cartService`的`selectOrUnSelect`方法，
+     * 由`cartService`执行将购物车所有商品设置为未选中状态的业务逻辑，比如更新数据库中购物车商品记录的选中标识字段等，最后返回`ServerResponse`对象告知客户端全不选操作的执行结果。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，通过它可以获取请求相关信息并借助父类方法确定当前登录用户，是整个购物车全不选操作的请求基础，为后续业务逻辑执行提供了关键的数据支撑。
+     * @return 返回一个`ServerResponse`对象，包含了购物车全不选操作的结果信息，如操作成功的状态码、提示全不选操作成功的消息等内容，方便客户端根据返回结果判断操作是否成功，并据此进行相应的后续处理（例如更新界面上购物车商品的选中状态显示等）。
      */
     @RequestMapping("un_select_all.do")
-    public ServerResponse un_select_all(HttpServletRequest httpServletRequest){
+    public ServerResponse un_select_all(HttpServletRequest httpServletRequest) {
         User user = getCurrentUser(httpServletRequest);
 
-        return cartService.selectOrUnSelect(user.getId(),Constants.Cart.UN_CHECKED,null);
+        return cartService.selectOrUnSelect(user.getId(), Constants.Cart.UN_CHECKED, null);
     }
 
     /**
-     * 7.购物车选中某个商品
+     * 7. 购物车选中某个商品方法
+     * 此方法用于处理将购物车中某个特定商品设置为选中状态的HTTP请求。
+     * 先是通过调用父类的`getCurrentUser`方法从`httpServletRequest`获取当前登录用户信息，确保知晓是哪个用户的购物车中的商品要进行选中操作。
+     * 然后将用户的唯一标识符（`user.getId()`）、表示选中状态的常量（`Constants.Cart.CHECKED`）以及客户端传入的要选中商品的唯一标识符（`productId`）传递给`cartService`的`selectOrUnSelect`方法，
+     * `cartService`会依据传入的商品标识符在对应的购物车记录中找到该商品，并执行将其设置为选中状态的业务逻辑，比如更新数据库中该商品记录的选中标识字段，最后返回`ServerResponse`对象告知客户端选中该商品操作的执行结果。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，它承载了请求的相关信息，一方面可借助父类方法获取当前登录用户信息，另一方面从中获取客户端传入的要选中商品的`productId`参数，是整个购物车选中某个商品操作的请求基础，提供了必要的数据来源。
+     * @param productId          要在购物车中设置为选中状态的商品的唯一标识符，是整数类型参数，由客户端在请求时传入，用于明确具体是哪个商品需要被设置为选中状态，`cartService`会根据这个标识符准确找到购物车中对应的商品记录并进行相应的选中状态设置操作。
+     * @return 返回一个`ServerResponse`对象，包含了购物车选中某个商品操作的结果信息，如操作成功的状态码、提示选中操作成功的消息等内容，方便客户端根据返回结果判断操作是否成功，并进行相应的后续处理（比如更新界面上购物车商品的选中状态显示等）。
      */
     @RequestMapping("select.do")
-    public ServerResponse select(HttpServletRequest httpServletRequest,Integer productId){
+    public ServerResponse select(HttpServletRequest httpServletRequest, Integer productId) {
         User user = getCurrentUser(httpServletRequest);
 
-        return cartService.selectOrUnSelect(user.getId(),Constants.Cart.CHECKED,productId);
+        return cartService.selectOrUnSelect(user.getId(), Constants.Cart.CHECKED, productId);
     }
 
     /**
-     * 8.购物车取消选中某个商品
+     * 8. 购物车取消选中某个商品方法
+     * 用于处理将购物车中某个特定商品取消选中（设置为未选中状态）的HTTP请求。
+     * 首先调用父类的`getCurrentUser`方法从`httpServletRequest`中获取当前登录用户信息，明确操作对应的用户购物车。
+     * 接着将用户的唯一标识符（`user.getId()`）、表示未选中状态的常量（`Constants.Cart.UN_CHECKED`）以及客户端传入的要取消选中商品的唯一标识符（`productId`）传递给`cartService`的`selectOrUnSelect`方法，
+     * `cartService`会依据`productId`找到购物车中对应的商品记录，并执行将其设置为未选中状态的业务逻辑，例如更新数据库中该商品记录的选中标识字段，最后返回`ServerResponse`对象告知客户端取消选中该商品操作的执行结果。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，通过它能获取当前登录用户信息以及客户端传入的要取消选中商品的`productId`参数，是整个购物车取消选中某个商品操作的请求基础，为后续业务逻辑执行提供了关键的数据依据。
+     * @param productId          要在购物车中设置为未选中状态的商品的唯一标识符，整数类型参数，由客户端请求传入，用于准确指定需要取消选中的商品，`cartService`会根据这个标识符定位到对应的商品记录并进行相应的状态更新操作。
+     * @return 返回一个`ServerResponse`对象，包含了购物车取消选中某个商品操作的结果信息，如操作成功的状态码、提示取消选中操作成功的消息等内容，方便客户端根据返回结果判断操作是否成功，并进行相应的后续处理（比如更新界面上购物车商品的选中状态显示等）。
      */
     @RequestMapping("un_select.do")
-    public ServerResponse un_select(HttpServletRequest httpServletRequest,Integer productId){
+    public ServerResponse un_select(HttpServletRequest httpServletRequest, Integer productId) {
         User user = getCurrentUser(httpServletRequest);
 
-        return cartService.selectOrUnSelect(user.getId(),Constants.Cart.UN_CHECKED,productId);
+        return cartService.selectOrUnSelect(user.getId(), Constants.Cart.UN_CHECKED, productId);
     }
 
-
     /**
-     * 9.查询在购物车里的产品数量
+     * 9. 查询在购物车里的产品数量方法
+     * 用于处理查询购物车中商品总数量的HTTP请求。
+     * 先通过调用父类的`getCurrentUser`方法从`httpServletRequest`获取当前登录用户信息，因为需要明确是查询哪个用户购物车中的商品数量。
+     * 然后将获取到的用户的唯一标识符（`user.getId()`）传递给`cartService`的`get_cart_product_count`方法，
+     * `cartService`的`get_cart_product_count`方法会去查询相关数据源（如数据库中对应购物车表记录等），统计出该用户购物车中商品的总数量，最后返回包含商品数量信息的`ServerResponse<Integer>`对象给客户端，告知客户端购物车中商品的数量情况。
+     * 这里`ServerResponse<Integer>`中的泛型`<Integer>`表示返回的数据部分是一个整数类型，即购物车中商品的数量，同时`ServerResponse`对象还包含了操作的状态码、提示消息等信息，方便客户端根据返回结果判断操作是否成功以及获取具体的商品数量数值，用于展示给用户或者进行其他相关的业务逻辑处理。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，通过它可以借助父类方法获取当前登录用户信息，以此确定要查询哪个用户购物车中的商品数量，是整个查询购物车商品数量操作的请求基础，为后续的查询统计操作提供了必要的数据依据。
+     * @return 返回一个`ServerResponse<Integer>`对象，其中包含了操作的状态码、提示消息以及表示购物车中商品数量的整数类型数据，客户端可以根据这个返回对象判断操作是否成功，并获取购物车商品数量的具体数值进行展示或其他相关业务处理。
      */
     @RequestMapping("get_cart_product_count.do")
-    public ServerResponse<Integer> get_cart_product_count(HttpServletRequest httpServletRequest){
+    public ServerResponse<Integer> get_cart_product_count(HttpServletRequest httpServletRequest) {
         User user = getCurrentUser(httpServletRequest);
 
         return cartService.get_cart_product_count(user.getId());
     }
 
-
     /**
-     * 提供的feign接口，根据userId获取购物车列表
+     * 提供的feign接口，根据userId获取购物车列表方法
+     * 此方法用于处理通过Feign客户端调用的获取购物车列表的HTTP请求。
+     * 首先，初始化一个`User`对象为`null`，用于后续存储从缓存中反序列化得到的用户信息。
+     * 然后，通过`httpServletRequest`获取请求头的名称枚举（`headerNames`），如果这个枚举不为`null`，说明存在请求头信息，接着就遍历这些请求头名称。
+     * 当遍历到名称为（忽略大小写）"snailmall_login_token"的请求头时，获取其对应的值（`value`），如果这个值为空字符串（即`StringUtils.isBlank(value)`为`true`），说明用户未登录或者登录信息不完整，此时直接返回一个表示需要登录的`ServerResponse`对象给客户端，提示用户未登陆，无法获取当前用户信息。
+     * 若获取到的请求头值不为空，则尝试从缓存中获取对应的用户信息，通过`commonCacheUtil`的`getCacheValue`方法，以请求头的值作为缓存键去获取对应的用户信息的JSON字符串（`userJsonStr`），如果获取到的JSON字符串为`null`，同样意味着可能用户登录状态异常或者缓存中不存在相应信息，也返回表示需要登录的`ServerResponse`对象。
+     * 若成功获取到用户信息的JSON字符串，就使用`JsonUtil`工具类的`Str2Obj`方法将其反序列化为`User`对象，赋值给之前初始化的`user`变量。
+     * 最后，如果`user`对象不为`null`，说明获取用户信息成功，就将用户的唯一标识符（`user.getId()`）传递给`cartService`的`list`方法获取购物车列表信息，并返回包含购物车列表数据的`ServerResponse`对象给客户端，告知客户端操作结果；若`user`对象为`null`，还是返回表示需要登录的`ServerResponse`对象告知客户端用户未登录情况。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，通过它获取请求头信息，从中查找登录相关的请求头来判断用户登录状态以及获取用户信息，是整个通过Feign接口获取购物车列表操作的请求基础，提供了关键的数据来源。
+     * @return 返回一个`ServerResponse`对象，包含了操作的状态码、提示消息以及购物车列表数据等信息，若操作成功则客户端可以根据这个对象展示购物车中的商品详情等信息给用户，若操作失败（如用户未登录）则会返回相应的错误提示信息告知客户端需要先登录。
      */
     @RequestMapping("getCartList.do")
-    public ServerResponse getCartList(HttpServletRequest httpServletRequest){
+    public ServerResponse getCartList(HttpServletRequest httpServletRequest) {
         User user = null;
         Enumeration<String> headerNames = httpServletRequest.getHeaderNames();
-        if (headerNames != null) {
+        if (headerNames!= null) {
             while (headerNames.hasMoreElements()) {
                 String name = headerNames.nextElement();
-                if(name.equalsIgnoreCase("snailmall_login_token")){
+                if (name.equalsIgnoreCase("snailmall_login_token")) {
                     String value = httpServletRequest.getHeader(name);
-                    if(StringUtils.isBlank(value)){
-                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登陆，无法获取当前用户信息");
+                    if (StringUtils.isBlank(value)) {
+                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登陆，无法获取当前用户信息");
                     }
                     String userJsonStr = commonCacheUtil.getCacheValue(value);
-                    if(userJsonStr == null){
-                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登陆，无法获取当前用户信息");
+                    if (userJsonStr == null) {
+                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登陆，无法获取当前用户信息");
                     }
-                    user = JsonUtil.Str2Obj(userJsonStr,User.class);
+                    user = JsonUtil.Str2Obj(userJsonStr, User.class);
                 }
             }
         }
-        if (user == null){
-            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登陆，无法获取当前用户信息");
+        if (user == null) {
+            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登陆，无法获取当前用户信息");
         }
         return cartService.list(user.getId());
     }
 
     /**
-     * 提供的feign接口，清空购物车
+     * 提供的feign接口，清空购物车方法
+     * 此方法用于处理通过Feign客户端调用的清空购物车的HTTP请求。
+     * 同样先初始化一个`User`对象为`null`，用于后续存储获取到的用户信息。
+     * 接着获取请求头的名称枚举（`headerNames`），若不为`null`则遍历这些请求头名称，查找名为（忽略大小写）"snailmall_login_token"的请求头，获取其对应的值（`value`）。
+     * 如果这个值为空字符串，说明用户未登录或登录信息有问题，直接返回表示需要登录的`ServerResponse`对象给客户端，提示用户未登陆，无法获取当前用户信息。
+     * 若获取到的值不为空，就通过`commonCacheUtil`从缓存中获取对应的用户信息的JSON字符串（`userJsonStr`），若获取的JSON字符串为`null`，也返回表示需要登录的`ServerResponse`对象，因为这意味着用户登录状态异常或者缓存中无对应信息。
+     * 当成功获取到用户信息的JSON字符串后，使用`JsonUtil`的`Str2Obj`方法将其反序列化为`User`对象，赋值给`user`变量。
+     * 最后，如果`user`对象不为`null`，表明获取用户信息成功，就将用户的唯一标识符（`user.getId()`）传递给`cartService`的`removeCart`方法执行清空购物车的业务逻辑，然后返回`ServerResponse`对象告知客户端清空购物车操作的执行结果；若`user`对象为`null`，则返回表示需要登录的`ServerResponse`对象告知客户端用户未登录情况。
+     *
+     * @param httpServletRequest 代表客户端发送的HTTP请求对象，通过它获取请求头信息来判断用户登录状态以及获取用户信息，是整个通过Feign接口清空购物车操作的请求基础，提供了关键的数据来源。
+     * @return 返回一个`ServerResponse`对象，包含了操作的状态码、提示消息以及清空购物车操作的结果信息等，若操作成功客户端可以根据返回结果知晓购物车已清空等情况，若操作失败（如用户未登录）则会收到相应的错误提示信息告知需要先登录。
      */
     @RequestMapping("removeCart.do")
-    public ServerResponse removeCart(HttpServletRequest httpServletRequest){
+    public ServerResponse removeCart(HttpServletRequest httpServletRequest) {
         User user = null;
         Enumeration<String> headerNames = httpServletRequest.getHeaderNames();
-        if (headerNames != null) {
+        if (headerNames!= null) {
             while (headerNames.hasMoreElements()) {
                 String name = headerNames.nextElement();
-                if(name.equalsIgnoreCase("snailmall_login_token")){
+                if (name.equalsIgnoreCase("snailmall_login_token")) {
                     String value = httpServletRequest.getHeader(name);
-                    if(StringUtils.isBlank(value)){
-                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登陆，无法获取当前用户信息");
+                    if (StringUtils.isBlank(value)) {
+                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登陆，无法获取当前用户信息");
                     }
                     String userJsonStr = commonCacheUtil.getCacheValue(value);
-                    if(userJsonStr == null){
-                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登陆，无法获取当前用户信息");
+                    if (userJsonStr == null) {
+                        return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登陆，无法获取当前用户信息");
                     }
-                    user = JsonUtil.Str2Obj(userJsonStr,User.class);
+                    user = JsonUtil.Str2Obj(userJsonStr, User.class);
                 }
             }
         }
-        if (user == null){
-            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(),"用户未登陆，无法获取当前用户信息");
+        if (user == null) {
+            return ServerResponse.createByErrorCodeMessage(ResponseEnum.NEED_LOGIN.getCode(), "用户未登陆，无法获取当前用户信息");
         }
         return cartService.removeCart(user.getId());
     }
-
-
-
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/dao/CartMapper.java

@@ -3,34 +3,64 @@ package com.njupt.swg.dao;
 import com.njupt.swg.entity.Cart;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
-
 import java.util.List;
 
+// @Mapper注解用于标识这个接口是MyBatis的Mapper接口，MyBatis框架会自动扫描并生成该接口的代理实现类，
+// 从而可以与数据库进行交互，执行对应的SQL操作，这个接口主要定义了针对购物车（Cart）相关数据的数据库操作方法。
 @Mapper
 public interface CartMapper {
+
+    // 根据购物车记录的主键（通常是一个唯一标识该记录的整数型ID）删除对应的购物车记录，返回值为受影响的行数，
+    // 如果成功删除一条记录，返回值通常为1，如果没有匹配的记录可删除，则返回0。
     int deleteByPrimaryKey(Integer id);
 
+    // 向数据库中插入一条完整的购物车记录（Cart对象），这个方法会将Cart对象中的所有属性对应的字段值插入到数据库表中，
+    // 返回值同样为受影响的行数，若插入成功一般返回1，表示成功插入了一条记录。
     int insert(Cart record);
 
+    // 插入购物车记录，但允许只插入Cart对象中部分非空的属性对应的字段值到数据库表中，
+    // 相比insert方法更加灵活，当Cart对象某些属性为null时，只会插入那些非null属性对应的字段，返回值为受影响的行数。
     int insertSelective(Cart record);
 
+    // 根据购物车记录的主键（id）从数据库中查询并返回对应的购物车记录（以Cart对象形式返回），
+    // 如果找不到对应的记录，则返回null。
     Cart selectByPrimaryKey(Integer id);
 
+    // 根据购物车记录的主键（id）来有选择性地更新购物车记录，只会更新Cart对象中那些非null属性对应的数据库字段值，
+    // 返回值为受影响的行数，用于指示实际更新了几条记录，若没有任何字段值被更新（比如传入的Cart对象属性都是null或者和数据库中原有值相同），则返回0。
     int updateByPrimaryKeySelective(Cart record);
 
+    // 根据购物车记录的主键（id）更新购物车记录，会将Cart对象中的所有属性对应的字段值更新到数据库表中对应的记录里，
+    // 不管属性值是否为null，返回值为受影响的行数，用来表示实际更新了几条记录。
     int updateByPrimaryKey(Cart record);
 
+    // 根据用户的ID（userId）和商品的ID（productId）联合查询购物车中对应的记录，
+    // 通过@Param注解明确指定了参数的名称，方便在对应的SQL语句中使用这些参数进行准确的条件查询，
+    // 返回值是匹配条件的购物车记录（以Cart对象形式返回），若找不到符合条件的记录则返回null。
     Cart selectByUserIdProductId(@Param("userId") Integer userId, @Param("productId") Integer productId);
 
+    // 根据用户的ID（userId）查询该用户购物车中的所有记录，返回一个包含多个Cart对象的List集合，
+    // 如果该用户没有购物车记录，则返回一个空的List集合。
     List<Cart> selectCartByUserId(Integer userId);
 
+    // 根据用户的ID（userId）查询该用户购物车中已选中商品的状态数量（具体含义可能根据业务逻辑而定，比如返回已选中商品的记录条数等），
+    // 返回一个整数类型的结果，例如返回已选中商品的数量或者代表选中状态的某种统计数值等。
     int selectCartCheckedStatusByUserId(Integer userId);
 
+    // 根据用户的ID（userId）以及要删除商品的ID列表（productIdList）从购物车中删除对应的商品记录，
+    // 通过@Param注解分别指定了参数名称，便于在对应的SQL语句中准确使用这些参数进行批量删除操作，
+    // 返回值为受影响的行数，代表实际删除了几条记录。
     int deleteByProductIds(@Param("userId") Integer userId, @Param("productIdList") List<String> productIdList);
 
+    // 根据用户的ID（userId）、商品的选中状态（checked，可能是用整数表示选中或未选中，比如1表示选中，0表示未选中等，具体由业务定义）以及商品的ID（productId），
+    // 来设置商品在购物车中的选中或未选中状态，此方法通常用于更新购物车中某个商品的选中情况，无返回值（void类型），
+    // 对应的SQL操作会根据传入的参数对数据库表中的相应字段进行更新操作。
     void selectOrUnSelectProduct(@Param("userId") Integer userId, @Param("checked") int checked, @Param("productId") Integer productId);
 
+    // 根据用户的ID（userId）查询该用户购物车中商品的总数量，返回一个整数类型的结果，用于统计该用户购物车中一共有多少件商品。
     int selectCartProductCount(Integer userId);
 
+    // 根据用户的ID（userId）查询该用户购物车中所有已选中商品的记录，返回一个包含多个已选中Cart对象的List集合，
+    // 方便后续对已选中商品进行相关业务处理（比如计算总价等操作），若没有已选中商品，则返回一个空的List集合。
     List<Cart> selectCheckedCartByUserId(Integer userId);
 }

snailmall-cart-service/src/main/java/com/njupt/swg/entity/Cart.java

@@ -4,26 +4,44 @@ import com.fasterxml.jackson.annotation.JsonFormat;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-
 import java.util.Date;
 
+// 使用Lombok的 @Data注解，会自动为这个类生成常用的方法，比如Getter、Setter方法，
+// 以及toString、hashCode、equals等方法，简化了代码编写，让实体类的属性访问和操作更加便捷。
 @Data
+
+// 使用 @AllArgsConstructor注解，Lombok会为这个类自动生成一个包含所有参数的构造函数，
+// 方便在创建对象时一次性传入所有属性的值进行初始化。
 @AllArgsConstructor
+
+// 使用 @NoArgsConstructor注解，Lombok会为这个类自动生成一个无参构造函数，
+// 这在很多框架（如一些序列化、反序列化的场景或者通过反射创建对象的情况）中是必要的，确保类有默认的构造方式。
 @NoArgsConstructor
 public class Cart {
+
+    // 购物车记录的唯一标识符，通常在数据库中作为主键使用，用于区分不同的购物车记录，类型为整数类型。
     private Integer id;
 
+    // 关联的用户的唯一标识符，用于表明这个购物车记录属于哪个用户，通过这个字段可以将购物车与具体的用户关联起来，方便查询某个用户的购物车相关信息，类型为整数类型。
     private Integer userId;
 
+    // 购物车中商品的唯一标识符，用于确定购物车中存放的是哪个具体商品，方便在业务逻辑中根据商品ID查找商品详情、库存等信息，类型为整数类型。
     private Integer productId;
 
+    // 商品在购物车中的数量，代表用户添加该商品到购物车的数量情况，例如用户添加了3件某商品到购物车，这个字段的值就会是3，类型为整数类型。
     private Integer quantity;
 
+    // 用于表示商品在购物车中的选中状态，具体取值含义可能由业务逻辑定义，比如可以用1表示选中，0表示未选中等，方便在购物车相关操作（如全选、取消全选、单独选中某个商品等操作）中标记商品的状态，类型为整数类型。
     private Integer checked;
 
+    // 使用 @JsonFormat注解来指定日期类型字段的序列化格式，这里将createTime字段在序列化为JSON字符串时，
+    // 按照指定的格式（"yyyy-MM-dd HH:mm:ss.SSS"，即年-月-日 时:分:秒.毫秒）进行格式化，方便在前后端数据交互或者数据存储时，日期格式能够统一且符合预期的展示需求。
     @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss.SSS")
     private Date createTime;
 
+    // 与createTime类似，也是使用 @JsonFormat注解来指定日期类型字段的序列化格式，
+    // updateTime字段在序列化为JSON字符串时，按照"yyyy-MM-dd HH:mm:ss.SSS"格式进行格式化，
+    // 通常用于记录购物车记录最后一次更新的时间，方便跟踪数据的变化情况以及进行一些基于时间的业务逻辑处理（如判断数据是否过期等情况）。
     @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss.SSS")
     private Date updateTime;
 }

snailmall-cart-service/src/main/java/com/njupt/swg/entity/Product.java

@@ -3,35 +3,70 @@ package com.njupt.swg.entity;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-
 import java.math.BigDecimal;
 import java.util.Date;
 
+// 使用Lombok的 @Data注解，它会自动帮我们生成这个类的一系列常用方法，包括所有属性的Getter和Setter方法，
+// 以及重写的toString方法、hashCode方法和equals方法等。这样可以减少大量样板代码的编写，让代码看起来更简洁，
+// 同时也方便在其他地方对类的属性进行访问和操作。
 @Data
+
+// @AllArgsConstructor注解指示Lombok为这个类生成一个包含所有参数的构造函数。
+// 这意味着我们可以通过传入所有属性的值来便捷地创建一个Product类的实例，例如：
+// Product product = new Product(1, 2, "商品名称", "商品副标题", "主图路径", "子图路径列表", "商品详情", new BigDecimal("9.99"), 100, 1, new Date(), new Date());
 @AllArgsConstructor
+
+// @NoArgsConstructor注解让Lombok为这个类生成一个无参构造函数。
+// 在很多情况下，比如通过反射创建对象、一些序列化和反序列化的场景中，无参构造函数是必不可少的，
+// 确保类有默认的创建实例的方式。
 @NoArgsConstructor
 public class Product {
+
+    // 商品的唯一标识符，在整个系统中用于区分不同的商品，通常会作为数据库表中的主键字段，类型为整数类型，
+    // 其他业务逻辑或者数据库操作往往会基于这个ID来对特定的商品进行查询、更新、删除等操作。
     private Integer id;
 
+    // 商品所属的分类的标识符，用于将商品归类到不同的类别下，方便进行分类查询、展示等操作，比如按照不同的品类展示商品列表，类型为整数类型，
+    // 通过这个字段可以关联到对应的商品分类信息，了解商品所属的大类别或者小类别等情况。
     private Integer categoryId;
 
+    // 商品的名称，用于展示给用户，让用户直观地知道商品是什么，是一个字符串类型的属性，例如"华为P50手机"等，
+    // 在商品列表展示、详情页展示等场景中会用到这个字段来呈现商品的基本信息。
     private String name;
 
+    // 商品的副标题，通常可以用来补充说明商品的一些特点、卖点或者优惠信息等内容，也是字符串类型，
+    // 比如"华为P50手机，超感知徕卡四摄，限时优惠"，可以进一步吸引用户关注该商品。
     private String subtitle;
 
+    // 商品的主图片的路径或者标识，一般用于在前端页面展示商品的主要图片，字符串类型，
+    // 这个路径可以是相对路径或者绝对路径，指向存储商品主图的位置（可能是服务器本地存储、云存储等），方便前端根据这个路径来加载并展示图片。
     private String mainImage;
 
+    // 商品的子图片的路径或者标识列表，以字符串形式存储，通常用特定的分隔符（如逗号等）将多个子图片的路径分隔开，
+    // 用于展示商品的多角度、多细节图片，让用户更全面地了解商品外观、功能等方面的情况，方便前端加载并展示商品的多张图片。
     private String subImages;
 
+    // 商品的详细描述信息，包含了商品的各种详细参数、功能介绍、使用说明等内容，是一个比较长的字符串类型，
+    // 在商品详情页中会完整地展示这些信息，帮助用户深入了解商品的具体情况，以便做出购买决策。
     private String detail;
 
+    // 商品的价格，使用BigDecimal类型来精确表示金额，避免使用浮点数类型（如double、float）带来的精度丢失问题，
+    // 例如可以表示为new BigDecimal("9.99")，准确地存储商品的售价信息，在购物车计算总价、下单结算等涉及金额计算的业务场景中会频繁使用这个字段。
     private BigDecimal price;
 
+    // 商品的库存数量，用于记录当前商品还有多少件可供销售，整数类型，
+    // 在添加商品到购物车、下单扣减库存等业务操作中，会根据这个字段的值来判断操作是否可行，比如库存不足时不能继续添加商品到购物车等情况。
     private Integer stock;
 
+    // 商品的状态标识，具体含义由业务逻辑定义，可能用不同的整数值来表示不同的状态，比如1表示上架、0表示下架等，
+    // 用于控制商品是否在前端展示、是否可购买等情况，方便后台管理人员对商品的售卖状态进行管理和操作。
     private Integer status;
 
+    // 商品的创建时间，记录商品信息首次被录入系统的时间点，使用Date类型来准确表示时间，
+    // 在数据统计、历史记录查询等业务场景中可能会用到这个字段，例如查看某个时间段内新上架的商品等情况。
     private Date createTime;
 
+    // 商品的更新时间，每当商品的相关信息（如名称、价格、库存等属性发生变化时）被修改后，会更新这个时间字段，
+    // 同样是Date类型，可用于跟踪商品信息的变更情况，比如查看商品最近一次的价格调整时间等业务需求。
     private Date updateTime;
 }

snailmall-cart-service/src/main/java/com/njupt/swg/entity/User.java

@@ -4,7 +4,6 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.ToString;
-
 import java.io.Serializable;
 import java.util.Date;
 
@@ -12,32 +11,52 @@ import java.util.Date;
  * @Author swg.
  * @Date 2018/12/31 21:01
  * @CONTACT 317758022@qq.com
- * @DESC 用户实体类
+ * @DESC 用户实体类，用于在整个项目中表示用户相关的信息，是对用户这一概念在代码层面的抽象，
+ * 它在不同的业务层（如持久层、服务层、控制层等）之间传递用户数据，方便进行与用户相关的各种业务操作，例如用户注册、登录、信息查询与修改等。
  */
 @Data
+// 使用Lombok的 @Data注解，会自动为这个类生成常用的方法，包括所有属性的Getter和Setter方法，以及重写的toString、hashCode和equals方法等，减少了手动编写这些样板代码的工作量，使代码更加简洁，便于对类中属性进行操作和使用。
+
 @NoArgsConstructor
+// 通过 @NoArgsConstructor注解，Lombok会为这个类生成一个无参构造函数。在很多场景下，比如通过反射创建对象、进行序列化和反序列化操作时，无参构造函数是必要的，确保类有默认的创建实例的方式。
+
 @AllArgsConstructor
+// @AllArgsConstructor注解则指示Lombok生成一个包含所有参数的构造函数，方便在创建对象时一次性传入所有属性的值进行初始化，例如：
+// User user = new User(1, "testUser", "123456", "test@example.com", "13812345678", "你的爱好是什么？", "看书", 1, new Date(), new Date());
+
 @ToString
+// @ToString注解会让Lombok自动重写toString方法，使得在打印对象或者将对象转换为字符串表示形式时，能够直观地展示对象的各个属性值，方便调试和查看对象的状态。
+
+// 实现Serializable接口，表示这个类的对象可以被序列化和反序列化，这在很多场景下是很重要的，比如将用户对象存储到文件、在网络中传输用户对象等情况，确保对象能够以字节流的形式进行持久化和传递，并且在反序列化后能正确还原对象状态。
 public class User implements Serializable {
+
+    // 用户的唯一标识符，通常作为数据库表中的主键字段来区分不同的用户，在整个系统中，其他与用户相关的业务操作（如查询、更新、删除用户信息等）大多会基于这个ID来进行，类型为整数类型。
     private Integer id;
 
+    // 用户登录使用的用户名，是一个字符串类型的属性，要求在系统中具有唯一性（一般会有相应的业务逻辑和数据库约束来保证），用于用户在登录界面输入，以标识自己的身份，例如"admin"、"user123"等。
     private String username;
 
+    // 用户登录的密码，同样为字符串类型，存储用户设置的密码信息，出于安全考虑，在实际应用中通常会对密码进行加密存储，而不是以明文形式保存，例如使用MD5、SHA等加密算法对密码进行处理后再存储到数据库中。
     private String password;
 
+    // 用户的电子邮箱地址，字符串类型，可用于用户注册验证、找回密码等功能，例如"test@example.com"，通过向该邮箱发送验证链接或者重置密码的相关信息来完成相应的操作，同时也方便系统与用户进行一些重要通知的邮件沟通。
     private String email;
 
+    // 用户的手机号码，字符串类型，常用于短信验证码验证、手机号登录等功能场景，例如"13812345678"，在如今的很多应用中，手机号已经成为一种常用且重要的用户身份验证和联系的方式。
     private String phone;
 
+    // 密保问题，字符串类型，是用户在设置账号安全相关信息时所填写的用于找回密码等情况的验证问题，例如"你的爱好是什么？"，当用户忘记密码时，可以通过回答正确的密保问题来重置密码，增加账号的安全性。
     private String question;
 
+    // 密保问题的答案，与question属性相对应，用户填写的用于验证密保问题的正确答案，也是字符串类型，例如"看书"，只有回答正确这个答案，才能进行后续的密码重置等安全相关操作。
     private String answer;
 
-    //角色0-管理员,1-普通用户
+    // 用户的角色标识，整数类型，通过不同的整数值来区分用户在系统中的不同角色，在这里定义了0表示管理员角色，1表示普通用户角色，不同角色在系统中通常具有不同的权限，例如管理员可能具有管理所有用户、系统配置等高级权限，而普通用户只能进行与自身相关的常规操作（如查看购物车、下单等）。
     private Integer role;
 
+    // 用户账号的创建时间，使用Date类型准确记录用户首次在系统中注册账号的时间点，在数据统计（如统计每日新增用户数量等）、历史记录查询（查看某个时间段内注册的用户等）等业务场景中会用到这个字段。
     private Date createTime;
 
+    // 用户账号信息的最后更新时间，每当用户修改了自己的用户名、密码、邮箱等相关信息后，会更新这个时间字段，同样为Date类型，方便跟踪用户信息的变更情况，例如查看用户最近一次修改密码的时间等。
     private Date updateTime;
-
 }

snailmall-cart-service/src/main/java/com/njupt/swg/message/MessageReceiver.java

@@ -9,31 +9,51 @@ import org.springframework.amqp.rabbit.annotation.QueueBinding;
 import org.springframework.amqp.rabbit.annotation.RabbitListener;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
-
 import java.util.List;
 
 /**
  * @Author swg.
  * @Date 2019/1/7 13:23
  * @CONTACT 317758022@qq.com
- * @DESC
+ * @DESC 这个类（MessageReceiver）是一个消息接收者组件，用于处理通过消息队列（RabbitMQ）接收到的消息，
+ * 在整个项目架构中，它承担着从消息队列获取消息并基于消息内容执行相应业务逻辑的职责，例如这里接收到消息后会调用购物车服务来清除对应用户的购物车。
  */
 @Component
+// 使用 @Component注解将这个类标记为Spring的一个组件，这样Spring容器会自动扫描并管理这个类的实例，使其可以参与依赖注入等Spring相关的功能。
+
 @Slf4j
+// 通过 @Slf4j注解，使用Lombok的功能自动为这个类添加一个名为log的日志记录器，方便在类中记录各种运行时的日志信息，有助于调试、监控和追踪代码的执行情况。
 public class MessageReceiver {
+
+    // 通过Spring的依赖注入机制，自动注入ICartService接口的实现类对象，用于调用购物车相关的业务逻辑方法，
+    // 在这里具体用于执行清除购物车的操作，依赖注入使得代码的耦合性更低，方便替换不同的购物车服务实现类，并且符合Spring的面向接口编程的理念。
     @Autowired
     private ICartService cartService;
 
+    /**
+     * 这个方法是一个消息监听器方法，通过 @RabbitListener注解配置了它与消息队列的绑定关系，用于监听特定队列（"cart-queue"）中的消息，
+     * 当有消息到达该队列时，这个方法就会被触发执行，它会接收消息队列传递过来的消息，并基于消息内容进行相应的业务逻辑处理，在这里主要是清除对应用户的购物车操作。
+     *
+     * @param message 表示从消息队列中接收到的消息内容，在这里消息内容预期是一个可以转换为整数类型的字符串（代表用户的ID），
+     *                它的具体格式和含义由发送消息的一端决定，本方法接收到消息后会对其进行解析并转化为相应的业务操作参数（userId），进而执行后续的清除购物车操作。
+     */
     @RabbitListener(bindings = @QueueBinding(
             value = @Queue("cart-queue"),
             exchange = @Exchange("cart-exchange")
     ))
-    public void proess(String message){
-        log.info("接收到的消息为:{}",message);
+    public void proess(String message) {
+        // 使用日志记录器记录接收到的消息内容，方便在运行时查看接收到的消息具体是什么，有助于调试和排查问题，例如查看消息是否符合预期格式等情况。
+        log.info("接收到的消息为:{}", message);
+
+        // 将接收到的消息（预期是一个字符串形式的整数）转换为实际的整数类型（userId），这里假设发送过来的消息内容就是有效的用户ID字符串表示形式，
+        // 如果消息格式不符合要求，可能会抛出NumberFormatException异常，在实际应用中可能需要更完善的错误处理机制来应对这种情况。
         Integer userId = Integer.parseInt(message);
-        log.info("【MQ解析数据,前者为userId,后者为productId：{}】",userId);
-        //清除购物车
+
+        // 再次使用日志记录器记录解析后的用户ID信息，便于在日志中清晰地看到处理的用户相关数据，方便后续查看消息处理的具体情况以及追踪问题，比如查看是否处理了正确的用户的购物车清除操作等。
+        log.info("【MQ解析数据,前者为userId,后者为productId：{}】", userId);
+
+        // 调用ICartService的removeCart方法，传入解析得到的用户ID（userId），执行清除对应用户购物车的业务操作，
+        // 这个操作可能涉及到数据库中购物车相关记录的删除等具体的持久层操作，具体由ICartService的实现类中对应的方法逻辑来决定。
         cartService.removeCart(userId);
     }
-
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/service/CartServiceImpl.java

@@ -31,211 +31,452 @@ import java.util.List;
  */
 @Service
 @Slf4j
-public class CartServiceImpl implements ICartService{
+
+
+// CartServiceImpl类实现了ICartService接口，意味着它需要实现该接口中定义的所有方法，
+// 这个类主要负责处理购物车相关的具体业务逻辑，例如添加商品到购物车、更新购物车中商品数量等操作，
+// 通过调用其他组件（如CartMapper、ProductClient、CommonCacheUtil等）来协同完成业务功能，并将结果以ServerResponse的形式返回给上层调用者（如控制层）。
+public class CartServiceImpl implements ICartService {
+
+    // 通过Spring的依赖注入机制，自动注入CartMapper接口的实现类对象。
+    // CartMapper用于与数据库进行交互，执行如查询、插入、更新、删除购物车相关记录等数据库操作，
+    // 在这里的各个购物车业务方法中会频繁调用它来完成持久化层面的工作，实现业务逻辑与数据访问的分离。
     @Autowired
     private CartMapper cartMapper;
+
+    // 同样通过依赖注入注入ProductClient对象。
+    // ProductClient通常是用于和外部的商品服务进行通信的客户端，比如在购物车业务中，需要获取商品的详细信息（是否下架、库存情况等）时，
+    // 就会通过这个客户端去调用商品服务提供的接口来获取相应数据，实现不同微服务之间的协作。
     @Autowired
     private ProductClient productClient;
+
+    // 注入CommonCacheUtil对象，用于与缓存系统进行交互操作。
+    // 在处理购物车业务时，可能会频繁用到商品相关信息，通过缓存可以减少重复查询数据库的次数，提高系统性能。
+    // 例如先从缓存中查找商品信息，如果缓存中不存在再去查询数据库，并将查询到的数据存入缓存供后续使用。
     @Autowired
     private CommonCacheUtil commonCacheUtil;
 
+    /**
+     * 实现ICartService接口中定义的添加商品到购物车的方法。
+     *
+     * @param userId 用户的唯一标识符，它是确定购物车归属的关键，若该值为null，表示用户未登录，不符合添加商品到购物车的前置条件，
+     *               此时会抛出SnailmallException异常，由上层（如控制层）进行捕获并处理，告知客户端用户未登录的情况。
+     * @param productId 要添加到购物车的商品的唯一标识符，若为null，说明传入的参数不完整，无法明确要添加的具体商品，
+     *                  会返回一个表示参数不正确的ServerResponse对象给客户端，提示用户修正参数。
+     * @param count 要添加到购物车的商品数量，同样不能为null，若为null则也返回参数不正确的提示响应，代表了此次操作中对应商品添加的具体数量。
+     * @return 返回一个ServerResponse对象，该对象封装了添加商品到购物车操作的结果信息，
+     *         如果操作成功，其内部会包含代表成功的数据（在这里是构建好的CartVo对象，包含了购物车相关详细信息，例如商品列表、总价等内容），
+     *         若操作失败，则包含相应的错误提示消息等内容，方便调用者（比如控制层）根据返回结果判断操作是否成功，并将相应信息返回给前端展示给用户或者进行其他后续处理。
+     */
     @Override
     public ServerResponse add(Integer userId, Integer productId, Integer count) {
-        //1.校验参数
-        if(userId == null){
+        // 1. 校验参数
+        // 首先检查用户ID是否为null，如果为null，意味着用户没有登录，这不符合添加商品到购物车的业务要求，所以抛出SnailmallException异常，
+        // 异常信息为"用户未登陆"，后续在合适的地方（比如控制层）可以捕获这个异常并返回相应提示给客户端，告知用户需要先登录才能进行添加操作。
+        if (userId == null) {
             throw new SnailmallException("用户未登陆");
         }
-        if(productId == null || count == null){
+        // 接着检查商品ID和商品数量是否为null，如果这两个参数中有任何一个为null，说明传入的参数不符合要求，无法准确执行添加商品的操作，
+        // 此时返回一个通过ServerResponse.createByErrorMessage方法创建的表示参数不正确的响应对象给客户端，提示用户检查并修正传入的参数。
+        if (productId == null || count == null) {
             return ServerResponse.createByErrorMessage("参数不正确");
         }
-        //2.校验商品
-        String productStr = commonCacheUtil.getCacheValue(Constants.PRODUCT_TOKEN_PREFIX+productId);
+
+        // 2. 校验商品
+        // 尝试从缓存中获取商品信息，缓存的键是通过Constants.PRODUCT_TOKEN_PREFIX加上商品ID拼接而成的，
+        // 这样可以根据不同的商品ID来准确地在缓存中查找对应的商品缓存数据，提高获取商品信息的效率，避免频繁访问数据库。
+        String productStr = commonCacheUtil.getCacheValue(Constants.PRODUCT_TOKEN_PREFIX + productId);
         Product product = null;
-        if(productStr == null){
+        // 如果从缓存中获取到的商品信息字符串为null，说明缓存中不存在该商品的相关信息，此时需要通过ProductClient去远程调用商品服务来查询商品详情。
+        if (productStr == null) {
+            // 调用ProductClient的queryProduct方法，传入商品ID作为参数，向商品服务发起查询请求，获取包含商品信息的ServerResponse对象。
             ServerResponse response = productClient.queryProduct(productId);
+            // 从ServerResponse对象中获取其包含的商品数据部分（可能是一个Object类型的对象，具体内容由商品服务返回的数据结构决定）。
             Object object = response.getData();
+            // 使用JsonUtil工具类的obj2String方法将获取到的商品数据对象转换为字符串形式，方便后续进行反序列化操作。
             String objStr = JsonUtil.obj2String(object);
-            product = (Product) JsonUtil.Str2Obj(objStr,Product.class);
-        }else {
-            product = (Product) JsonUtil.Str2Obj(productStr,Product.class);
+            // 再通过JsonUtil的Str2Obj方法将字符串形式的商品信息反序列化为Product对象，以便后续在业务逻辑中使用商品的各个属性进行相关判断和操作。
+            product = (Product) JsonUtil.Str2Obj(objStr, Product.class);
+        } else {
+            // 如果缓存中存在商品信息字符串，则直接使用JsonUtil的Str2Obj方法将其反序列化为Product对象，避免了再次远程查询商品服务的开销。
+            product = (Product) JsonUtil.Str2Obj(productStr, Product.class);
         }
 
-        if(product == null){
+        // 如果经过上述步骤获取到的商品对象为null，说明商品不存在，可能是商品ID有误或者商品已经被彻底删除等原因，
+        // 此时返回一个通过ServerResponse.createByErrorMessage方法创建的表示商品不存在的响应对象给客户端，告知用户无法添加不存在的商品到购物车。
+        if (product == null) {
             return ServerResponse.createByErrorMessage("商品不存在");
         }
-        if(!product.getStatus().equals(Constants.Product.PRODUCT_ON)){
+        // 检查商品的状态是否为Constants.Product.PRODUCT_ON（这个常量应该是在业务中定义好的，表示商品处于正常可售卖状态的标识），
+        // 如果商品状态不等于这个正常可售卖状态标识，说明商品可能已经下架或者被删除了，不应该再添加到购物车中，
+        // 所以返回一个表示商品下架或者删除的错误提示响应对象给客户端。
+        if (!product.getStatus().equals(Constants.Product.PRODUCT_ON)) {
             return ServerResponse.createByErrorMessage("商品下架或者删除");
         }
-        //3.根据商品或者购物车，购物车存在则增加商品数量即可，不存在则创建新的购物车，一个用户对应一个购物车
-        Cart cart = cartMapper.selectByUserIdProductId(userId,productId);
-        if (cart == null){
+
+        // 3. 根据商品或者购物车，购物车存在则增加商品数量即可，不存在则创建新的购物车，一个用户对应一个购物车
+        // 通过CartMapper的selectByUserIdProductId方法，根据传入的用户ID和商品ID去数据库中查询购物车中是否已经存在该商品的记录，
+        // 如果不存在（即查询返回的Cart对象为null），则表示该用户的购物车中还没有添加过这个商品，需要创建一个新的购物车记录。
+        Cart cart = cartMapper.selectByUserIdProductId(userId, productId);
+        if (cart == null) {
+            // 创建一个新的Cart对象，用于表示要插入到数据库中的购物车记录信息。
             Cart cartItem = new Cart();
+            // 设置新购物车记录的用户ID，关联到对应的用户，表示这个购物车是属于哪个用户的。
             cartItem.setUserId(userId);
+            // 设置商品ID，明确购物车中存放的是哪个商品。
             cartItem.setProductId(productId);
+            // 设置商品数量，即此次要添加到购物车的商品数量。
             cartItem.setQuantity(count);
+            // 设置商品的选中状态，这里设置为Constants.Cart.CHECKED（应该是在业务中定义好的表示选中的常量），表示默认添加到购物车后商品是选中状态，具体选中含义可根据业务逻辑确定，比如是否参与总价计算等。
             cartItem.setChecked(Constants.Cart.CHECKED);
 
+            // 通过CartMapper的insert方法将新创建的购物车记录插入到数据库中，该方法会返回受影响的行数，正常插入成功应该返回1，
+            // 如果返回值为0，表示插入操作失败，可能是数据库出现问题或者其他原因导致插入不成功，此时返回一个表示添加购物车失败的错误提示响应对象给客户端。
             int resultCount = cartMapper.insert(cartItem);
-            if(resultCount == 0){
+            if (resultCount == 0) {
                 return ServerResponse.createByErrorMessage("添加购物车失败");
             }
-        }else {
-            cart.setQuantity(cart.getQuantity()+count);
+        } else {
+            // 如果购物车中已经存在该商品的记录，说明之前已经添加过这个商品到购物车了，此时只需要更新商品的数量即可，
+            // 将原有的商品数量加上此次要添加的数量，更新Cart对象中的quantity属性。
+            cart.setQuantity(cart.getQuantity() + count);
+            // 通过CartMapper的updateByPrimaryKeySelective方法，根据更新后的Cart对象去更新数据库中对应的购物车记录，
+            // 这个方法会根据Cart对象中不为null的属性来更新数据库相应字段，返回受影响的行数，若返回0则表示更新失败，同样返回添加购物车失败的提示响应给客户端。
             int resultCount = cartMapper.updateByPrimaryKeySelective(cart);
-            if(resultCount == 0){
+            if (resultCount == 0) {
                 return ServerResponse.createByErrorMessage("添加购物车失败");
             }
         }
-        //构建购物车信息，返回给前端，并且要检查库存
-        CartVo cartVo = getCartVoLimit(userId,true);
+
+        // 构建购物车信息，返回给前端，并且要检查库存
+        // 调用getCartVoLimit方法来构建包含购物车详细信息的CartVo对象，这个方法内部会进一步处理购物车中商品的各种信息，
+        // 比如获取商品的详细信息（可能再次从缓存或远程查询商品服务获取更详细数据）、判断库存情况、计算购物车商品的总价等操作，
+        // 最后返回一个表示操作成功且包含构建好的CartVo对象的ServerResponse对象给客户端，告知用户添加商品到购物车操作成功，并将购物车的详细信息返回给前端展示给用户。
+        CartVo cartVo = getCartVoLimit(userId, true);
         return ServerResponse.createBySuccess(cartVo);
     }
 
+    /**
+     * 实现ICartService接口中定义的更新购物车中某个商品数量的方法。
+     *
+     * @param userId 用户的唯一标识符，用于确定是哪个用户的购物车中的商品数量需要更新，是操作的关键依据，若为null则不符合业务逻辑（但此处未做处理，可根据实际情况完善），
+     *               类型为整数类型，在整个购物车业务体系中关联到具体的用户账户。
+     * @param productId 要更新数量的商品的唯一标识符，若为null，说明没有明确要更新数量的具体商品，无法进行更新操作，
+     *                  会返回一个表示参数错误的ServerResponse对象给客户端，提示用户传入正确的商品ID参数，类型为整数类型，用于在购物车记录中准确找到对应的商品。
+     * @param count 要更新为的商品数量，同样不能为null，若为null则返回参数错误的提示响应，代表了更新后该商品在购物车中应有的具体数量，类型为整数类型。
+     * @return 返回一个ServerResponse对象，该对象封装了更新购物车商品数量操作的结果信息，
+     *         如果操作成功，内部包含代表成功的数据（即构建好的CartVo对象，包含了更新数量后购物车的详细信息，例如商品列表、总价等情况），
+     *         若操作失败，则包含相应的错误提示消息等内容，方便调用者（如控制层）根据返回结果判断操作是否成功，并进行相应的处理（如返回给前端提示信息等）。
+     */
     @Override
     public ServerResponse update(Integer userId, Integer productId, Integer count) {
-        if(productId == null || count == null){
+        // 首先对传入的参数进行校验，如果商品ID或者商品数量为null，说明参数不符合要求，无法进行更新操作，
+        // 此时返回一个通过ServerResponse.createByErrorMessage方法创建的表示参数错误的响应对象给客户端，提示用户修正传入的参数。
+        if (productId == null || count == null) {
             return ServerResponse.createByErrorMessage("参数错误");
         }
-        Cart cart = cartMapper.selectByUserIdProductId(userId,productId);
-        if(cart == null){
+
+        // 通过CartMapper的selectByUserIdProductId方法，根据传入的用户ID和商品ID去数据库中查询购物车中是否存在对应的商品记录，
+        // 如果不存在（即查询返回的Cart对象为null），说明要更新数量的商品在购物车中不存在，无法进行更新操作，
+        // 此时返回一个表示购物车不存在的错误提示响应对象给客户端，告知用户无法进行更新。
+        Cart cart = cartMapper.selectByUserIdProductId(userId, productId);
+        if (cart == null) {
             return ServerResponse.createByErrorMessage("购物车不存在");
         }
+
+        // 如果找到了对应的购物车商品记录，将Cart对象中的quantity属性设置为新传入的商品数量值，准备更新数据库中的对应记录。
         cart.setQuantity(count);
+        // 通过CartMapper的updateByPrimaryKeySelective方法，根据更新后的Cart对象去更新数据库中对应的购物车记录，
+        // 该方法会根据Cart对象中不为null的属性来更新数据库相应字段，返回受影响的行数，若返回0则表示更新失败，返回一个表示更新购物车失败的错误提示响应给客户端。
         int updateCount = cartMapper.updateByPrimaryKeySelective(cart);
-        if(updateCount == 0){
+        if (updateCount == 0) {
             return ServerResponse.createByErrorMessage("更新购物车失败");
         }
-        CartVo cartVo = this.getCartVoLimit(userId,true);
+
+        // 调用getCartVoLimit方法构建包含更新后购物车详细信息的CartVo对象，这个方法会进一步处理购物车商品的相关信息（如获取商品详情、判断库存、计算总价等），
+        // 最后返回一个表示操作成功且包含构建好的CartVo对象的ServerResponse对象给客户端，告知用户更新购物车商品数量操作成功，并将购物车的详细信息返回给前端展示给用户。
+        CartVo cartVo = this.getCartVoLimit(userId, true);
         return ServerResponse.createBySuccess(cartVo);
     }
 
+    /**
+     * 实现ICartService接口中定义的从购物车中删除指定商品的方法。
+     *
+     * @param userId 用户的唯一标识符，用于确定是哪个用户的购物车进行商品删除操作，若为null不符合业务逻辑（此处未做额外处理，可按需完善），
+     *               通过它能精准定位到对应用户的购物车记录，类型为整数类型。
+     * @param productIds 表示要删除的商品的标识信息，格式为以逗号分隔的字符串，例如"1,2,3"表示要删除ID为1、2、3的商品，
+     *                   若为空字符串或者格式不符合要求（无法解析出有效的商品ID列表）则返回表示参数错误的响应，类型为字符串类型。
+     * @return 返回一个ServerResponse对象，该对象封装了删除购物车商品操作的结果信息，
+     *         如果操作成功，内部包含代表成功的数据（即构建好的CartVo对象，包含了删除商品后购物车的详细信息，例如剩余商品列表、总价等情况），
+     *         若操作失败，则包含相应的错误提示消息等内容，方便调用者（如控制层）根据返回结果判断操作是否成功，并进行相应的处理（如返回给前端提示信息等）。
+     */
     @Override
     public ServerResponse delete(Integer userId, String productIds) {
+        // 使用Google Guava库的Splitter工具类，按照逗号（","）将传入的商品ID字符串（productIds）分割成一个字符串列表，
+        // 这样就能方便地获取到要删除的各个商品的ID，以便后续批量操作数据库中对应的购物车商品记录。
         List<String> productIdList = Splitter.on(",").splitToList(productIds);
-        if(CollectionUtils.isEmpty(productIdList)){
+        // 通过Apache Commons Collections的CollectionUtils工具类检查分割后的商品ID列表是否为空，
+        // 如果为空，说明传入的参数不符合要求，无法准确执行删除操作，此时返回一个表示参数错误的ServerResponse对象给客户端，提示用户修正传入的参数。
+        if (CollectionUtils.isEmpty(productIdList)) {
             return ServerResponse.createByErrorMessage("参数错误");
         }
-        int rowCount = cartMapper.deleteByProductIds(userId,productIdList);
-        if(rowCount == 0){
+
+        // 调用CartMapper的deleteByProductIds方法，根据用户ID和要删除的商品ID列表从数据库中删除对应的购物车商品记录，
+        // 该方法会返回受影响的行数，即实际删除的记录条数，正常情况下如果成功删除了对应的商品记录，返回值应该大于0。
+        int rowCount = cartMapper.deleteByProductIds(userId, productIdList);
+        // 如果返回值为0，表示没有实际删除任何记录，可能是因为要删除的商品已经不存在于购物车中了，
+        // 此时返回一个表示商品已经不存在于购物车中，请勿重复删除的ServerResponse对象给客户端，告知用户当前操作情况。
+        if (rowCount == 0) {
             return ServerResponse.createByErrorMessage("此商品已经不存在于购物车中，请勿重复删除");
         }
-        CartVo cartVo = this.getCartVoLimit(userId,false);
+
+        // 调用getCartVoLimit方法构建包含删除商品后购物车详细信息的CartVo对象，这个方法会进一步处理购物车商品的相关信息（如获取剩余商品详情、计算总价等），
+        // 最后返回一个表示操作成功且包含构建好的CartVo对象的ServerResponse对象给客户端，告知用户删除购物车商品操作成功，并将购物车的详细信息返回给前端展示给用户。
+        CartVo cartVo = this.getCartVoLimit(userId, false);
         return ServerResponse.createBySuccess(cartVo);
     }
 
+    /**
+     * 实现ICartService接口中定义的查询购物车列表信息的方法。
+     *
+     * @param userId 用户的唯一标识符，用于确定是查询哪个用户的购物车列表，类型为整数类型，是定位具体购物车数据的关键依据。
+     * @return 返回一个ServerResponse对象，该对象封装了查询购物车列表操作的结果信息，
+     *         如果操作成功，内部包含代表成功的数据（即构建好的CartVo对象，包含了购物车的详细商品列表、总价等信息），
+     *         方便调用者（如控制层）根据返回结果将购物车信息展示给客户端（如前端页面展示购物车内容等）。
+     */
     @Override
     public ServerResponse list(Integer userId) {
-        CartVo cartVo = this.getCartVoLimit(userId,false);
+        // 直接调用getCartVoLimit方法构建包含购物车详细信息的CartVo对象，这个方法内部会处理购物车商品的相关信息（如获取商品详情、判断库存、计算总价等），
+        // 最后返回一个表示操作成功且包含构建好的CartVo对象的ServerResponse对象给客户端，告知用户查询购物车列表操作成功，并将购物车的详细信息返回给前端展示给用户。
+        CartVo cartVo = this.getCartVoLimit(userId, false);
         return ServerResponse.createBySuccess(cartVo);
     }
 
+    /**
+     * 实现ICartService接口中定义的设置购物车中商品的选中或未选中状态的方法。
+     *
+     * @param userId 用户的唯一标识符，用于确定是哪个用户的购物车进行商品选中状态设置操作，类型为整数类型，明确操作对应的购物车归属。
+     * @param checked 表示商品要设置的选中状态，可能是用整数表示（例如Constants.Cart.CHECKED表示选中，Constants.Cart.UN_CHECKED表示未选中，具体由业务定义），类型为整数类型，用于传递要设置的具体状态值。
+     * @param productId 要设置选中状态的商品的唯一标识符，若为null则表示对购物车中所有商品进行操作（根据具体业务逻辑而定），用于在购物车中定位具体的商品，类型为整数类型。
+     * @return 返回一个ServerResponse对象，该对象封装了设置商品选中状态操作的结果信息，
+     *         如果操作成功，内部包含代表成功的数据（即构建好的CartVo对象，包含了更新后的购物车相关信息，如商品选中状态改变后的购物车总价等情况），
+     *         方便调用者根据返回结果判断操作是否成功，并进行相应的处理（如返回给前端提示信息等）。
+     */
     @Override
     public ServerResponse selectOrUnSelect(Integer userId, int checked, Integer productId) {
-        cartMapper.selectOrUnSelectProduct(userId,checked,productId);
-        CartVo cartVo = this.getCartVoLimit(userId,false);
+        // 调用CartMapper的selectOrUnSelectProduct方法，根据用户ID、要设置的选中状态以及商品ID（如果不为null则针对特定商品，为null则针对所有商品，具体看业务逻辑实现）来更新数据库中购物车商品的选中状态记录，
+        // 此方法无返回值，它直接执行数据库更新操作，将对应的购物车商品记录的选中状态字段更新为传入的checked值。
+        cartMapper.selectOrUnSelectProduct(userId, checked, productId);
+
+        // 调用getCartVoLimit方法构建包含更新后购物车详细信息的CartVo对象，这个方法会进一步处理购物车商品的相关信息（如获取商品详情、判断库存、计算总价等），
+        // 最后返回一个表示操作成功且包含构建好的CartVo对象的ServerResponse对象给客户端，告知用户设置商品选中状态操作成功，并将购物车的详细信息返回给前端展示给用户。
+        CartVo cartVo = this.getCartVoLimit(userId, false);
         return ServerResponse.createBySuccess(cartVo);
     }
 
+    /**
+     * 实现ICartService接口中定义的查询购物车中商品总数量的方法。
+     *
+     * @param userId 用户的唯一标识符，用于确定是哪个用户的购物车进行商品数量统计，若为null，按照业务逻辑返回数量为0的成功响应，类型为整数类型，作为统计的范围限定依据。
+     * @return 返回一个ServerResponse<Integer>对象，该对象封装了查询购物车商品数量操作的结果信息，
+     *         如果操作成功，其泛型部分的整数表示购物车中商品的总数量，同时ServerResponse对象本身还包含操作的状态码、提示消息等内容，
+     *         方便调用者（如控制层）根据返回结果判断操作是否成功，并获取购物车商品数量的具体数值进行展示或其他相关业务处理。
+     */
     @Override
     public ServerResponse<Integer> get_cart_product_count(Integer userId) {
-        if(userId == null){
+        // 首先判断用户ID是否为null，如果为null，按照业务逻辑，直接返回一个表示操作成功且数据部分为0的ServerResponse对象，
+        // 意味着如果用户未登录或者传入的用户ID无效等情况，默认购物车商品数量为0，告知调用者当前情况。
+        if (userId == null) {
             return ServerResponse.createBySuccess(0);
         }
+
+        // 调用CartMapper的selectCartProductCount方法，传入用户ID作为参数，去查询数据库中对应用户购物车中商品的总数量，
+        // 然后返回一个表示操作成功且数据部分为查询到的商品数量的ServerResponse<Integer>对象给客户端，方便调用者获取并使用这个数量信息。
         return ServerResponse.createBySuccess(cartMapper.selectCartProductCount(userId));
     }
 
+    /**
+     * 实现ICartService接口中定义的清空购物车的方法。
+     *
+     * @param userId 用户的唯一标识符，用于确定是哪个用户的购物车进行清空操作，类型为整数类型，明确操作对应的购物车归属。
+     * @return 返回一个ServerResponse对象，该对象封装了清空购物车操作的结果信息，
+     *         如果操作成功，包含表示成功的提示消息（如这里的"清除购物车成功"），方便调用者（如控制层）根据返回结果判断操作是否成功，并进行相应的处理（如返回给前端提示信息等）。
+     */
     @Override
     public ServerResponse removeCart(Integer userId) {
+        // 首先通过CartMapper的selectCartByUserId方法，根据用户ID去查询数据库中该用户购物车中的所有商品记录，返回一个包含多个Cart对象的列表，代表购物车中的所有商品信息。
         List<Cart> cartList = cartMapper.selectCartByUserId(userId);
-        for(Cart cart:cartList){
+
+        // 遍历查询到的购物车商品记录列表，对于每一条购物车记录，调用CartMapper的deleteByPrimaryKey方法，根据购物车记录的主键（ID）从数据库中删除对应的记录，
+        // 这样就实现了逐个删除购物车中的所有商品记录，达到清空购物车的目的。
+        for (Cart cart : cartList) {
             cartMapper.deleteByPrimaryKey(cart.getId());
         }
+
+        // 返回一个表示操作成功且包含提示消息"清除购物车成功"的ServerResponse对象给客户端，告知用户购物车已成功清空，方便调用者（如控制层）将这个消息返回给前端展示给用户。
         return ServerResponse.createBySuccessMessage("清除购物车成功");
     }
 
     /**
-     * 比较通用的构建购物车的方法
-     * @param userId
-     * @return
+     * 比较通用的构建购物车的方法，用于组装包含购物车详细信息的CartVo对象，会综合考虑商品信息、库存情况、选中状态等来构建完整的购物车视图数据。
+     *
+     * @param userId 用户的唯一标识符，用于确定是哪个用户的购物车信息需要构建，类型为整数类型，是获取相关数据的关键依据。
+     * @param isJudgeStock 一个布尔类型的参数，用于决定是否需要判断商品的库存情况，有些业务接口在构建购物车信息时不需要考虑库存，
+     *                    通过这个参数可以灵活控制是否执行库存相关的判断和处理逻辑，true表示需要判断库存，false表示不需要判断库存。
+     * @return 返回一个CartVo对象，该对象包含了购物车的详细信息，如购物车商品列表（CartProductVo列表）、购物车总价、全选状态以及图片主机地址等信息，
+     *         方便在其他业务方法中作为返回数据提供给上层调用者（如控制层），进而展示给客户端（前端页面）使用。
      */
-    private CartVo getCartVoLimit(Integer userId,boolean isJudgeStock) {
+    private CartVo getCartVoLimit(Integer userId, boolean isJudgeStock) {
+        // 创建一个新的CartVo对象，用于组装最终要返回的购物车详细信息，这个对象将包含购物车的各种关键信息，如商品列表、总价、全选状态等内容。
         CartVo cartVo = new CartVo();
+
+        // 创建一个空的CartProductVo列表，用于存放购物车中各个商品的详细信息对象，后续会遍历购物车记录，将每个商品的详细信息封装成CartProductVo对象后添加到这个列表中。
         List<CartProductVo> cartProductVoList = Lists.newArrayList();
+
+        // 通过CartMapper的selectCartByUserId方法，根据传入的用户ID去查询数据库中该用户购物车中的所有商品记录，返回一个包含多个Cart对象的列表，代表购物车中的所有商品信息。
         List<Cart> cartList = cartMapper.selectCartByUserId(userId);
+
+        // 初始化购物车总价为0，使用BigDecimal类型来精确表示金额，避免浮点数运算的精度问题，后续会根据购物车中选中商品的价格和数量来累加计算总价。
         BigDecimal cartTotalPrice = new BigDecimal("0");
-        if(CollectionUtils.isNotEmpty(cartList)){
-            //1.遍历购物车，一条购物车记录对应一个商品，这些购物车共同对应到一个用户userId
-            for(Cart cart:cartList){
+
+        // 判断查询到的购物车商品记录列表是否不为空，如果不为空，说明该用户购物车中有商品，需要进一步处理这些商品的详细信息，进行购物车信息的构建。
+        if (CollectionUtils.isNotEmpty(cartList)) {
+            // 1. 遍历购物车，一条购物车记录对应一个商品，这些购物车共同对应到一个用户userId
+            // 开始遍历购物车商品记录列表，对于每一条购物车记录（代表一个商品在购物车中的信息），进行如下操作，构建对应的CartProductVo对象来封装商品详细信息，并添加到购物车商品列表中。
+            for (Cart cart : cartList) {
                 CartProductVo cartProductVo = new CartProductVo();
+                // 设置CartProductVo对象的ID，一般可以使用购物车记录的主键ID作为其唯一标识，方便后续在一些业务逻辑中对特定商品信息进行定位和操作。
                 cartProductVo.setId(cart.getId());
+                // 设置CartProductVo对象的用户ID，关联到对应的用户，确保商品信息所属的用户明确，与传入的参数userId对应。
                 cartProductVo.setUserId(cart.getUserId());
+                // 设置CartProductVo对象的商品ID，明确这个商品信息对应的具体商品，与购物车记录中的商品ID保持一致。
                 cartProductVo.setProductId(cart.getProductId());
-                //2.从redis中获取商品，获取不到则feign获取并且重置进redis中
-                String productStr = commonCacheUtil.getCacheValue(Constants.PRODUCT_TOKEN_PREFIX+cart.getProductId());
+
+                // 2. 从redis中获取商品，获取不到则feign获取并且重置进redis中
+                // 尝试从缓存（这里假设使用Redis缓存，通过CommonCacheUtil工具类操作）中获取商品信息，缓存的键是通过Constants.PRODUCT_TOKEN_PREFIX加上购物车记录中商品的ID拼接而成的，
+                // 这样可以根据不同的商品ID准确地在缓存中查找对应的商品缓存数据，提高获取商品信息的效率，避免频繁访问数据库。
+                String productStr = commonCacheUtil.getCacheValue(Constants.PRODUCT_TOKEN_PREFIX + cart.getProductId());
                 Product product = null;
-                if(productStr == null){
+                // 如果从缓存中获取到的商品信息字符串为null，说明缓存中不存在该商品的相关信息，此时需要通过ProductClient去远程调用商品服务来查询商品详情。
+                if (productStr == null) {
                     ServerResponse response = productClient.queryProduct(cart.getProductId());
                     Object object = response.getData();
                     String objStr = JsonUtil.obj2String(object);
-                    product = (Product) JsonUtil.Str2Obj(objStr,Product.class);
-                }else {
-                    product = (Product) JsonUtil.Str2Obj(productStr,Product.class);
+                    product = (Product) JsonUtil.Str2Obj(objStr, Product.class);
+                } else {
+                    // 如果缓存中存在商品信息字符串，则直接使用JsonUtil的Str2Obj方法将其反序列化为Product对象，避免了再次远程查询商品服务的开销。
+                    product = (Product) JsonUtil.Str2Obj(productStr, Product.class);
                 }
 
-                if(product != null){
+                // 如果成功获取到了商品对象（即product不为null），说明获取到了商品的详细信息，接下来可以设置CartProductVo对象中与商品相关的各种属性值。
+                if (product!= null) {
+                    // 设置CartProductVo对象的商品主图片路径，从获取到的商品对象中获取主图片路径属性值，方便前端根据这个路径展示商品的主图片。
                     cartProductVo.setProductMainImage(product.getMainImage());
+                    // 设置CartProductVo对象的商品名称，从商品对象中获取商品名称属性值，用于在前端展示商品的名称信息。
                     cartProductVo.setProductName(product.getName());
+                    // 设置CartProductVo对象的商品副标题，从商品对象中获取副标题属性值，可在前端展示商品的补充说明信息，如卖点、优惠等相关内容。
                     cartProductVo.setProductSubtitle(product.getSubtitle());
+                    // 设置CartProductVo对象的商品状态，从商品对象中获取商品状态属性值，用于前端展示商品是否可购买等状态信息（例如是否下架等情况）。
                     cartProductVo.setProductStatus(product.getStatus());
+                    // 设置CartProductVo对象的商品价格，从商品对象中获取商品价格属性值，用于后续计算商品总价等操作，注意这里价格使用BigDecimal类型保证精度。
                     cartProductVo.setProductPrice(product.getPrice());
+                    // 设置CartProductVo对象的商品库存，从商品对象中获取商品库存属性值，用于判断库存是否足够等相关业务逻辑处理。
                     cartProductVo.setProductStock(product.getStock());
-                    //3.判断这个商品的库存,有些接口不需要再去判断库存了，所以根据传进来的isJudgeStock这个boolean参数来决定是否判断库存
+
+                    // 3. 判断这个商品的库存，有些接口不需要再去判断库存了，所以根据传进来的isJudgeStock这个boolean参数来决定是否判断库存
                     int buyLimitCount = 0;
-                    if (isJudgeStock){
-                        if(product.getStock() > cart.getQuantity()){
-                            //4.库存是够的
+                    if (isJudgeStock) {
+                        // 如果需要判断库存（即isJudgeStock为true），则比较商品的库存数量和购物车中该商品的数量，判断库存是否足够。
+                        if (product.getStock() > cart.getQuantity()) {
+                            // 4. 库存是够的
+                            // 如果商品库存大于购物车中该商品的数量，说明库存充足，购买数量可以按照购物车中记录的数量来确定，将购买数量设置为购物车中的商品数量。
                             buyLimitCount = cart.getQuantity();
+                            // 设置CartProductVo对象的限制数量标识为Constants.Cart.LIMIT_NUM_SUCCESS（应该是业务中定义好的表示数量限制成功，即库存足够的
+                            // 在构建购物车信息的方法中，针对每个购物车商品记录，根据库存情况设置相关属性，并计算商品总价等信息，以下是继续添加注释后的详细内容。
+
+// 如果库存足够，设置CartProductVo对象的限制数量标识为表示库存足够的常量值，意味着当前商品在购物车中的数量是可购买的数量，没有受到库存限制。
                             cartProductVo.setLimitQuantity(Constants.Cart.LIMIT_NUM_SUCCESS);
-                        }else {
-                            //5.库存不够了,则返回当前最大库存
+                        } else {
+                            // 5. 库存不够了，则返回当前最大库存
+                            // 当商品库存小于或等于购物车中该商品的数量时，说明库存不足，此时将购买数量设置为商品当前的库存数量，即用户最多只能购买库存剩余的数量。
                             buyLimitCount = product.getStock();
+                            // 设置CartProductVo对象的限制数量标识为Constants.Cart.LIMIT_NUM_FAIL（应该是业务中定义好的表示数量限制失败，即库存不足的标识），
+                            // 用于前端展示等场景告知用户该商品库存不足，可能无法按照购物车中原本设置的数量购买。
                             cartProductVo.setLimitQuantity(Constants.Cart.LIMIT_NUM_FAIL);
+                            // 创建一个新的Cart对象，用于更新购物车中该商品的记录，因为库存不足，需要将购物车中记录的商品数量更新为实际可购买的库存数量。
                             Cart cartItem = new Cart();
+                            // 设置新Cart对象的ID为当前购物车商品记录的ID，确保更新的是正确的购物车商品记录。
                             cartItem.setId(cart.getId());
+                            // 设置新Cart对象的商品数量为前面计算得到的可购买的库存数量（buyLimitCount），准备更新数据库中的购物车记录。
                             cartItem.setQuantity(buyLimitCount);
+                            // 通过CartMapper的updateByPrimaryKeySelective方法，根据更新后的Cart对象去更新数据库中对应的购物车记录，
+                            // 这个方法会根据Cart对象中不为null的属性来更新数据库相应字段，以确保购物车中的商品数量与实际库存情况相符。
                             cartMapper.updateByPrimaryKeySelective(cartItem);
                         }
-                    }else {
+                    } else {
+                        // 如果不需要判断库存（即isJudgeStock为false），则直接将购买数量设置为购物车中原本记录的商品数量，不考虑库存是否足够的情况，可能适用于某些特定业务场景，比如仅查看购物车信息而不涉及购买操作时。
                         buyLimitCount = cart.getQuantity();
                     }
 
-                    //6.购买的数量已经是确定的了，下面就可以直接计算价格了
+                    // 6. 购买的数量已经是确定的了，下面就可以直接计算价格了
+                    // 设置CartProductVo对象的商品数量为前面确定好的购买数量（buyLimitCount），这个数量将用于后续计算该商品在购物车中的总价。
                     cartProductVo.setQuantity(buyLimitCount);
-                    cartProductVo.setProductTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(),buyLimitCount));
+                    // 使用BigDecimalUtil工具类的mul方法（应该是自定义的用于BigDecimal类型乘法运算的工具方法，确保精度），
+                    // 传入商品价格的double值（通过调用product.getPrice().doubleValue()获取）和购买数量（buyLimitCount），计算得到该商品在购物车中的总价，
+                    // 并设置到CartProductVo对象的ProductTotalPrice属性中，方便后续汇总购物车总价以及展示给用户查看商品的价格明细。
+                    cartProductVo.setProductTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(), buyLimitCount));
+                    // 设置CartProductVo对象的商品选中状态，从购物车记录中获取商品的选中状态（cart.getChecked()）并赋值给CartProductVo对象，
+                    // 用于前端展示商品是否被选中以及参与购物车总价计算等相关业务逻辑（例如只有选中的商品总价才会累加到购物车总价中）。
                     cartProductVo.setProductChecked(cart.getChecked());
                 }
-                //7.选中的，就加入到总价中
-                if(cart.getChecked() == Constants.Cart.CHECKED){
-                    cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVo.getProductTotalPrice().doubleValue());
+                // 7. 选中的，就加入到总价中
+                // 判断购物车记录中该商品的选中状态是否为Constants.Cart.CHECKED（表示已选中），如果是，则将该商品的总价累加到购物车总价（cartTotalPrice）中。
+                // 通过BigDecimalUtil工具类的add方法（同样是自定义的用于BigDecimal类型加法运算的工具方法，保证精度），
+                // 传入当前购物车总价的double值（cartTotalPrice.doubleValue()）和该商品的总价（cartProductVo.getProductTotalPrice().doubleValue()）进行累加计算，
+                // 更新购物车总价，以得到所有选中商品的总价信息。
+                if (cart.getChecked() == Constants.Cart.CHECKED) {
+                    cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(), cartProductVo.getProductTotalPrice().doubleValue());
                 }
+                // 将构建好的包含该商品详细信息的CartProductVo对象添加到购物车商品列表（cartProductVoList）中，完成一个商品信息的处理，后续继续遍历其他购物车商品记录进行同样的操作。
                 cartProductVoList.add(cartProductVo);
             }
         }
+
+        // 设置CartVo对象的购物车总价属性（CartTotalPrice）为前面计算得到的购物车总价（cartTotalPrice），方便将购物车总价信息传递给上层调用者（如控制层）展示给用户查看整个购物车的商品总价情况。
         cartVo.setCartTotalPrice(cartTotalPrice);
+        // 设置CartVo对象的购物车商品列表属性（CartProductVoList）为前面构建好的包含所有商品详细信息的列表（cartProductVoList），
+        // 这样在前端展示购物车信息时，可以遍历这个列表展示每个商品的各项信息（如名称、价格、数量、选中状态等）。
         cartVo.setCartProductVoList(cartProductVoList);
+        // 调用getAllCheckedStatus方法（下面定义的用于判断购物车中商品是否全选的方法），传入用户ID作为参数，获取购物车中商品的全选状态（是否所有商品都被选中），
+        // 并设置到CartVo对象的AllChecked属性中，方便前端展示购物车全选按钮的状态以及进行全选、取消全选等相关业务逻辑操作。
         cartVo.setAllChecked(this.getAllCheckedStatus(userId));
-        cartVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix","http://img.oursnail.cn/"));
-        log.info("购物车列表内容为：{}",cartVo);
+        // 通过PropertiesUtil工具类的getProperty方法（应该是用于读取配置文件中属性值的工具方法），尝试获取配置文件中名为"ftp.server.http.prefix"的属性值，
+        // 如果获取不到，则使用默认值"http://img.oursnail.cn/"作为图片主机地址，这个地址通常用于前端展示购物车中商品图片时拼接图片的具体路径，
+        // 例如商品主图片路径可能是相对路径，通过拼接这个图片主机地址可以得到完整的可访问的图片URL，方便前端正确展示商品图片。
+        cartVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix", "http://img.oursnail.cn/"));
+        // 使用日志记录器记录购物车列表的详细内容，方便在开发、调试以及运行过程中查看购物车信息的构建情况，排查可能出现的问题，例如购物车总价计算错误、商品信息缺失等情况。
+        log.info("购物车列表内容为：{}", cartVo);
+        // 最后返回构建好的包含完整购物车详细信息的CartVo对象，供上层调用者（如在其他业务方法中）使用，例如将其包装在ServerResponse对象中返回给控制层，进而展示给前端页面。
         return cartVo;
     }
 
     /**
-     * 0-未勾选，1-已勾选，所以我就找有没有未勾选的商品，找到就说明没有全选
+     * 0 - 未勾选，1 - 已勾选，所以我就找有没有未勾选的商品，找到就说明没有全选
+     * 此方法用于判断给定用户的购物车中商品是否全部被选中，通过查询购物车中已选中商品的状态数量来判断。
+     * 如果查询到的已选中商品的状态数量为0，意味着没有商品被选中，即购物车中的商品不是全选状态，返回false；
+     * 否则说明购物车中至少有一个商品被选中，返回true表示全选状态（这里根据业务逻辑中对于全选的定义来判断，具体业务可能有所不同，可按需调整）。
+     *
+     * @param userId 用户的唯一标识符，用于确定是哪个用户的购物车进行全选状态判断，类型为整数类型，是定位具体购物车数据的关键依据。
+     * @return 返回一个布尔值，表示购物车中商品是否处于全选状态，true表示全选，false表示未全选。
      */
     private Boolean getAllCheckedStatus(Integer userId) {
-        if(userId == null){
+        // 首先判断用户ID是否为null，如果为null，按照业务逻辑，直接返回false，表示无法判断全选状态或者默认不是全选状态（可根据实际业务含义调整），
+        // 例如在未登录或者传入无效用户ID的情况下，不认为购物车是全选状态。
+        if (userId == null) {
             return false;
         }
+        // 调用CartMapper的selectCartCheckedStatusByUserId方法，传入用户ID作为参数，去查询数据库中该用户购物车中已选中商品的状态数量，
+        // 这里返回值的具体含义可能根据业务逻辑而定，例如返回的是已选中商品的记录条数等，只要返回值不为0，就表示有商品被选中。
         return cartMapper.selectCartCheckedStatusByUserId(userId) == 0;
     }
-}
+}

snailmall-cart-service/src/main/java/com/njupt/swg/vo/CartProductVo.java

@@ -3,7 +3,6 @@ package com.njupt.swg.vo;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-
 import java.io.Serializable;
 import java.math.BigDecimal;
 
@@ -11,24 +10,69 @@ import java.math.BigDecimal;
  * @Author swg.
  * @Date 2019/1/5 15:18
  * @CONTACT 317758022@qq.com
- * @DESC
+ * @DESC 这个类（CartProductVo）是一个值对象（Value Object，简称 VO），用于在不同层之间传递购物车中商品的相关详细信息，
+ * 它将购物车中单个商品的多个属性整合在一起，方便进行数据传输和展示等操作。例如，在从服务层向控制层传递购物车商品信息，
+ * 或者控制层将这些信息进一步返回给前端展示时，使用这个VO对象可以清晰、规范地携带和传递数据，并且遵循了面向对象的设计原则，
+ * 使代码的可读性和可维护性更好。同时实现了Serializable接口，意味着这个对象可以被序列化和反序列化，便于在网络传输、存储等场景中使用。
  */
 @NoArgsConstructor
+// 通过 @NoArgsConstructor注解，Lombok会为这个类自动生成一个无参构造函数。在很多情况下，比如通过反射创建对象、进行序列化和反序列化操作时，无参构造函数是必要的，确保类有默认的创建实例的方式。
+
 @AllArgsConstructor
+// @AllArgsConstructor注解则指示Lombok生成一个包含所有参数的构造函数，方便在创建对象时一次性传入所有属性的值进行初始化，例如：
+// CartProductVo cartProductVo = new CartProductVo(1, 1001, 2001, 2, "华为手机", "高性能智能手机", "http://img/phone.jpg", new BigDecimal("3999"), 1, new BigDecimal("7998"), 10, 1, "库存充足");
+
 @Data
+// 使用Lombok的 @Data注解，会自动为这个类生成常用的方法，包括所有属性的Getter和Setter方法，以及重写的toString、hashCode和equals方法等，减少了手动编写这些样板代码的工作量，使代码更加简洁，便于对类中属性进行操作和使用。
+
 public class CartProductVo implements Serializable {
+
+    // 购物车商品记录的唯一标识符，通常与数据库中购物车表内对应商品记录的主键相关联，用于在系统中唯一标识这条购物车商品记录，方便进行查询、更新、删除等操作，类型为整数类型。
     private Integer id;
+
+    // 用户的唯一标识符，关联到具体是哪个用户的购物车中的商品，通过这个字段可以明确该商品所属的用户，与系统中用户模块的用户ID相对应，类型为整数类型。
     private Integer userId;
+
+    // 商品的唯一标识符，用于确定购物车中存放的是哪个具体商品，可通过这个ID去查询商品的详细信息（如商品详情、库存等），在整个商品管理和购物流程中用于区分不同的商品，类型为整数类型。
     private Integer productId;
-    private Integer quantity;//购物车中此商品的数量
+
+    // 购物车中此商品的数量，代表用户添加该商品到购物车的数量情况，例如用户添加了3件某商品到购物车，这个字段的值就会是3，类型为整数类型，
+    // 在购物车相关业务逻辑中，这个数量会参与到总价计算、库存判断等操作中。
+    private Integer quantity;
+
+    // 商品的名称，用于展示给用户，让用户直观地知道商品是什么，是一个字符串类型的属性，例如"华为P50手机"等，
+    // 在购物车列表展示、商品详情页展示等场景中会用到这个字段来呈现商品的基本信息。
     private String productName;
+
+    // 商品的副标题，通常可以用来补充说明商品的一些特点、卖点或者优惠信息等内容，也是字符串类型，
+    // 比如"华为P50手机，超感知徕卡四摄，限时优惠"，可以进一步吸引用户关注该商品，在前端展示购物车商品时丰富商品的展示信息。
     private String productSubtitle;
+
+    // 商品的主图片的路径或者标识，一般用于在前端页面展示商品的主要图片，字符串类型，
+    // 这个路径可以是相对路径或者绝对路径，指向存储商品主图的位置（可能是服务器本地存储、云存储等），方便前端根据这个路径来加载并展示图片，使购物车中的商品展示更加直观形象。
     private String productMainImage;
+
+    // 商品的价格，使用BigDecimal类型来精确表示金额，避免使用浮点数类型（如double、float）带来的精度丢失问题，
+    // 例如可以表示为new BigDecimal("9.99")，准确地存储商品的售价信息，在购物车计算总价、下单结算等涉及金额计算的业务场景中会频繁使用这个字段。
     private BigDecimal productPrice;
+
+    // 商品的状态标识，具体含义由业务逻辑定义，可能用不同的整数值来表示不同的状态，比如1表示上架、0表示下架等，
+    // 用于控制商品是否在前端展示、是否可购买等情况，方便后台管理人员对商品的售卖状态进行管理和操作，在购物车中展示商品时也需要根据这个状态来决定是否显示商品等操作。
     private Integer productStatus;
+
+    // 商品在购物车中的总价，通过商品的单价（productPrice）乘以购物车中该商品的数量（quantity）计算得出，同样使用BigDecimal类型保证金额计算的精度，
+    // 用于在购物车中展示每个商品的总价情况，方便用户清楚了解购买该商品所需的费用，以及参与整个购物车总价的汇总计算等业务操作。
     private BigDecimal productTotalPrice;
+
+    // 商品的库存数量，用于记录当前商品还有多少件可供销售，整数类型，
+    // 在购物车相关业务中，如添加商品到购物车、更新商品数量等操作时，会根据这个字段的值来判断操作是否可行，比如库存不足时不能继续添加商品到购物车或者需要调整购物车中商品数量等情况，同时在前端展示时也可以告知用户商品的库存剩余情况。
     private Integer productStock;
-    private Integer productChecked;//此商品是否勾选
 
-    private String limitQuantity;//限制数量的一个返回结果
-}
+    // 此商品是否勾选，用于表示商品在购物车中的选中状态，具体取值含义可能由业务逻辑定义，比如可以用1表示选中，0表示未选中等，方便在购物车相关操作（如全选、取消全选、单独选中某个商品等操作）中标记商品的状态，类型为整数类型，
+    // 在计算购物车总价时，通常只会将勾选状态的商品总价进行累加，并且前端展示购物车时也会根据这个状态来展示商品是否被选中的视觉效果（如打勾图标等）。
+    private Integer productChecked;
+
+    // 限制数量的一个返回结果，这个字段的具体含义可能根据业务逻辑来定，比如在判断商品库存与购物车中商品数量关系后，根据库存情况返回相应的提示信息，
+    // 像"库存充足"、"库存不足，仅剩X件"等类似表示数量限制情况的内容，以字符串形式存储，方便前端展示给用户，让用户了解商品数量相关的限制情况。
+    private String limitQuantity;
+}

snailmall-cart-service/src/main/java/com/njupt/swg/vo/CartVo.java

@@ -1,7 +1,6 @@
 package com.njupt.swg.vo;
 
 import lombok.Data;
-
 import java.math.BigDecimal;
 import java.util.List;
 
@@ -9,12 +8,29 @@ import java.util.List;
  * @Author swg.
  * @Date 2019/1/5 15:18
  * @CONTACT 317758022@qq.com
- * @DESC
+ * @DESC 这个类（CartVo）是一个值对象（Value Object，简称VO），用于在不同业务层之间传递购物车整体相关的信息，
+ * 它将购物车的几个关键属性整合在一起，方便进行数据传输、展示以及在不同模块间进行交互操作。例如，从服务层将购物车的综合信息传递给控制层，
+ * 再由控制层将这些信息返回给前端进行展示，使用这个VO对象可以使数据传递更加规范、清晰，符合面向对象的设计理念，同时也增强了代码的可读性和可维护性。
  */
 @Data
+// 使用Lombok的 @Data注解，会自动为这个类生成常用的方法，包括所有属性的Getter和Setter方法，以及重写的toString方法等，这样可以减少手动编写这些样板代码的工作量，使代码更加简洁，便于对类中属性进行操作和使用。
+
 public class CartVo {
+
+    // 购物车中商品信息列表，是一个包含CartProductVo对象的List集合，每个CartProductVo对象代表购物车中的一个商品的详细信息（如商品名称、价格、数量、选中状态等），
+    // 通过这个列表可以完整地展示购物车中所有商品的各项具体情况，方便前端遍历并展示购物车中的商品列表，以及在后端进行基于购物车商品列表的各种业务逻辑处理（如计算总价、判断全选状态等）。
     private List<CartProductVo> cartProductVoList;
+
+    // 购物车的总价，使用BigDecimal类型来精确表示金额，避免浮点数运算带来的精度丢失问题，这个总价是通过计算购物车中所有已选中商品的价格总和得到的，
+    // 它准确地反映了用户当前选择购买的商品的总费用情况，在购物车页面展示以及下单结算等业务场景中是一个非常关键的信息，方便用户清楚知晓购买这些商品需要支付的金额总数。
     private BigDecimal cartTotalPrice;
-    private Boolean allChecked;//是否已经都勾选
+
+    // 是否已经都勾选，是一个布尔类型的属性，用于表示购物车中的所有商品是否都处于被选中的状态，其取值为true表示购物车中的商品全部都被勾选了，
+    // false则表示存在至少一个商品未被勾选，这个属性方便前端展示购物车全选按钮的状态（如全选按钮是否应该被勾选等视觉效果），
+    // 同时在后端进行一些批量操作（如批量删除选中商品、批量结算等）时也可以根据这个属性来判断是否符合操作条件。
+    private Boolean allChecked;
+
+    // 图片主机地址，是一个字符串类型的属性，通常用于存放服务器上存储商品图片的主机地址或者前缀路径，例如"http://img.oursnail.cn/"，
+    // 在前端展示购物车中商品的图片时，需要将商品图片的相对路径与这个图片主机地址进行拼接，从而形成完整的可访问的图片URL，以正确地加载并展示商品的图片信息，使购物车中的商品展示更加直观形象。
     private String imageHost;
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/cache/CommonCacheUtil.java

@@ -11,70 +11,111 @@ import redis.clients.jedis.JedisPool;
  * @Author swg.
  * @Date 2019/1/1 15:03
  * @CONTACT 317758022@qq.com
- * @DESC
+ * @DESC 这个类（CommonCacheUtil）是一个工具类，主要用于与Redis缓存进行交互操作，
+ * 提供了如向缓存中存储数据、从缓存中获取数据、设置带过期时间的缓存数据以及删除缓存数据等常用功能，
+ * 在整个项目中，方便其他模块通过调用这些方法来利用Redis缓存提升系统性能，减少对数据库等其他数据源的频繁访问，例如在购物车模块中缓存商品信息等场景会用到此类方法。
+ * 同时，在方法执行出现异常时，会进行相应的日志记录并抛出业务相关的异常（SnailmallException），方便上层调用者进行统一的异常处理和业务逻辑调整。
  */
 @Component
+// 使用 @Component注解将这个类标记为Spring的一个组件，使得Spring容器能够自动扫描并管理这个类的实例，这样在其他需要使用的地方就可以通过依赖注入的方式来获取该类的实例进行缓存操作。
+
 @Slf4j
+// 通过 @Slf4j注解，利用Lombok的功能自动为这个类添加一个名为log的日志记录器，用于记录在与Redis缓存交互过程中出现的各种错误信息等日志内容，方便后续排查问题、监控系统运行状态等。
+
 public class CommonCacheUtil {
 
+    // 通过Spring的依赖注入机制，自动注入JedisPoolWrapper对象，JedisPoolWrapper应该是对JedisPool（Jedis连接池对象，用于管理Jedis客户端与Redis服务器的连接）进行包装的一个类，
+    // 在这里注入它的目的是为了获取JedisPool实例，进而通过JedisPool获取Jedis客户端对象来与Redis进行交互操作，实现缓存相关的功能，这种方式有助于更好地管理和配置Jedis连接资源。
     @Autowired
     private JedisPoolWrapper jedisPoolWrapper;
 
-
     /**
-     * 缓存永久key
+     * 缓存永久key的方法，用于将指定的键值对永久存储到Redis缓存中（这里的永久是指没有设置过期时间，不过在实际生产环境中可能需要根据业务需求和缓存策略来调整）。
+     *
+     * @param key 要存储到缓存中的键，是一个字符串类型，用于唯一标识缓存中的一个数据项，例如可以是按照一定规则拼接的商品ID、用户ID等信息作为键，方便后续根据键来获取对应的值，类型为字符串类型。
+     * @param value 要存储到缓存中的值，同样为字符串类型，它可以是序列化后的对象数据（如JSON字符串形式的商品信息等），根据业务需求存储各种需要缓存的数据内容，类型为字符串类型。
      */
     public void cache(String key, String value) {
         try {
+            // 通过JedisPoolWrapper获取JedisPool对象，它是管理Jedis客户端连接的连接池，如果获取到的连接池不为null，说明可以正常获取到与Redis服务器的连接资源，进而进行后续操作。
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
+            if (pool!= null) {
+                // 从JedisPool中获取一个Jedis客户端对象，Jedis客户端用于实际与Redis服务器进行交互，这里使用了Java 7的try-with-resources语句，
+                // 可以确保在使用完Jedis客户端后自动关闭资源，释放连接，避免资源泄露，提高资源利用效率和系统的稳定性。
                 try (Jedis Jedis = pool.getResource()) {
+                    // 选择Redis的数据库编号，这里选择0号数据库（通常Redis可以配置多个数据库，默认从0开始编号），根据实际业务需求和项目配置，可能会选择不同的数据库来区分不同类型的数据缓存等情况，不过这里固定选择了0号数据库进行操作。
                     Jedis.select(0);
+                    // 使用Jedis客户端的set方法，将指定的键（key）和值（value）存储到Redis缓存中，实现缓存数据的功能，如果键已经存在，则会覆盖原有的值，这是一种简单的设置缓存数据的操作方式。
                     Jedis.set(key, value);
                 }
             }
         } catch (Exception e) {
+            // 如果在缓存数据过程中出现任何异常，使用日志记录器记录错误信息，方便后续查看具体的异常情况，排查是网络问题、Redis服务器问题还是其他原因导致的缓存失败，这里记录的日志级别为ERROR，表示出现了错误情况。
             log.error("redis存值失败", e);
+            // 抛出SnailmallException异常，异常信息为"redis报错"，在调用这个方法的上层模块（如业务逻辑层的相关类）可以捕获这个异常，并根据业务需求进行相应的处理，比如返回错误提示给客户端或者进行重试等操作。
             throw new SnailmallException("redis报错");
         }
     }
 
     /**
-     * 获取缓存key
+     * 获取缓存key对应的value值的方法，用于从Redis缓存中根据指定的键获取对应的值，如果键不存在则返回null。
+     *
+     * @param key 要从缓存中获取值的键，是一个字符串类型，通过这个键去查找在Redis缓存中之前存储的数据，类型为字符串类型。
+     * @return 返回从缓存中获取到的对应键的值，为字符串类型，如果缓存中不存在该键对应的内容，则返回null，方便调用者根据返回值判断缓存中是否存在期望的数据并进行后续业务处理。
      */
     public String getCacheValue(String key) {
         String value = null;
         try {
+            // 通过JedisPoolWrapper获取JedisPool对象，用于后续获取Jedis客户端连接，判断连接池是否可用，若不为null则可以继续进行获取缓存值的操作。
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
+            if (pool!= null) {
+                // 从JedisPool中获取一个Jedis客户端对象，并使用try-with-resources语句确保资源的正确释放，然后通过这个客户端与Redis服务器进行交互操作。
                 try (Jedis Jedis = pool.getResource()) {
+                    // 选择Redis的0号数据库，与前面存储数据时选择的数据库保持一致，确保在同一个数据库中进行数据的读写操作，避免出现数据查找不一致等问题。
                     Jedis.select(0);
+                    // 使用Jedis客户端的get方法，根据传入的键（key）从Redis缓存中获取对应的值，并将获取到的值赋给局部变量value，若键不存在则返回null，这是Redis获取缓存值的基本操作方式。
                     value = Jedis.get(key);
                 }
             }
         } catch (Exception e) {
+            // 如果在获取缓存值的过程中出现异常，记录详细的错误日志，方便后续排查问题，确定是网络、服务器还是其他原因导致的获取失败，日志级别为ERROR，表示出现了错误情况。
             log.error("redis获取指失败", e);
+            // 抛出SnailmallException异常，告知调用者Redis操作出现报错，上层模块可以捕获该异常并进行相应的业务处理，比如返回默认值或者提示客户端缓存获取失败等情况。
             throw new SnailmallException("redis报错");
         }
         return value;
     }
 
     /**
-     * 过期key
+     * 过期key的方法，用于向Redis缓存中存储一个带有过期时间的数据项，即设置一个键值对，同时指定这个键在一定时间（以秒为单位）后过期失效，
+     * 并且先通过setnx操作保证只有在键不存在时才进行设置（原子操作，避免并发情况下的重复设置问题），返回一个表示设置是否成功的结果（1表示成功，0表示失败，因为键已经存在等原因）。
+     *
+     * @param key 要存储到缓存中的键，是一个字符串类型，用于唯一标识缓存中的一个数据项，例如可以是按照一定规则拼接的临时数据的标识等，类型为字符串类型。
+     * @param value 要存储到缓存中的值，同样为字符串类型，存储具体的数据内容，比如临时的验证码信息等需要设置过期时间的数据，类型为字符串类型。
+     * @param expire 表示键值对在Redis缓存中的过期时间，单位为秒，通过这个参数可以控制缓存数据的有效时长，根据业务需求合理设置过期时间，例如设置验证码的有效时间为60秒等情况，类型为整数类型。
+     * @return 返回一个长整型数值，表示设置操作的结果，1表示设置成功，即键不存在时成功设置了键值对并设置了过期时间；0表示设置失败，通常是因为键已经存在，不符合setnx操作只有键不存在时才设置的条件，方便调用者根据返回结果判断操作是否成功并进行后续业务处理。
      */
     public long cacheNxExpire(String key, String value, int expire) {
         long result = 0;
         try {
+            // 获取JedisPool对象，用于获取Jedis客户端连接，若连接池不为null则可进行后续与Redis服务器的交互操作。
             JedisPool pool = jedisPoolWrapper.getJedisPool();
-            if (pool != null) {
+            if (pool!= null) {
+                // 从JedisPool中获取一个Jedis客户端对象，并通过try-with-resources语句确保使用后自动关闭资源，然后与Redis服务器进行操作。
                 try (Jedis jedis = pool.getResource()) {
+                    // 选择Redis的0号数据库，确保在正确的数据库中进行数据操作。
                     jedis.select(0);
+                    // 使用Jedis客户端的setnx方法（SET if Not eXists的缩写，是一个原子操作），尝试将指定的键（key）和值（value）存储到Redis缓存中，
+                    // 只有当键不存在时才会设置成功，返回1；如果键已经存在，则设置失败，返回0，将这个结果赋值给result变量，用于后续判断操作是否成功以及返回给调用者。
                     result = jedis.setnx(key, value);
+                    // 如果前面的setnx操作成功（即result为1），则使用Jedis客户端的expire方法，为刚刚设置的键（key）设置过期时间，单位为秒，通过传入的expire参数指定具体的过期时长，确保缓存数据在指定时间后自动失效。
                     jedis.expire(key, expire);
                 }
             }
         } catch (Exception e) {
+            // 如果在设置带过期时间的缓存数据过程中出现异常，记录详细的错误日志，便于后续排查是哪个环节出现问题导致操作失败，日志级别为ERROR，表示出现错误情况。
             log.error("redis塞值和设置缓存时间失败", e);
+            // 抛出SnailmallException异常，告知调用者Redis操作出现报错，上层模块捕获该异常后可以根据业务逻辑进行相应处理，比如重新尝试设置或者提示客户端操作失败等情况。
             throw new SnailmallException("redis报错");
         }
 
@@ -82,23 +123,25 @@ public class CommonCacheUtil {
     }
 
     /**
-     * 删除缓存key
+     * 删除缓存key的方法，用于从Redis缓存中删除指定的键及其对应的数据项，如果键不存在则不会执行任何实际删除操作，也不会抛出异常。
+     *
+     * @param key 要从缓存中删除的键，是一个字符串类型，通过这个键来定位并删除在Redis缓存中对应的缓存数据，类型为字符串类型。
      */
     public void delKey(String key) {
         JedisPool pool = jedisPoolWrapper.getJedisPool();
-        if (pool != null) {
+        if (pool!= null) {
             try (Jedis jedis = pool.getResource()) {
                 jedis.select(0);
                 try {
+                    // 使用Jedis客户端的del方法，尝试从Redis缓存中删除指定的键（key）对应的缓存数据，若键存在则会成功删除，若不存在则不做任何操作，不会抛出异常，这是Redis删除缓存数据的基本操作方式。
                     jedis.del(key);
                 } catch (Exception e) {
+                    // 如果在删除缓存数据过程中出现异常，记录详细的错误日志，方便后续排查是网络、Redis服务器还是其他原因导致的删除失败，日志级别为ERROR，表示出现错误情况。
                     log.error("从redis中删除失败", e);
+                    // 抛出SnailmallException异常，告知调用者Redis操作出现报错，上层模块捕获该异常后可以根据业务逻辑进行相应处理，比如提示客户端缓存删除失败等情况。
                     throw new SnailmallException("redis报错");
                 }
             }
         }
     }
-
-
-
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/cache/JedisPoolWrapper.java

@@ -13,30 +13,64 @@ import javax.annotation.PostConstruct;
  * @Date 2019/1/1 15:00
  * @CONTACT 317758022@qq.com
  * @DESC 只做了单个redis，但是课程中实现的redis客户端集群，要掌握一致性hash算法
+ * 这个类（JedisPoolWrapper）主要用于封装JedisPool（Jedis连接池对象）的初始化和获取操作，通过依赖注入获取相关配置参数，
+ * 利用JedisPoolConfig来配置连接池的各项属性，然后创建JedisPool实例，方便在其他类（如与Redis缓存交互的工具类）中获取JedisPool对象，进而获取Jedis客户端与Redis进行交互，
+ * 同时在初始化过程中进行了日志记录，以便及时知晓连接池初始化的成功与否情况，对于后续排查问题、监控系统状态等有一定帮助。
  */
 @Component
+// 使用 @Component注解将这个类标记为Spring的一个组件，使得Spring容器能够自动扫描并管理这个类的实例，这样其他需要使用JedisPool的地方就可以通过依赖注入等方式获取该类的实例进行操作。
+
 @Slf4j
+// 通过 @Slf4j注解，利用Lombok的功能自动为这个类添加一个名为log的日志记录器，用于记录在初始化JedisPool过程中出现的各种情况（成功或失败）的日志信息，方便后续排查问题、监控系统运行状态等。
+
 public class JedisPoolWrapper {
+
+    // 通过Spring的依赖注入机制，自动注入Parameters对象，Parameters类应该是用于存放Redis相关配置参数（如最大连接数、最大空闲连接数、最大等待时间等）的一个类，
+    // 在这里注入它的目的是获取这些配置参数来正确配置JedisPool连接池，使连接池的各项属性符合项目的实际需求和运行环境要求。
     @Autowired
     private Parameters parameters;
 
+    // 定义一个JedisPool类型的私有变量，用于存放初始化后的JedisPool实例，初始值设置为null，在后续的init方法中会根据配置参数进行实例化操作，
+    // 通过这种方式可以在类的其他方法（如getJedisPool方法）中返回这个实例供外部使用，实现对JedisPool的封装和统一管理。
     private JedisPool jedisPool = null;
 
+    /**
+     * @PostConstruct注解标记的方法会在对象依赖注入完成后自动被调用，在这里用于初始化JedisPool连接池，
+     * 通过从注入的Parameters对象中获取配置参数，利用JedisPoolConfig来设置连接池的各项属性，然后创建JedisPool实例，完成连接池的初始化工作，
+     * 如果初始化过程中出现异常，会通过日志记录错误信息，方便后续排查问题。
+     */
     @PostConstruct
-    public void init(){
+    public void init() {
         try {
+            // 创建一个JedisPoolConfig对象，JedisPoolConfig用于配置JedisPool连接池的各种属性，例如连接池的最大连接数、最大空闲连接数、最大等待时间等，通过设置这些属性可以优化连接池的性能和资源利用情况。
             JedisPoolConfig config = new JedisPoolConfig();
+            // 设置JedisPool连接池的最大连接数，通过调用Parameters对象的getRedisMaxTotal方法获取配置的最大连接数参数值，并设置到JedisPoolConfig对象中，
+            // 这个参数决定了连接池中最多可以同时存在多少个Jedis客户端连接，需要根据实际的Redis服务器性能、业务并发量等因素合理设置，避免连接数过多导致服务器压力过大或过少影响业务处理效率。
             config.setMaxTotal(parameters.getRedisMaxTotal());
+            // 设置JedisPool连接池的最大空闲连接数，从Parameters对象中获取对应的配置参数值（通过getRedisMaxIdle方法）并设置到JedisPoolConfig对象中，
+            // 最大空闲连接数表示连接池中最多可以空闲（未被使用）的Jedis客户端连接数量，合理设置这个参数有助于提高连接资源的利用效率，避免资源浪费。
             config.setMaxIdle(parameters.getRedisMaxIdle());
+            // 设置JedisPool连接池的最大等待时间，单位为毫秒，通过Parameters对象的getRedisMaxWaitMillis方法获取配置参数值并设置到JedisPoolConfig对象中，
+            // 当连接池中的连接资源耗尽时，如果有新的获取连接请求，请求线程会在这个最大等待时间内等待空闲连接出现，如果超过这个时间仍无空闲连接，则可能抛出异常，根据业务对响应时间的要求等因素合理设置这个参数。
             config.setMaxWaitMillis(parameters.getRedisMaxWaitMillis());
-            jedisPool = new JedisPool(config,parameters.getRedisHost(),parameters.getRedisPort(),2000,"xxx");
+            // 使用配置好的JedisPoolConfig对象、Redis服务器的主机地址（通过Parameters对象的getRedisHost方法获取）、端口号（通过getRedisPort方法获取）以及连接超时时间（这里设置为2000毫秒）和密码（这里示例中为"xxx"，实际中应替换为真实密码）等信息，
+            // 创建一个JedisPool实例，这个实例就是用于管理Jedis客户端与Redis服务器连接的连接池，后续其他代码可以通过这个连接池获取Jedis客户端来与Redis进行交互操作。
+            jedisPool = new JedisPool(config, parameters.getRedisHost(), parameters.getRedisPort(), 2000, "xxx");
+            // 使用日志记录器记录一条信息，表示初始化redis连接池成功，方便在运行时查看系统启动过程中连接池初始化的情况，确认是否正常初始化，对于监控系统状态有一定帮助。
             log.info("【初始化redis连接池成功】");
-        }catch (Exception e){
-            log.error("【初始化redis连接池失败】",e);
+        } catch (Exception e) {
+            // 如果在初始化JedisPool连接池过程中出现异常，使用日志记录器记录错误信息，日志级别为ERROR，表示出现了错误情况，同时将异常对象e传入，方便记录详细的异常堆栈信息，便于后续排查问题，确定是配置参数错误、网络问题还是其他原因导致的初始化失败。
+            log.error("【初始化redis连接池失败】", e);
         }
     }
 
+    /**
+     * 这个方法用于对外提供获取JedisPool实例的接口，使得其他类（如与Redis缓存交互的工具类）可以获取到这个连接池对象，进而通过连接池获取Jedis客户端来与Redis进行交互操作，
+     * 返回的就是之前在init方法中初始化好的JedisPool实例，如果初始化失败（即jedisPool为null），则返回null，调用者需要根据返回值判断是否能正常使用连接池进行后续操作。
+     *
+     * @return 返回JedisPool实例，用于获取Jedis客户端与Redis进行交互，可能为null（如果初始化失败的情况），类型为JedisPool。
+     */
     public JedisPool getJedisPool() {
         return jedisPool;
     }
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/cache/Parameters.java

@@ -8,26 +8,49 @@ import org.springframework.stereotype.Component;
  * @Author swg.
  * @Date 2019/1/1 14:27
  * @CONTACT 317758022@qq.com
- * @DESC
+ * @DESC 这个类（Parameters）是一个用于存储项目中各种配置参数的实体类，通过Spring的 @Value注解从配置文件（通常是application.properties或application.yml等配置文件）中读取对应配置项的值，
+ * 并将这些值注入到类的相应属性中，方便在项目的其他地方使用这些配置参数进行相关操作，例如在初始化Redis连接池、与Zookeeper进行交互等场景中，都需要使用到这里定义的配置参数。
+ * 使用Lombok的 @Data注解，会自动为这个类生成常用的方法，包括所有属性的Getter和Setter方法，以及重写的toString方法等，减少了手动编写这些样板代码的工作量，使代码更加简洁，便于对类中属性进行操作和使用。
  */
 @Component
+// 使用 @Component注解将这个类标记为Spring的一个组件，使得Spring容器能够自动扫描并管理这个类的实例，并且能够识别类中的 @Value注解进行属性值的注入操作，确保可以正确获取配置文件中的参数值。
+
 @Data
+// 通过 @Data注解，Lombok会自动生成各属性的Getter和Setter方法等，方便获取和设置类中的各个配置参数属性的值，例如可以通过getRedisHost方法获取Redis服务器的主机地址，通过setRedisHost方法设置新的主机地址等操作，提高代码的简洁性和可维护性。
+
 public class Parameters {
+
     /*****redis config start*******/
+    // 使用 @Value注解，从配置文件（例如application.properties或application.yml等，具体取决于项目配置）中读取名为"redis.host"的配置项的值，并将其注入到这个名为redisHost的字符串类型属性中，
+    // 这个属性用于存储Redis服务器的主机地址，例如"localhost"或者具体的IP地址等，在初始化与Redis的连接时会用到这个地址来定位Redis服务器，类型为字符串类型。
     @Value("${redis.host}")
     private String redisHost;
+
+    // 同样通过 @Value注解，从配置文件中读取"redis.port"配置项的值，并注入到这个整数类型的属性中，该属性表示Redis服务器的端口号，默认Redis端口号一般是6379，
+    // 但可以根据实际部署情况进行配置修改，在建立与Redis服务器的连接时需要指定正确的端口号，类型为整数类型。
     @Value("${redis.port}")
     private int redisPort;
+
+    // 此处可能存在属性命名上的混淆，从 @Value注解的配置项"${redis.max-idle}"来看，本意应该是获取Redis连接池的最大空闲连接数配置参数，
+    // 但属性名却定义为redisMaxTotal，可能是命名错误（按常规理解应该是redisMaxIdle），这个属性用于设置JedisPool（如果使用Jedis连接Redis的话）中允许的最大空闲连接数量，合理设置可优化连接资源利用，类型为整数类型。
     @Value("${redis.max-idle}")
     private int redisMaxTotal;
+
+    // 类似地，这里的 @Value注解从配置文件中读取"${redis.max-total}"配置项的值注入到该属性，按常理应该是表示Redis连接池的最大连接数（即连接池中最多能同时存在的Jedis客户端连接数量），
+    // 不过属性名是redisMaxIdle（可能是命名失误，正常应类似redisMaxConnTotal之类更符合语义的名称），在配置JedisPool时会依据这个参数来控制连接池规模，类型为整数类型。
     @Value("${redis.max-total}")
     private int redisMaxIdle;
+
+    // 通过 @Value注解读取配置文件中"${redis.max-wait-millis}"配置项的值，注入到这个整数类型属性中，该属性表示当从Redis连接池中获取连接时，如果连接池中没有空闲连接，
+    // 请求线程最多等待的时间（单位为毫秒），根据业务的并发情况和对响应时间的要求等因素合理设置这个参数，避免长时间等待或因超时而出现异常，类型为整数类型。
     @Value("${redis.max-wait-millis}")
     private int redisMaxWaitMillis;
     /*****redis config end*******/
 
     /*****curator config start*******/
+    // 使用 @Value注解从配置文件中读取名为"zk.host"的配置项的值，并注入到这个字符串类型属性中，该属性用于存储Zookeeper服务器的主机地址，
+    // 在项目中如果涉及到使用Zookeeper进行服务注册与发现、分布式锁等相关功能时，会通过这个地址去连接Zookeeper服务器，类型为字符串类型。
     @Value("${zk.host}")
     private String zkHost;
     /*****curator config end*******/
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/constants/Constants.java

@@ -4,43 +4,78 @@ package com.njupt.swg.common.constants;
  * @Author swg.
  * @Date 2019/1/1 13:19
  * @CONTACT 317758022@qq.com
- * @DESC
+ * @DESC 这个类（Constants）主要用于定义项目中的各种常量，将一些在项目中经常使用且固定不变的值集中管理起来，
+ * 通过使用常量可以提高代码的可读性、可维护性以及避免在代码中出现魔法数字（直接使用字面常量而难以理解其含义的情况）和硬编码字符串等问题，方便不同模块的代码复用这些常量进行相关业务逻辑处理。
  */
 public class Constants {
-    /**自定义状态码 start**/
+
+    /**
+     * 自定义状态码 start
+     * 以下是定义的一组表示不同响应状态的整型常量，用于在整个项目的前后端交互或者模块间通信时，统一标识操作的结果状态，
+     * 使得代码中对不同状态的判断和处理更加清晰明了，避免使用随意的数字来表示状态导致代码可读性差的问题。
+     */
+    // 表示操作成功的状态码，通常在请求处理成功后返回给客户端，对应HTTP状态码中的200，表示请求已成功被服务器接收、理解、并接受，按照业务逻辑正常处理完成，类型为整数类型。
     public static final int RESP_STATUS_OK = 200;
 
+    // 表示未授权的状态码，对应HTTP状态码中的401，意味着客户端尝试访问需要授权的资源，但未提供有效的认证信息（如未登录或者登录凭证过期等情况），服务器拒绝该请求，类型为整数类型。
     public static final int RESP_STATUS_NOAUTH = 401;
 
+    // 表示服务器内部错误的状态码，等同于HTTP状态码中的500，说明在服务器端处理请求的过程中发生了意外的错误，可能是代码逻辑问题、数据库连接异常等原因导致无法正常完成请求处理，类型为整数类型。
     public static final int RESP_STATUS_INTERNAL_ERROR = 500;
 
+    // 表示请求参数错误的状态码，类似HTTP状态码中的400，意味着客户端发送的请求中包含了不符合要求的参数（如格式错误、必填参数缺失等情况），服务器无法按照这样的参数进行正确的业务处理，类型为整数类型。
     public static final int RESP_STATUS_BADREQUEST = 400;
+    /**
+     * 自定义状态码 end
+     */
 
-    /**自定义状态码 end**/
-
-    /***redis user相关的key以这个打头**/
+    /**
+     * *redis user相关的key以这个打头
+     * 定义了一个字符串常量，用于作为Redis中存储与用户相关数据的键（key）的前缀，通过添加这个前缀可以方便地对用户相关的缓存数据进行区分和管理，
+     * 例如存储用户登录信息、用户权限信息等在Redis中的键都可以以这个前缀开头，再拼接具体的用户标识（如用户ID等）来形成完整的键，类型为字符串类型。
+     */
     public static final String TOKEN_PREFIX = "user_";
 
     /**
      * 用户登陆redis的过期时间
+     * 这里定义了一个内部接口（RedisCacheExtime），在接口中定义了一个整型常量（REDIS_SESSION_EXTIME），用于表示用户登录信息在Redis缓存中的过期时间，
+     * 以秒为单位，当前设置为60 * 60 * 10，即30分钟，通过这种方式将缓存过期时间这个常量进行了集中管理，方便在需要设置用户登录缓存过期时间的地方统一引用，同时如果后续需要调整过期时间，只需要修改此处的值即可，无需在多处代码中逐个修改，提高了可维护性。
      */
-    public interface RedisCacheExtime{
-        int REDIS_SESSION_EXTIME = 60 * 60 * 10;//30分钟
+    public interface RedisCacheExtime {
+        int REDIS_SESSION_EXTIME = 60 * 60 * 10; // 30分钟
     }
 
-    /** 用户注册判断重复的参数类型 start **/
+    /**
+     * 用户注册判断重复的参数类型 start
+     * 以下定义了两个字符串常量，用于在用户注册相关业务逻辑中，明确判断重复时所针对的参数类型，例如在检查用户名或者邮箱是否已经被其他用户注册使用时，
+     * 通过使用这些常量可以使代码更加清晰直观，避免直接使用字面字符串导致代码可读性差和难以维护的问题，方便进行统一的逻辑判断和处理。
+     */
+    // 表示用于判断用户注册时邮箱是否重复的参数类型标识，在进行邮箱重复性验证的代码逻辑中可以使用这个常量来明确操作的对象是邮箱，类型为字符串类型。
     public static final String EMAIL = "email";
 
+    // 表示用于判断用户注册时用户名是否重复的参数类型标识，在验证用户名是否已被使用的业务逻辑中，通过这个常量来清晰地表明所处理的参数是用户名，类型为字符串类型。
     public static final String USERNAME = "username";
-    /** 用户注册判断重复的参数类型 end **/
+    /**
+     * 用户注册判断重复的参数类型 end
+     */
 
-    /** 用户角色 **/
-    public interface Role{
-        int ROLE_CUSTOME = 0;//普通用户
-        int ROLE_ADMIN = 1;//管理员用户
+    /**
+     * 用户角色
+     * 这里定义了一个内部接口（Role），在接口中定义了两个整型常量，用于表示项目中不同的用户角色，通过这种方式清晰地划分和标识了用户角色类型，
+     * 在涉及用户权限管理、不同角色操作权限判断等业务逻辑中，可以方便地使用这些常量进行条件判断和相应的业务处理，提高代码的可读性和可维护性。
+     */
+    public interface Role {
+        // 表示普通用户的角色标识，通常普通用户具有基本的使用系统功能的权限，但不具备管理、配置等高级权限，在权限判断等代码中可以通过这个常量来识别用户是否为普通用户，类型为整数类型。
+        int ROLE_CUSTOME = 0; // 普通用户
+
+        // 表示管理员用户的角色标识，管理员用户一般拥有系统的高级权限，例如可以管理用户、配置系统参数等操作，在进行权限相关业务逻辑处理时，通过这个常量来区分是否为管理员角色，类型为整数类型。
+        int ROLE_ADMIN = 1; // 管理员用户
     }
 
-    /**用户注册分布式锁路径***/
+    /**
+     * 用户注册分布式锁路径
+     * 定义了一个字符串常量，用于指定在使用分布式锁来保证用户注册操作的原子性和一致性时所对应的锁路径，
+     * 在涉及分布式系统中多节点同时可能进行用户注册操作的场景下，通过这个路径来创建和管理分布式锁，确保同一时间只有一个节点能够进行用户注册相关的关键操作（如写入数据库等），避免数据冲突等问题，类型为字符串类型。
+     */
     public static final String USER_REGISTER_DISTRIBUTE_LOCK_PATH = "/user_reg";
-
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/exception/ExceptionHandlerAdvice.java

@@ -1,6 +1,5 @@
 package com.njupt.swg.common.exception;
 
-
 import com.njupt.swg.common.constants.Constants;
 import com.njupt.swg.common.resp.ServerResponse;
 import lombok.extern.slf4j.Slf4j;
@@ -13,21 +12,49 @@ import org.springframework.web.bind.annotation.ResponseBody;
  * @Date 2019/1/1 13:21
  * @CONTACT 317758022@qq.com
  * @DESC 全局异常处理
+ * 这个类（ExceptionHandlerAdvice）是一个用于全局处理异常的类，它利用了Spring框架提供的 @ControllerAdvice 和 @ExceptionHandler 注解来实现统一捕获并处理项目中出现的异常情况，
+ * 通过将异常信息记录到日志中，并根据不同类型的异常返回相应的统一格式的响应给客户端，提高了系统的稳定性和用户体验，避免异常信息直接暴露给用户导致用户困惑以及保证系统在出现异常后能给出合理的提示让用户知晓情况并采取适当的操作。
  */
 @ControllerAdvice
+// @ControllerAdvice注解表明这个类是一个全局的异常处理类，它可以对整个Spring MVC应用中多个Controller（控制器）里抛出的异常进行统一处理，使得异常处理逻辑更加集中，便于维护和管理，而不需要在每个Controller中单独编写异常处理代码。
+
 @ResponseBody
+// @ResponseBody注解用于指示这个类中的方法返回的结果直接作为响应体写入到HTTP响应中，而不是像常规的Controller方法那样去寻找视图进行渲染等操作，这样可以方便地返回JSON格式或者其他格式的数据作为响应，符合现在大多数前后端分离项目中直接返回数据给前端的需求。
+
 @Slf4j
+// 通过 @Slf4j注解，利用Lombok的功能自动为这个类添加一个名为log的日志记录器，用于记录在处理异常过程中出现的各种异常信息，方便后续排查问题、分析系统出现异常的原因等，确保对异常情况有详细的记录可供查看。
+
 public class ExceptionHandlerAdvice {
+
+    /**
+     * 异常处理方法，用于处理所有继承自Exception类的异常（也就是捕获几乎所有的运行时异常和非运行时异常），
+     * 当项目中任何地方抛出Exception类型或者其子类的异常时，都会被这个方法捕获并进行相应的处理，将异常信息记录到日志中，然后返回一个统一格式的表示系统内部错误的响应给客户端。
+     *
+     * @param e 捕获到的异常对象，通过这个对象可以获取异常的详细信息，例如异常消息、堆栈信息等，方便记录日志以及判断异常的具体情况，类型为Exception。
+     * @return 返回一个ServerResponse对象，这个对象封装了统一格式的响应信息，包含了表示系统内部错误的状态码（通过Constants.RESP_STATUS_INTERNAL_ERROR常量获取）以及提示用户系统异常，请稍后再试的错误消息，方便前端根据返回的状态码和消息展示相应的提示给用户。
+     */
     @ExceptionHandler(Exception.class)
-    public ServerResponse handleException(Exception e){
-        log.error(e.getMessage(),e);
-        return ServerResponse.createByErrorCodeMessage(Constants.RESP_STATUS_INTERNAL_ERROR,"系统异常，请稍后再试");
+    public ServerResponse handleException(Exception e) {
+        // 使用日志记录器记录异常信息，通过e.getMessage()获取异常的简要消息，同时传入异常对象e本身，这样日志中还会记录详细的异常堆栈信息，方便后续排查问题，确定是哪里出现了问题导致这个异常被抛出，日志级别为ERROR，表示出现了错误情况。
+        log.error(e.getMessage(), e);
+        // 通过ServerResponse的createByErrorCodeMessage静态方法创建一个表示错误响应的ServerResponse对象，传入表示系统内部错误的状态码（Constants.RESP_STATUS_INTERNAL_ERROR）以及提示用户的错误消息（"系统异常，请稍后再试"），
+        // 返回这个对象给前端，告知前端系统出现了内部错误，让用户稍后再尝试操作，实现了对异常情况的统一响应处理，使前端能以统一的方式展示错误提示给用户。
+        return ServerResponse.createByErrorCodeMessage(Constants.RESP_STATUS_INTERNAL_ERROR, "系统异常，请稍后再试");
     }
 
+    /**
+     * 异常处理方法，专门用于处理SnailmallException类型的异常，SnailmallException应该是项目中自定义的业务异常类，
+     * 当业务逻辑中抛出这种自定义异常时，这个方法会捕获它，记录异常信息到日志中，并根据自定义异常中携带的状态码和消息返回相应的统一格式的响应给客户端，使得业务异常能够按照业务需求进行特定的处理和反馈给用户。
+     *
+     * @param e 捕获到的SnailmallException类型的异常对象，通过这个对象可以获取自定义异常中定义的状态码、异常消息等详细信息，方便进行针对性的响应处理，类型为SnailmallException。
+     * @return 返回一个ServerResponse对象，这个对象的状态码和消息根据传入的SnailmallException对象中的信息来设置，通过调用ServerResponse的createByErrorCodeMessage方法，传入异常对象的状态码（e.getExceptionStatus()）和异常消息（e.getMessage()），
+     * 返回给前端相应的提示信息，告知用户业务层面出现的具体问题情况，实现了对业务异常的统一处理和合理反馈。
+     */
     @ExceptionHandler(SnailmallException.class)
-    public ServerResponse handleException(SnailmallException e){
-        log.error(e.getMessage(),e);
-        return ServerResponse.createByErrorCodeMessage(e.getExceptionStatus(),e.getMessage());
+    public ServerResponse handleException(SnailmallException e) {
+        // 使用日志记录器记录SnailmallException类型异常的详细信息，包括异常消息和堆栈信息，方便后续查看业务异常出现的原因，进行业务逻辑的调整和优化等，日志级别为ERROR，表示出现了错误情况。
+        log.error(e.getMessage(), e);
+        // 根据自定义异常对象中携带的状态码和消息创建一个ServerResponse对象，返回给前端，使得前端可以根据返回的状态码和消息展示相应的提示给用户，告知用户业务层面具体的异常情况，实现了业务异常的统一处理和反馈机制。
+        return ServerResponse.createByErrorCodeMessage(e.getExceptionStatus(), e.getMessage());
     }
-
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/exception/SnailmallException.java

@@ -7,19 +7,40 @@ import lombok.Getter;
  * @Author swg.
  * @Date 2019/1/1 13:18
  * @CONTACT 317758022@qq.com
- * @DESC
+ * @DESC 这个类（SnailmallException）是项目中自定义的一个异常类，继承自Java的RuntimeException（运行时异常），
+ * 用于在业务逻辑中抛出特定的、符合项目业务场景的异常情况，通过自定义异常可以携带更多与业务相关的信息（比如特定的状态码等），方便进行统一的异常处理以及向客户端反馈更准确的错误提示信息，
+ * 区别于Java内置的通用异常，使得异常处理更加贴合项目实际业务需求，提高系统的可维护性和异常处理的灵活性。
  */
 @Getter
-public class SnailmallException extends RuntimeException{
+// 使用Lombok的 @Getter注解，会自动为这个类的私有属性（exceptionStatus）生成对应的Getter方法，这样在其他地方就可以方便地获取这个属性的值，无需手动编写Getter方法，使代码更加简洁，便于操作类中的属性。
+
+public class SnailmallException extends RuntimeException {
+
+    // 定义一个私有整型属性，用于存储异常对应的状态码，初始值设置为ResponseEnum.ERROR.getCode()，这里ResponseEnum应该是一个枚举类，用于定义各种响应状态相关的枚举值（如错误码等），
+    // 通过这种方式可以默认给自定义异常赋予一个通用的错误状态码，后续在构造函数中可以根据具体情况进行修改，类型为整数类型。
     private int exceptionStatus = ResponseEnum.ERROR.getCode();
 
-    public SnailmallException(String msg){
+    /**
+     * 构造函数，用于创建一个只传入异常消息的SnailmallException实例，
+     * 调用父类（RuntimeException）的构造函数，将传入的异常消息（msg）传递给父类，以便在抛出和处理异常时能够获取到这个具体的异常消息内容，
+     * 此时异常状态码会使用默认的ResponseEnum.ERROR.getCode()值，适用于一些通用的、不需要特定状态码的业务异常情况。
+     *
+     * @param msg 异常消息，是一个字符串类型，用于描述出现异常的具体原因或情况，方便在日志记录、向客户端反馈等场景中展示给开发人员或用户知晓具体的异常内容，类型为字符串类型。
+     */
+    public SnailmallException(String msg) {
         super(msg);
     }
 
-    public SnailmallException(int code,String msg){
+    /**
+     * 构造函数，用于创建一个同时传入异常状态码和异常消息的SnailmallException实例，
+     * 首先调用父类（RuntimeException）的构造函数，将传入的异常消息（msg）传递给父类，确保可以获取到异常消息内容，
+     * 然后将传入的状态码（code）赋值给当前类的exceptionStatus属性，用于设置这个自定义异常对应的特定状态码，方便根据不同的业务异常场景设置不同的状态码，以便在统一异常处理时进行更精准的判断和反馈。
+     *
+     * @param code 异常状态码，是一个整数类型，通过这个状态码可以区分不同类型的业务异常情况，例如不同业务模块出现的错误可以对应不同的状态码，便于在全局异常处理中进行针对性的响应处理，类型为整数类型。
+     * @param msg 异常消息，同样是一个字符串类型，用于描述具体的异常原因或情况，与上面的构造函数中msg参数作用相同，类型为字符串类型。
+     */
+    public SnailmallException(int code, String msg) {
         super(msg);
         exceptionStatus = code;
     }
-
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/resp/ResponseEnum.java

@@ -7,19 +7,34 @@ import lombok.Getter;
  * @Date 2018/12/31 20:15
  * @CONTACT 317758022@qq.com
  * @DESC 基本的返回状态描述
+ * 这个类（ResponseEnum）是一个枚举类型，用于定义项目中常见的基本返回状态相关的枚举值，通过枚举的方式将不同的返回状态进行集中管理，
+ * 每个枚举常量都包含了一个状态码（code）和对应的描述信息（desc），方便在整个项目的不同模块中统一使用这些状态来表示操作的结果情况，提高代码的可读性、可维护性以及避免出现魔法数字（直接使用字面常量而难以理解其含义的情况）和硬编码字符串等问题。
  */
 @Getter
+// 使用Lombok的 @Getter注解，会自动为这个枚举类型中的私有属性（code和desc）生成对应的Getter方法，这样在其他地方就可以方便地获取这些属性的值，无需手动编写Getter方法，使代码更加简洁，便于操作枚举中的属性值。
+
 public enum ResponseEnum {
-    SUCCESS(0,"SUCCESS"),
-    ERROR(1,"ERROR"),
-    ILLEGAL_ARGUMENTS(2,"ILLEGAL_ARGUMENTS"),
-    NEED_LOGIN(10,"NEED_LOGIN");
+    // 定义一个名为SUCCESS的枚举常量，表示操作成功的返回状态，其对应的状态码为0，描述信息为"SUCCESS"，
+    // 在项目中当某个操作（如数据库查询、业务逻辑处理等）成功完成后，可以使用这个枚举常量来表示成功的结果，方便统一返回格式以及在其他代码中进行结果判断等操作。
+    SUCCESS(0, "SUCCESS"),
+    // 定义一个名为ERROR的枚举常量，状态码为1，描述信息为"ERROR"，用于表示出现错误的返回状态，在业务逻辑中如果发生了异常或者不符合预期的情况，可以使用这个枚举常量来表示操作失败，向调用者传达出现错误的信息。
+    ERROR(1, "ERROR"),
+    // 定义一个名为ILLEGAL_ARGUMENTS的枚举常量，状态码为2，描述信息为"ILLEGAL_ARGUMENTS"，通常用于表示传入的参数不符合要求（如参数格式错误、缺失必要参数等情况）的返回状态，
+    // 在进行参数校验的代码逻辑中，如果发现参数不合法，就可以使用这个枚举常量来返回相应的错误提示信息，告知调用者参数存在问题。
+    ILLEGAL_ARGUMENTS(2, "ILLEGAL_ARGUMENTS"),
+    // 定义一个名为NEED_LOGIN的枚举常量，状态码为10，描述信息为"NEED_LOGIN"，主要用于表示需要用户登录才能进行后续操作的返回状态，
+    // 例如在访问某些需要权限的接口时，如果用户未登录，就可以返回这个枚举常量对应的状态信息，提示用户先进行登录操作，再尝试访问相应的资源。
+
+    NEED_LOGIN(10, "NEED_LOGIN");
 
+    // 定义一个私有整型属性，用于存储枚举常量对应的状态码，通过构造函数进行初始化赋值，在其他地方可以通过Getter方法获取这个状态码，用于在返回结果中传递具体的状态标识，类型为整数类型。
     private int code;
+    // 定义一个私有字符串属性，用于存储枚举常量对应的描述信息，同样通过构造函数初始化，方便在返回结果中向调用者展示更直观的操作结果描述内容，类型为字符串类型。
     private String desc;
 
-    ResponseEnum(int code,String desc){
+    // 枚举类型的构造函数，用于初始化每个枚举常量的状态码（code）和描述信息（desc）属性，在定义枚举常量时会自动调用这个构造函数传入相应的值进行初始化，确保每个枚举常量都有对应的状态码和描述内容，便于后续使用。
+    ResponseEnum(int code, String desc) {
         this.code = code;
         this.desc = desc;
     }
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/resp/ServerResponse.java

@@ -5,7 +5,6 @@ import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-
 import java.io.Serializable;
 
 /**
@@ -13,67 +12,102 @@ import java.io.Serializable;
  * @Date 2018/12/31 20:11
  * @CONTACT 317758022@qq.com
  * @DESC 作为本项目的通用的返回封装类
+ * 这个类（ServerResponse）是项目中的一个通用返回封装类，用于将服务端的操作结果统一进行包装，方便在不同的业务接口返回数据时，按照统一的格式向客户端（如前端应用）传递信息，
+ * 它包含了状态码（status）、提示消息（msg）以及具体的数据内容（data）等属性，同时提供了一系列静态方法来方便地创建不同情况下（成功或失败等）的返回实例，增强了返回结果的规范性、可读性以及便于客户端进行统一的结果处理。
  */
 @Getter
+// 使用Lombok的 @Getter注解，会自动为这个类中的私有属性（status、msg、data）生成对应的Getter方法，使得在其他地方（如调用接口的客户端代码）可以方便地获取这些属性的值，无需手动编写Getter方法，代码更加简洁，便于操作类中的属性。
+
 @JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
+// 这个注解用于配置Jackson序列化的行为，这里指定了只序列化非空的属性，也就是说在将ServerResponse对象转换为JSON格式（例如返回给前端时），如果属性值为null，那么该属性就不会出现在最终的JSON数据中，
+// 这样可以减少不必要的数据传输，使返回的JSON数据更加精简，符合实际业务中通常不需要返回大量空值属性的需求。
+
 public class ServerResponse<T> implements Serializable {
+    // 定义一个私有整型属性，用于存储返回结果的状态码，通过不同的状态码可以表示操作是成功还是失败以及其他各种不同的业务状态，例如可以使用前面定义的ResponseEnum枚举中的状态码值，类型为整数类型。
     private int status;
+    // 定义一个私有字符串属性，用于存储返回结果的提示消息，这个消息可以是操作成功的提示、失败的错误信息或者其他相关的说明内容，方便客户端根据消息展示给用户相应的提示信息，类型为字符串类型。
     private String msg;
+    // 定义一个泛型属性，用于存储具体的业务数据，类型根据实际业务场景而定，可以是单个对象、列表、Map等各种数据结构，通过泛型可以使这个返回封装类更加灵活，适用于不同类型数据的返回，类型为泛型类型<T>。
     private T data;
 
-    public ServerResponse(){}
+    // 默认的无参构造函数，用于创建一个初始状态的ServerResponse对象，在某些情况下可能需要先创建对象再设置其各个属性的值，提供了一种默认的创建方式，不过在实际使用中更多是通过静态方法来创建具体状态的返回实例。
+    public ServerResponse() {
+    }
 
-    private ServerResponse(int status){
+    // 私有构造函数，用于创建一个只传入状态码的ServerResponse对象，主要在类内部的其他构造函数或者静态方法中调用，方便根据给定的状态码初始化对象，外部一般不直接使用这个构造函数，而是通过提供的静态方法来创建返回实例，参数为状态码（status），类型为整数类型。
+    private ServerResponse(int status) {
         this.status = status;
     }
-    private ServerResponse(int status,String msg){
+
+    // 私有构造函数，用于创建一个传入状态码和提示消息的ServerResponse对象，方便在需要指定特定状态码和相应提示消息的情况下初始化对象，同样主要在类内部被调用，参数为状态码（status）和提示消息（msg），分别为整数类型和字符串类型。
+    private ServerResponse(int status, String msg) {
         this.status = status;
         this.msg = msg;
     }
-    private ServerResponse(int status,T data){
+
+    // 私有构造函数，用于创建一个传入状态码和具体数据的ServerResponse对象，适用于操作成功并需要返回具体业务数据的场景，在类内部通过静态方法等方式调用这个构造函数来创建相应的返回实例，参数为状态码（status）和数据（data），类型分别为整数类型和泛型类型<T>。
+    private ServerResponse(int status, T data) {
         this.status = status;
         this.data = data;
     }
-    private ServerResponse(int status,String msg,T data){
+
+    // 私有构造函数，用于创建一个传入状态码、提示消息和具体数据的ServerResponse对象，是最完整的构造方式，可用于各种不同的业务返回情况，根据具体的状态、消息以及要返回的数据来初始化对象，参数分别为状态码（status）、提示消息（msg）和数据（data），对应整数类型、字符串类型和泛型类型<T>。
+    private ServerResponse(int status, String msg, T data) {
         this.status = status;
         this.msg = msg;
         this.data = data;
     }
 
+    /**
+     * @JsonIgnore注解用于指示在JSON序列化（例如将对象转换为JSON格式返回给前端时）过程中忽略这个方法，
+     * 这里定义了一个用于判断返回结果是否为成功状态的方法，通过比较当前对象的状态码（status）和ResponseEnum.SUCCESS.getCode()（即表示成功的状态码）是否相等来确定，
+     * 返回一个布尔值，true表示操作成功，false表示操作失败或者处于其他非成功的业务状态，方便客户端代码（如前端JavaScript代码接收返回结果后）进行简单的判断来决定后续如何展示信息或者进行其他操作。
+     */
     @JsonIgnore
-    public boolean isSuccess(){
+    public boolean isSuccess() {
         return this.status == ResponseEnum.SUCCESS.getCode();
     }
 
     /**
      * 成功的方法
+     * 以下是一组静态方法，用于方便地创建表示操作成功的不同情况的ServerResponse对象实例，返回给客户端相应的成功提示信息以及可能的数据内容，遵循统一的返回格式规范，使得在业务接口返回成功结果时代码更加简洁、清晰，易于维护和使用。
      */
-    public static <T>ServerResponse<T> createBySuccess(){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),ResponseEnum.SUCCESS.getDesc());
+    // 创建一个表示操作成功且只包含默认成功提示消息（从ResponseEnum.SUCCESS.getDesc()获取）的ServerResponse对象，适用于不需要额外返回具体数据的简单成功场景，例如一些只需要告知客户端操作已成功完成的接口返回情况，返回类型为泛型的ServerResponse<T>，其中<T>根据实际调用情况确定具体类型。
+    public static <T> ServerResponse<T> createBySuccess() {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), ResponseEnum.SUCCESS.getDesc());
     }
-    public static <T>ServerResponse<T> createBySuccessMessage(String message){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),message);
+
+    // 创建一个表示操作成功并可以自定义提示消息的ServerResponse对象，传入的参数message就是要设置的具体提示消息内容，适用于需要给客户端传递一些额外的成功相关说明信息的情况，例如操作成功后提示用户某些注意事项等，返回类型为泛型的ServerResponse<T>。
+    public static <T> ServerResponse<T> createBySuccessMessage(String message) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), message);
     }
-    public static <T>ServerResponse<T> createBySuccess(T data){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),data);
+
+    // 创建一个表示操作成功且包含具体业务数据的ServerResponse对象，传入的参数data就是要返回的具体业务数据，适用于接口查询操作成功后返回查询到的数据给客户端等场景，返回类型为泛型的ServerResponse<T>，<T>根据实际返回的数据类型确定。
+    public static <T> ServerResponse<T> createBySuccess(T data) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), data);
     }
-    public static <T>ServerResponse<T> createBySuccess(String message,T data){
-        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(),message,data);
+
+    // 创建一个表示操作成功、可以自定义提示消息并且包含具体业务数据的ServerResponse对象，传入的参数message是提示消息，data是具体业务数据，综合了前面几种成功情况的特点，适用于更复杂一些的成功返回场景，返回类型为泛型的ServerResponse<T>。
+    public static <T> ServerResponse<T> createBySuccess(String message, T data) {
+        return new ServerResponse<>(ResponseEnum.SUCCESS.getCode(), message, data);
     }
 
     /**
      * 失败的方法
+     * 以下是一组静态方法，用于创建表示操作失败的不同情况的ServerResponse对象实例，按照统一的格式向客户端返回失败的状态码和相应的错误提示信息，方便客户端根据返回结果展示错误提示给用户，同样使得在业务接口返回失败结果时代码编写更加规范、便捷，易于统一管理和维护。
      */
-    public static <T>ServerResponse<T> createByError(){
-        return new ServerResponse<>(ResponseEnum.ERROR.getCode(),ResponseEnum.ERROR.getDesc());
-    }
-    public static <T>ServerResponse<T> createByErrorMessage(String msg){
-        return new ServerResponse<>(ResponseEnum.ERROR.getCode(),msg);
+    // 创建一个表示操作失败且只包含默认失败提示消息（从ResponseEnum.ERROR.getDesc()获取）的ServerResponse对象，适用于一些通用的、不需要特别说明具体错误原因的失败场景，返回类型为泛型的ServerResponse<T>。
+    public static <T> ServerResponse<T> createByError() {
+        return new ServerResponse<>(ResponseEnum.ERROR.getCode(), ResponseEnum.ERROR.getDesc());
     }
-    public static <T>ServerResponse<T> createByErrorCodeMessage(int code,String msg){
-        return new ServerResponse<>(code,msg);
-    }
-
 
+    // 创建一个表示操作失败并可以自定义错误提示消息的ServerResponse对象，传入的参数msg就是要设置的具体错误提示内容，适用于根据不同的业务错误情况返回相应的具体错误信息给客户端的场景，返回类型为泛型的ServerResponse<T>。
+    public static <T> ServerResponse<T> createByErrorMessage(String msg) {
+        return new ServerResponse<>(ResponseEnum.ERROR.getCode(), msg);
+    }
 
-}
+    // 创建一个表示操作失败且可以自定义状态码和错误提示消息的ServerResponse对象，传入的参数code是要设置的具体状态码，msg是错误提示消息，适用于一些需要返回特定状态码来表示不同类型失败情况（例如不同业务模块的不同错误类型对应不同状态码）的场景，返回类型为泛型的ServerResponse<T>。
+    public static <T> ServerResponse<T> createByErrorCodeMessage(int code, String msg) {
+        return new ServerResponse<>(code, msg);
+    }
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/utils/CookieUtil.java

@@ -2,73 +2,105 @@ package com.njupt.swg.common.utils;
 
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
-
 import javax.servlet.http.Cookie;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 /**
  * cookie读写
+ * 这个类（CookieUtil）主要提供了操作Cookie的工具方法，用于在Web应用中进行与用户登录相关的Cookie的写入、读取以及删除操作，
+ * 通过合理设置Cookie的各种属性（如域名、路径、有效期、是否可通过脚本访问等）来实现安全且符合业务需求的Cookie管理，方便在用户登录认证等相关业务场景中利用Cookie来存储和获取用户登录凭证等信息。
  */
 @Slf4j
+// 通过 @Slf4j注解，利用Lombok的功能自动为这个类添加一个名为log的日志记录器，用于记录在Cookie操作过程中出现的各种相关信息，比如写入、读取、删除Cookie时的具体内容等，方便后续排查问题、监控Cookie的使用情况等。
+
 public class CookieUtil {
+
+    // 定义一个静态的字符串常量，用于指定Cookie的域名，这里设置为"oursnail.cn"，意味着这个Cookie在该域名下及其子域名下都是有效的（具体还取决于浏览器的同源策略等因素），
+    // 在实际应用中，要根据项目部署的域名情况进行准确设置，确保Cookie能在正确的范围内被识别和使用，类型为字符串类型。
     private final static String COOKIE_DOMAIN = "oursnail.cn";
+    // 定义一个静态的字符串常量，用于指定Cookie的名称，这里设置为"snailmall_login_token"，通过这个特定的名称可以在多个Cookie中准确地识别出用于存储用户登录凭证等相关信息的Cookie，类型为字符串类型。
     private final static String COOKIE_NAME = "snailmall_login_token";
 
-
     /**
      * 登陆的时候写入cookie
-     * @param response
-     * @param token
+     * 这个方法用于在用户登录成功等需要设置登录凭证的场景下，向客户端（浏览器）写入一个Cookie，将用户的登录相关信息（以token形式传入）存储到Cookie中，方便后续请求中识别用户身份。
+     *
+     * @param response HttpServletResponse对象，用于向客户端发送响应，通过这个对象可以添加要返回给客户端的Cookie信息，类型为HttpServletResponse。
+     * @param token 要写入Cookie的值，通常是代表用户登录凭证的一个字符串（比如经过加密等处理后的用户标识信息等），类型为字符串类型。
      */
-    public static void writeLoginToken(HttpServletResponse response,String token){
-        Cookie ck = new Cookie(COOKIE_NAME,token);
+    public static void writeLoginToken(HttpServletResponse response, String token) {
+        // 创建一个新的Cookie对象，使用前面定义的COOKIE_NAME作为Cookie的名称，传入的token作为Cookie的值，这样就构造好了一个要发送给客户端的Cookie实例。
+        Cookie ck = new Cookie(COOKIE_NAME, token);
+        // 设置Cookie的域名，通过调用setDomain方法并传入COOKIE_DOMAIN常量，使得这个Cookie在指定的域名（"oursnail.cn"及其子域名）下有效，确保在相应的网站范围内可以被正确识别和使用。
         ck.setDomain(COOKIE_DOMAIN);
-        ck.setPath("/");//设值在根目录
-        ck.setHttpOnly(true);//不允许通过脚本访问cookie,避免脚本攻击
-        ck.setMaxAge(60*60*24*365);//一年，-1表示永久,单位是秒，maxage不设置的话，cookie就不会写入硬盘，只会写在内存，只在当前页面有效
-        log.info("write cookieName:{},cookieValue:{}",ck.getName(),ck.getValue());
+        // 设置Cookie的路径为根目录（"/"），意味着这个Cookie在整个网站的所有页面（该域名下的所有路径）都可以被访问到，根据业务需求合理设置路径可以控制Cookie的有效访问范围，例如设置为特定的子目录则只在该子目录下的页面有效等情况。
+        ck.setPath("/");
+        // 设置Cookie的HttpOnly属性为true，这是一种安全机制，设置后浏览器将不允许通过JavaScript等脚本语言来访问这个Cookie，有效地避免了跨站脚本攻击（XSS攻击）中攻击者通过脚本获取用户登录凭证等敏感信息的风险，提高了系统的安全性。
+        ck.setHttpOnly(true);
+        // 设置Cookie的最大生存时间（有效期）为一年，通过将秒数换算（60 * 60 * 24 * 365）后设置给setMaxAge方法，单位是秒，这里表示这个Cookie从写入客户端开始，在一年内都有效，
+        // 如果设置为 -1 则表示永久有效（不过实际中永久有效的情况要谨慎使用，考虑到安全性和用户可能主动注销等因素），若不设置这个属性（即默认值），Cookie就只会存在于浏览器内存中，只在当前页面有效，关闭页面后就会被清除，根据业务需求合理设置有效期很重要。
+        ck.setMaxAge(60 * 60 * 24 * 365);
+        // 使用日志记录器记录要写入的Cookie的名称和值，方便在运行时查看具体写入的Cookie信息，例如排查是否写入了正确的登录凭证等情况，日志级别根据实际情况可能为INFO等合适的级别，用于记录操作相关的重要信息。
+        log.info("write cookieName:{},cookieValue:{}", ck.getName(), ck.getValue());
+        // 通过HttpServletResponse对象的addCookie方法，将构造好并设置好属性的Cookie添加到响应中，发送给客户端（浏览器），使得浏览器能够接收到并存储这个Cookie，完成Cookie的写入操作。
         response.addCookie(ck);
     }
 
     /**
      * 读取登陆的cookie
-     * @param request
-     * @return
+     * 该方法用于从客户端发送过来的请求中读取之前设置的用于存储用户登录凭证的Cookie，通过查找名称匹配的Cookie来获取其值，进而可以在服务端进行用户身份验证等相关操作。
+     *
+     * @param request HttpServletRequest对象，用于获取客户端发送过来的请求信息，通过这个对象可以获取请求中携带的Cookie数组，类型为HttpServletRequest。
+     * @return 返回从Cookie中读取到的存储用户登录凭证的值（如果存在的话），为字符串类型，如果没有找到名称匹配的Cookie，则返回null，方便调用者根据返回值判断是否获取到了有效的登录凭证信息。
      */
-    public static String readLoginToken(HttpServletRequest request){
+    public static String readLoginToken(HttpServletRequest request) {
+        // 通过HttpServletRequest对象的getCookies方法获取客户端发送过来的所有Cookie，返回一个Cookie数组，如果请求中没有携带Cookie，则返回null，这里先判断是否获取到了Cookie数组。
         Cookie[] cks = request.getCookies();
-        if(cks != null){
-            for(Cookie ck:cks){
-                log.info("cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
-                if(StringUtils.equals(ck.getName(),COOKIE_NAME)){
-                    log.info("return cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
+        if (cks!= null) {
+            // 遍历获取到的Cookie数组，对每个Cookie进行检查，查找名称与定义的COOKIE_NAME（"snailmall_login_token"）匹配的Cookie。
+            for (Cookie ck : cks) {
+                // 使用日志记录器记录每个Cookie的名称和值，方便在运行时查看请求中携带的Cookie具体情况，例如排查是否存在预期的登录凭证Cookie以及其值是否正确等情况，日志级别可根据实际需求设置为INFO等合适级别。
+                log.info("cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
+                // 通过StringUtils的equals方法（这里导入了Apache Commons Lang3的StringUtils类，用于方便地进行字符串比较操作，避免空指针等问题）比较当前Cookie的名称和定义的COOKIE_NAME是否相等，
+                // 如果相等，说明找到了存储用户登录凭证的Cookie，返回其值，以便后续在服务端进行相应的用户身份验证等操作。
+                if (StringUtils.equals(ck.getName(), COOKIE_NAME)) {
+                    log.info("return cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
                     return ck.getValue();
                 }
             }
         }
+        // 如果遍历完所有Cookie都没有找到名称匹配的Cookie，说明没有获取到有效的用户登录凭证信息，返回null给调用者。
         return null;
     }
 
     /**
      * 注销的时候进行删除
-     * @param request
-     * @param response
+     * 此方法用于在用户注销登录等需要清除登录凭证的场景下，从客户端删除之前设置的存储用户登录凭证的Cookie，通过设置Cookie的有效期为0等操作来实现让浏览器自动删除该Cookie的目的。
+     *
+     * @param request HttpServletRequest对象，用于获取客户端当前发送的请求信息，通过这个对象可以获取请求中携带的Cookie数组，以便查找要删除的目标Cookie，类型为HttpServletRequest。
+     * @param response HttpServletResponse对象，用于向客户端发送响应，通过这个对象可以添加修改后的Cookie信息（设置有效期为0等操作后的Cookie），让浏览器执行删除Cookie的操作，类型为HttpServletResponse。
      */
-    public static void delLoginToken(HttpServletRequest request,HttpServletResponse response){
+    public static void delLoginToken(HttpServletRequest request, HttpServletResponse response) {
+        // 通过HttpServletRequest对象的getCookies方法获取客户端发送过来的所有Cookie，返回一个Cookie数组，如果请求中没有携带Cookie，则返回null，先判断是否获取到了Cookie数组。
         Cookie[] cks = request.getCookies();
-        if(cks != null){
-            for(Cookie ck:cks) {
-                if(StringUtils.equals(ck.getName(),COOKIE_NAME)){
+        if (cks!= null) {
+            // 遍历获取到的Cookie数组，查找名称与定义的COOKIE_NAME（"snailmall_login_token"）匹配的Cookie，找到后进行删除操作。
+            for (Cookie ck : cks) {
+                if (StringUtils.equals(ck.getName(), COOKIE_NAME)) {
+                    // 设置要删除的Cookie的域名，与写入Cookie时设置的域名保持一致（通过COOKIE_DOMAIN常量指定），确保删除的是正确域名下对应的Cookie。
                     ck.setDomain(COOKIE_DOMAIN);
+                    // 设置Cookie的路径为根目录（"/"），同样要和写入时的路径设置一致，保证准确删除对应的Cookie，避免因路径不一致导致删除失败的情况。
                     ck.setPath("/");
-                    ck.setMaxAge(0);//0表示消除此cookie
-                    log.info("del cookieName:{},cookieBValue:{}",ck.getName(),ck.getValue());
+                    // 设置Cookie的最大生存时间（有效期）为0，表示这个Cookie立即失效，浏览器接收到这样设置后的Cookie后，会自动将其从本地存储中删除，从而实现了删除登录凭证Cookie的目的。
+                    ck.setMaxAge(0);
+                    // 使用日志记录器记录要删除的Cookie的名称和值等信息，方便在运行时查看具体的删除操作情况，例如确认是否删除了正确的Cookie等，日志级别可根据实际需求设置为INFO等合适级别。
+                    log.info("del cookieName:{},cookieBValue:{}", ck.getName(), ck.getValue());
+                    // 通过HttpServletResponse对象的addCookie方法，将修改了属性（主要是设置有效期为0）后的Cookie添加到响应中发送给客户端，让浏览器执行删除操作，完成Cookie的删除过程，之后遇到return语句直接结束方法执行。
                     response.addCookie(ck);
                     return;
                 }
             }
         }
     }
-
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/utils/DateTimeUtil.java

@@ -4,65 +4,115 @@ import org.apache.commons.lang3.StringUtils;
 import org.joda.time.DateTime;
 import org.joda.time.format.DateTimeFormat;
 import org.joda.time.format.DateTimeFormatter;
-
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 
 /**
  * @DESC 时间转换的工具类
+ * 这个类（DateTimeUtil）主要提供了一系列用于日期和时间格式转换的工具方法，借助了Joda-Time库（一个功能强大的日期和时间处理库）来实现更方便、灵活的时间操作，
+ * 可以将字符串形式的日期时间转换为 `Date` 对象，也能将 `Date` 对象转换为指定格式的字符串，以及实现 `Date` 对象与时间戳之间的转换，方便在项目的不同业务场景中对时间相关的数据进行处理和展示。
  */
 public class DateTimeUtil {
-    //joda-time
-
-    //str->Date
-    //Date->str
-    public static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
 
+    // joda-time
+    // 以下是使用Joda-Time库进行时间处理相关的代码，Joda-Time库提供了比Java标准库中 `java.util.Date` 和 `SimpleDateFormat` 更易用、功能更丰富且不易出错的日期时间处理方式，在很多项目中被广泛用于时间相关的操作。
 
+    // str->Date
+    // Date->str
+    // 定义一个静态的字符串常量，用于表示标准的日期时间格式，这里采用了 "yyyy-MM-dd HH:mm:ss" 的格式，即年-月-日 时:分:秒的形式，
+    // 在很多业务场景中，如数据库存储时间、接口传输时间数据等经常会使用这种通用的日期时间格式，方便统一数据格式以及进行不同系统间的交互和数据展示等操作，类型为字符串类型。
+    public static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
 
-    public static Date strToDate(String dateTimeStr, String formatStr){
+    /**
+     * 将指定格式的字符串形式的日期时间转换为 `Date` 对象的方法，通过使用Joda-Time库的相关类和方法来解析字符串并生成对应的 `Date` 对象。
+     *
+     * @param dateTimeStr 要转换的字符串形式的日期时间，其格式需要与传入的 `formatStr` 参数指定的格式一致，例如 "2024-12-18 10:30:00"，类型为字符串类型。
+     * @param formatStr 指定的日期时间字符串的格式，用于告诉解析器按照何种格式来解析输入的字符串，比如 "yyyy-MM-dd HH:mm:ss" 等，类型为字符串类型。
+     * @return 返回解析后的 `Date` 对象，如果字符串格式不符合要求或者解析过程出现问题，可能会抛出异常（由Joda-Time库内部处理），返回的 `Date` 对象可用于后续的日期时间相关操作，如比较、计算等，类型为 `Date`。
+     */
+    public static Date strToDate(String dateTimeStr, String formatStr) {
+        // 根据传入的日期时间格式字符串（`formatStr`）创建一个 `DateTimeFormatter` 对象，它用于定义如何解析输入的日期时间字符串，类似于 `SimpleDateFormat` 在Java标准库中的作用，但功能更强大且更易于使用，是Joda-Time库中进行日期时间格式化和解析的关键类之一。
         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(formatStr);
+        // 使用创建好的 `DateTimeFormatter` 对象的 `parseDateTime` 方法，将输入的日期时间字符串（`dateTimeStr`）解析为一个 `DateTime` 对象，`DateTime` 是Joda-Time库中表示日期时间的核心类，提供了丰富的日期时间操作方法。
         DateTime dateTime = dateTimeFormatter.parseDateTime(dateTimeStr);
+        // 通过 `DateTime` 对象的 `toDate` 方法，将 `DateTime` 对象转换为Java标准库中的 `Date` 对象，这样就完成了从指定格式字符串到 `Date` 对象的转换，方便在Java代码中后续使用标准的 `Date` 相关操作方法进行处理。
         return dateTime.toDate();
     }
 
-    public static String dateToStr(Date date,String formatStr){
-        if(date == null){
+    /**
+     * 将 `Date` 对象转换为指定格式的字符串形式的日期时间的方法，利用Joda-Time库将 `Date` 对象按照给定的格式进行格式化输出。
+     *
+     * @param date 要转换的 `Date` 对象，代表一个具体的日期时间点，例如通过数据库查询获取的时间数据等，类型为 `Date`。
+     * @param formatStr 指定的目标格式字符串，用于控制转换后的字符串的日期时间格式，例如 "yyyy-MM-dd" 可以只输出年-月-日部分，类型为字符串类型。
+     * @return 返回格式化后的字符串形式的日期时间，如果传入的 `date` 参数为 `null`，则返回一个空字符串（通过 `StringUtils.EMPTY` 获取），方便调用者根据返回值进行后续处理，如展示给用户或者进行数据传输等，类型为字符串类型。
+     */
+    public static String dateToStr(Date date, String formatStr) {
+        if (date == null) {
             return StringUtils.EMPTY;
         }
+        // 使用传入的 `Date` 对象创建一个 `DateTime` 对象，以便利用Joda-Time库的功能进行格式化操作，`DateTime` 类提供了更灵活方便的格式化方法来将日期时间转换为指定格式的字符串。
         DateTime dateTime = new DateTime(date);
         return dateTime.toString(formatStr);
     }
 
-    //固定好格式
-    public static Date strToDate(String dateTimeStr){
+    /**
+     * 将字符串形式的日期时间转换为 `Date` 对象的方法，此方法使用了类中定义的标准日期时间格式（`STANDARD_FORMAT`）来解析输入的字符串，
+     * 适用于当日期时间字符串格式固定为 "yyyy-MM-dd HH:mm:ss" 的情况，简化了调用时需要传入格式字符串的操作，方便在项目中大量使用统一格式的日期时间转换场景。
+     *
+     * @param dateTimeStr 要转换的字符串形式的日期时间，其格式需要符合标准的 "yyyy-MM-dd HH:mm:ss" 格式，例如 "2024-12-18 10:30:00"，类型为字符串类型。
+     * @return 返回解析后的 `Date` 对象，如果字符串格式不符合要求或者解析过程出现问题，可能会抛出异常（由Joda-Time库内部处理），类型为 `Date`。
+     */
+    public static Date strToDate(String dateTimeStr) {
         DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(STANDARD_FORMAT);
         DateTime dateTime = dateTimeFormatter.parseDateTime(dateTimeStr);
         return dateTime.toDate();
     }
 
-    public static String dateToStr(Date date){
-        if(date == null){
+    /**
+     * 将 `Date` 对象转换为标准格式（"yyyy-MM-dd HH:mm:ss"）的字符串形式的日期时间的方法，当需要将 `Date` 对象按照统一的标准格式展示或者传输时，可以使用这个方法，
+     * 如果传入的 `Date` 对象为 `null`，则返回一个空字符串，方便在不同业务场景中进行统一的时间数据处理和展示操作。
+     *
+     * @param date 要转换的 `Date` 对象，代表一个具体的日期时间点，类型为 `Date`。
+     * @return 返回格式化后的字符串形式的日期时间，格式为 "yyyy-MM-dd HH:mm:ss"，如果 `date` 参数为 `null`，则返回 `StringUtils.EMPTY`，类型为字符串类型。
+     */
+    public static String dateToStr(Date date) {
+        if (date == null) {
             return StringUtils.EMPTY;
         }
         DateTime dateTime = new DateTime(date);
         return dateTime.toString(STANDARD_FORMAT);
     }
 
-    //Date -> 时间戳
+    /**
+     * 将 `Date` 对象转换为时间戳（从1970年1月1日00:00:00 UTC到指定日期时间的毫秒数）的方法，这里使用了Java标准库中的 `SimpleDateFormat` 来进行格式化和解析操作，
+     * 先将 `Date` 对象格式化为字符串，再将字符串解析为时间戳，注意在使用过程中可能会抛出 `ParseException` 异常，需要调用者进行相应的异常处理，例如在进行数据库存储时间戳数据、与其他系统交互时间戳相关信息等场景中会用到这个方法。
+     *
+     * @param date 要转换为时间戳的 `Date` 对象，代表一个具体的日期时间点，类型为 `Date`。
+     * @return 返回对应的时间戳，为长整型数值，表示从1970年1月1日00:00:00 UTC到传入的 `Date` 对象所代表的日期时间的毫秒数，如果传入的 `date` 参数为 `null`，则返回 `null`，方便调用者根据返回值进行后续处理，类型为 `Long`。
+     * @throws ParseException 可能会抛出的异常，表示在使用 `SimpleDateFormat` 解析字符串过程中出现格式不匹配等解析错误情况，调用者需要捕获并处理这个异常，避免程序因异常而终止运行。
+     */
     public static Long dateToChuo(Date date) throws ParseException {
-        if(date == null){
+        if (date == null) {
             return null;
         }
-        SimpleDateFormat format =   new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
+        // 创建一个 `SimpleDateFormat` 对象，指定日期时间格式为标准的 "yyyy-MM-dd HH:mm:ss"，用于将 `Date` 对象格式化为对应的字符串形式，以便后续解析为时间戳。
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        // 使用 `SimpleDateFormat` 对象的 `parse` 方法，先将 `Date` 对象转换为字符串（通过 `String.valueOf(date)` 获取 `Date` 对象对应的字符串表示），再将这个字符串解析为对应的日期时间，然后通过 `getTime` 方法获取从1970年1月1日00:00:00 UTC到这个日期时间的毫秒数，即时间戳，完成转换操作。
         return format.parse(String.valueOf(date)).getTime();
     }
 
+    /**
+     * 主函数，用于进行简单的测试，在类中直接运行这个方法可以验证时间转换相关方法的功能是否正确，这里示例了将一个指定格式的日期时间字符串解析为 `Date` 对象，然后获取其对应的时间戳并输出，
+     * 不过在实际项目中，这个主函数通常只是用于开发过程中的临时测试，项目部署运行时并不会执行这里的代码，更多是依靠单元测试等方式来全面验证工具类中各个方法的正确性和稳定性。
+     *
+     * @param args 命令行参数，这里在示例中未使用，类型为字符串数组。
+     * @throws ParseException 可能会抛出的异常，因为在主函数中调用了 `dateToChuo` 方法，该方法可能会抛出 `ParseException`，需要在这里进行捕获处理，避免程序因异常而终止运行。
+     */
     public static void main(String[] args) throws ParseException {
-        SimpleDateFormat format =   new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
-        String time="1970-01-06 11:45:55";
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        String time = "1970-01-06 11:45:55";
         Date date = format.parse(time);
-        System.out.print("Format To times:"+date.getTime());
+        System.out.print("Format To times:" + date.getTime());
     }
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/utils/JsonUtil.java

@@ -8,119 +8,168 @@ import org.codehaus.jackson.map.SerializationConfig;
 import org.codehaus.jackson.map.annotate.JsonSerialize;
 import org.codehaus.jackson.type.JavaType;
 import org.codehaus.jackson.type.TypeReference;
-
 import java.io.IOException;
 import java.text.SimpleDateFormat;
 
 /**
  * jackson的序列化和反序列化
+ * 该类主要提供了一系列基于Jackson库的工具方法，用于实现Java对象与JSON字符串之间的序列化（将对象转换为JSON字符串）和反序列化（将JSON字符串转换为对象）操作，
+ * 并且对Jackson库中的ObjectMapper进行了配置，以适应项目中在处理JSON数据时的特定需求，比如统一日期格式、忽略特定的序列化和反序列化错误等情况。
  */
 @Slf4j
+// 使用 @Slf4j注解，通过Lombok库自动为该类生成一个名为log的日志记录器，方便在序列化和反序列化出现问题时记录相关信息，便于后续排查错误和监控数据处理情况。
 public class JsonUtil {
+
+    // 创建一个静态的ObjectMapper对象，ObjectMapper是Jackson库中核心的类，负责处理JSON数据的序列化和反序列化工作，在这里作为整个工具类中进行JSON操作的基础实例，在类加载时就进行初始化，后续所有的序列化和反序列化方法都会使用到它。
     private static ObjectMapper objectMapper = new ObjectMapper();
 
     static {
-        //所有字段都列入进行转换
+        // 以下是在静态代码块中对ObjectMapper对象进行的一系列配置操作，这些配置会影响整个工具类中使用该ObjectMapper进行JSON处理的行为。
+
+        // 所有字段都列入进行转换
+        // 设置序列化时包含所有字段，即不管字段的值是否为null，在将Java对象转换为JSON字符串时都会包含这些字段，通过JsonSerialize.Inclusion.ALWAYS配置来实现，
+        // 这样可以确保JSON数据完整地反映Java对象的结构，避免因某些字段为null而被默认忽略的情况（如果有业务需求要求完整展示对象结构的话）。
         objectMapper.setSerializationInclusion(JsonSerialize.Inclusion.ALWAYS);
-        //取消默认转换timestamp形式
-        objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS,false);
-        //忽略空bean转json的错误
-        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS,false);
-        //统一时间的格式
+
+        // 取消默认转换timestamp形式
+        // 配置序列化时不将日期类型的数据转换为时间戳形式（默认情况下Jackson可能会将Date类型转换为时间戳），而是按照后续设置的日期格式进行转换，
+        // 通过将SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS设置为false来实现，这样可以使得日期在JSON中的表示更符合常见的日期字符串格式，便于阅读和理解，也便于与其他系统进行数据交互时的日期格式统一。
+        objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, false);
+
+        // 忽略空bean转json的错误
+        // 配置在将一个空的Java对象（没有任何属性或者属性值都为null的对象，通常称为空Bean）转换为JSON字符串时忽略可能出现的错误，
+        // 将SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS设置为false，避免因为空对象转换问题导致整个序列化过程失败，提高了程序的健壮性，特别是在某些业务场景下可能会出现临时的空对象需要转换为JSON的情况。
+        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
+
+        // 统一时间的格式
+        // 设置日期格式，通过创建一个SimpleDateFormat对象并指定日期格式为DateTimeUtil.STANDARD_FORMAT（假设DateTimeUtil类中定义了通用的日期时间格式，比如"yyyy-MM-dd HH:mm:ss"），
+        // 然后将这个SimpleDateFormat对象设置给ObjectMapper，使得在序列化和反序列化涉及日期类型数据时，都按照这个统一的格式进行处理，保证了日期数据在JSON中的格式一致性，方便在不同模块间传递和解析时间相关的数据。
         objectMapper.setDateFormat(new SimpleDateFormat(DateTimeUtil.STANDARD_FORMAT));
-        //忽略json存在属性，但是java对象不存在属性的错误
-        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,false);
+
+        // 忽略json存在属性，但是java对象不存在属性的错误
+        // 配置在反序列化（将JSON字符串转换为Java对象）时，忽略JSON数据中存在但Java对象中不存在对应属性的情况，
+        // 将DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES设置为false，避免因为JSON数据结构和Java对象结构不完全匹配而导致反序列化失败，
+        // 这在处理来自不同数据源的JSON数据或者JSON数据结构发生变化但Java对象结构尚未完全同步更新的场景中非常有用，提高了反序列化的兼容性和容错性。
+        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
     }
 
     /**
      * 序列化方法，将对象转为字符串
-     * @param obj
-     * @param <T>
-     * @return
+     * 该方法用于将传入的Java对象转换为JSON字符串。如果传入的对象为null，则直接返回null。
+     * 在转换过程中，如果出现IOException异常（例如对象结构不符合JSON序列化要求等原因导致无法正确转换），会记录警告日志并返回null，
+     * 方便在不同业务场景下将对象数据转换为JSON格式以便进行传输、存储等操作。
+     *
+     * @param obj 要进行序列化的Java对象，其类型可以是任意Java对象，例如自定义的实体类、集合类等，类型为泛型类型<T>。
+     * @param <T> 泛型标识，用于表示传入对象的类型以及返回的JSON字符串对应的Java对象类型，在调用这个方法时，Java编译器会根据实际传入的对象类型来确定具体的<T>类型，保证类型的一致性和安全性。
+     * @return 返回转换后的JSON字符串，如果对象为null或者转换过程出现异常，则返回null，方便调用者根据返回值判断是否成功进行了序列化操作并进行后续处理，如将JSON字符串发送给前端或者存储到缓存等，类型为字符串类型。
      */
-    public static <T> String obj2String(T obj){
-        if(obj == null){
+    public static <T> String obj2String(T obj) {
+        if (obj == null) {
             return null;
         }
         try {
-            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
+            // 判断传入的对象是否本身就是字符串类型，如果是，则直接返回该字符串（不需要进行JSON序列化操作），
+            // 否则使用ObjectMapper的writeValueAsString方法将对象转换为JSON字符串并返回。
+            return obj instanceof String? (String) obj : objectMapper.writeValueAsString(obj);
         } catch (IOException e) {
-            log.warn("parse object to string error",e);
+            // 如果在序列化过程中出现IOException（例如对象中有无法序列化的属性、循环引用等问题），使用日志记录器记录警告信息，
+            // 包含简单的错误描述以及异常对象本身，方便后续排查问题，同时返回null表示序列化失败，日志级别为WARN，表示出现了可继续运行但可能需要关注的情况。
+            log.warn("parse object to string error", e);
             return null;
         }
     }
 
     /**
      * 序列化方法，同上，只是输出的格式是美化的，便于测试
-     * @param obj
-     * @param <T>
-     * @return
+     * 这个方法与obj2String方法功能类似，也是将Java对象转换为JSON字符串，但不同的是它会输出美化后的JSON字符串（格式更清晰，有缩进等格式排版），
+     * 方便在开发测试阶段查看JSON数据结构，同样如果对象为null或者转换过程出现异常，会返回null。
+     *
+     * @param obj 要进行序列化的Java对象，类型为泛型类型<T>，其具体类型可以是任意Java对象，同obj2String方法中的参数含义。
+     * @param <T> 泛型标识，用于表示对象类型以及返回的JSON字符串对应的Java对象类型，具体作用与obj2String方法中的<T>一致，保证类型一致性和安全性。
+     * @return 返回美化后的JSON字符串，如果对象为null或者转换过程出现异常，则返回null，类型为字符串类型，可用于在测试环境中展示给开发人员查看详细的JSON数据结构等情况。
      */
-    public static <T> String obj2StringPretty(T obj){
-        if(obj == null){
+    public static <T> String obj2StringPretty(T obj) {
+        if (obj == null) {
             return null;
         }
         try {
-            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
+            // 判断传入的对象是否为字符串类型，如果是则直接返回该字符串，否则使用ObjectMapper的writerWithDefaultPrettyPrinter方法获取一个能够生成美化格式JSON字符串的写入器，
+            // 再通过这个写入器的writeValueAsString方法将对象转换为美化后的JSON字符串并返回。
+            return obj instanceof String? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
         } catch (IOException e) {
-            log.warn("parse object to string error",e);
+            log.warn("parse object to string error", e);
             return null;
         }
     }
 
     /**
      * 比较简单的反序列化的方法，将字符串转为单个对象
-     * @param str
-     * @param clazz
-     * @param <T>
-     * @return
+     * 这个方法用于将JSON字符串反序列化为指定类型的Java对象，适用于简单的单个对象的反序列化情况，例如将一个表示用户信息的JSON字符串转换为对应的User类对象等。
+     * 如果传入的字符串为空或者指定的Java类对象类型为null，则直接返回null。
+     * 在反序列化过程中，如果出现IOException（比如JSON格式不符合要求、缺少必要属性等原因导致无法正确解析），会记录警告日志并返回null。
+     *
+     * @param str 要进行反序列化的JSON字符串，其格式需要符合Jackson库能够解析的JSON格式要求，并且与要转换的Java对象结构尽量匹配（根据配置可能会忽略部分属性不匹配情况），类型为字符串类型。
+     * @param clazz 要反序列化生成的Java对象的类型，通过传入具体的类对象（例如User.class）来指定目标对象类型，Jackson会根据这个类型信息将JSON字符串解析并构造出对应的Java对象，类型为Class<T>，表示一个具体的Java类类型，其中<T>是泛型标识，与方法返回的对象类型相关联，保证类型的一致性。
+     * @param <T> 泛型标识，用于表示返回的Java对象类型，与传入的clazz参数指定的类类型相对应，确保反序列化后得到的对象类型符合预期，方便在不同业务场景下将JSON数据转换为具体的Java对象进行后续业务处理，如存入数据库、在业务逻辑中使用等，类型为泛型类型<T>。
+     * @return 返回反序列化后的Java对象，如果传入的字符串为空、指定的类类型为null或者反序列化过程出现异常，则返回null，类型为<T>，即与传入的clazz参数指定的类类型一致的Java对象类型，方便调用者根据返回值进行后续操作，如调用对象的方法、获取对象的属性等。
      */
-    public static <T> T String2Obj(String str,Class<T> clazz){
-        if(StringUtils.isEmpty(str) || clazz == null){
+    public static <T> T String2Obj(String str, Class<T> clazz) {
+        if (StringUtils.isEmpty(str) || clazz == null) {
             return null;
         }
         try {
-            return clazz.equals(String.class)?(T)str:objectMapper.readValue(str,clazz);
+            // 判断传入的clazz参数指定的类是否就是String类，如果是，表示要将JSON字符串直接转换为String类型的对象（其实就是返回原字符串本身），
+            // 否则使用ObjectMapper的readValue方法，根据传入的JSON字符串str和指定的类类型clazz将JSON数据解析为对应的Java对象并返回。
+            return clazz.equals(String.class)? (T) str : objectMapper.readValue(str, clazz);
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
 
     /**
      * 复杂对象的反序列化（通用）
-     * @param str
-     * @param typeReference
-     * @param <T>
-     * @return
+     * 这个方法用于处理更复杂的反序列化情况，通过使用TypeReference来指定复杂的目标对象类型（例如包含泛型的集合类型、嵌套的自定义对象类型等），
+     * 可以更灵活地将JSON字符串转换为相应的复杂Java对象，同样如果传入的字符串为空或者指定的TypeReference为null，则返回null，反序列化出现异常时会记录警告日志并返回null。
+     *
+     * @param str 要进行反序列化的JSON字符串，格式需要符合Jackson库的解析要求并且与要转换的复杂对象结构相适配（根据配置可忽略部分不匹配情况），类型为字符串类型。
+     * @param typeReference 用于指定复杂对象类型的TypeReference对象，通过创建TypeReference的匿名子类或者使用已有的具体子类来准确描述要反序列化生成的复杂对象的类型结构，
+     * 例如new TypeReference<List<User>>() {}可以表示要将JSON字符串转换为List<User>类型的对象，类型为TypeReference。
+     * @param <T> 泛型标识，用于表示返回的复杂Java对象的类型，与传入的typeReference指定的类型一致，方便在不同业务场景下将JSON数据转换为符合业务需求的复杂对象进行后续处理，如在业务逻辑中遍历集合、操作嵌套对象等，类型为泛型类型<T>。
+     * @return 返回反序列化后的复杂Java对象，如果传入的字符串为空、指定的TypeReference为null或者反序列化过程出现异常，则返回null，类型为<T>，即与typeReference指定的复杂对象类型一致的Java对象类型，方便调用者根据返回值进行后续操作，如对集合进行添加元素、调用嵌套对象的方法等。
      */
-    public static <T> T Str2Obj(String str, TypeReference typeReference){
-        if(StringUtils.isEmpty(str) || typeReference == null){
+    public static <T> T Str2Obj(String str, TypeReference typeReference) {
+        if (StringUtils.isEmpty(str) || typeReference == null) {
             return null;
         }
         try {
-            return (T) (typeReference.getType().equals(String.class)?str:objectMapper.readValue(str,typeReference));
+            // 判断传入的typeReference指定的类型是否就是String类，如果是，表示要将JSON字符串直接作为String类型返回（其实就是原字符串本身），
+            // 否则使用ObjectMapper的readValue方法，根据传入的JSON字符串str和typeReference指定的复杂对象类型将JSON数据解析为对应的Java对象并返回。
+            return (T) (typeReference.getType().equals(String.class)? str : objectMapper.readValue(str, typeReference));
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
 
     /**
      * 第二种方式实现复杂对象的反序列化
-     * @param str
-     * @param collectionClass
-     * @param elementClasses
-     * @param <T>
-     * @return
+     * 这个方法也是用于处理复杂对象的反序列化情况，通过传入表示集合类型的类对象以及集合中元素类型的类对象等参数，利用ObjectMapper的类型工厂来构造出具体的JavaType，
+     * 进而将JSON字符串转换为对应的复杂对象（通常是各种泛型集合类型等情况），同样在传入参数不符合要求或者反序列化出现异常时会返回null。
+     *
+     * @param str 要进行反序列化的JSON字符串，其格式要符合Jackson库的解析要求并且与要转换的复杂对象结构相适配，类型为字符串类型。
+     * @param collectionClass 表示集合类型的类对象，例如List.class、Set.class等，用于指定要反序列化生成的复杂对象的外层集合类型，类型为Class<?>，表示一个不确定具体元素类型的类类型，这里的?表示通配符，因为只关注集合类型本身，暂不确定其元素类型。
+     * @param elementClasses 可变参数，表示集合中元素类型的类对象，例如对于List<User>类型，这里就传入User.class，可以传入多个类对象来表示嵌套的多层集合结构中各层的元素类型，类型为Class<?>数组，即每个元素都是一个类类型对象，方便描述复杂的对象类型结构，类型为Class<?>...。
+     * @param <T> 泛型标识，用于表示返回的复杂Java对象的类型，与根据传入的collectionClass和elementClasses参数构造出的复杂对象类型一致，方便在不同业务场景下将JSON数据转换为符合业务需求的复杂对象进行后续处理，类型为泛型类型<T>。
+     * @return 返回反序列化后的复杂Java对象，如果传入的字符串为空、传入的类对象参数不符合要求或者反序列化过程出现异常，则返回null，类型为<T>，即与根据参数构造出的复杂对象类型一致的Java对象类型，方便调用者根据返回值进行后续操作，如对集合进行遍历、操作集合元素等。
      */
-    public static <T> T Str2Obj(String str,Class<?> collectionClass,Class<?>... elementClasses){
-        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass,elementClasses);
+    public static <T> T Str2Obj(String str, Class<?> collectionClass, Class<?>... elementClasses) {
+        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
         try {
-            return objectMapper.readValue(str,javaType);
+            return objectMapper.readValue(str, javaType);
         } catch (IOException e) {
-            log.warn("parse string to obj error",e);
+            log.warn("parse string to obj error", e);
             return null;
         }
     }
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/utils/MD5Util.java

@@ -4,56 +4,102 @@ import java.security.MessageDigest;
 
 /**
  * MD5加密工具类
+ * 这个类（MD5Util）主要用于实现对输入字符串进行MD5加密的功能，提供了相应的方法来将给定的字符串按照MD5算法转换为加密后的十六进制字符串表示形式，
+ * 并且支持指定字符编码（如UTF-8）进行加密操作，同时还预留了加盐（一种增强加密安全性的手段，不过当前代码示例中未完整实现加盐功能）的位置，方便在项目中对敏感信息（如用户密码等）进行加密处理，保障数据的安全性。
  */
 public class MD5Util {
+
+    /**
+     * 将字节数组转换为十六进制字符串的方法，通过遍历字节数组，逐个将字节转换为对应的十六进制表示形式，并拼接起来形成最终的十六进制字符串。
+     *
+     * @param b 要转换的字节数组，通常是经过MD5加密算法处理后得到的字节数组，例如通过MessageDigest的digest方法获取到的结果，类型为字节数组类型（byte[]）。
+     * @return 返回转换后的十六进制字符串，这个字符串就是字节数组对应的十六进制表示形式，可用于后续作为加密后的最终结果展示或者进一步处理等，类型为字符串类型。
+     */
     private static String byteArrayToHexString(byte b[]) {
+        // 创建一个StringBuffer对象，用于高效地拼接字符串，避免频繁创建新的字符串对象，提高性能，后续将逐个字节转换后的十六进制字符依次添加到这个StringBuffer中。
         StringBuffer resultSb = new StringBuffer();
+        // 遍历传入的字节数组，对每个字节调用byteToHexString方法进行十六进制转换，并将转换后的结果添加到StringBuffer中。
         for (int i = 0; i < b.length; i++)
             resultSb.append(byteToHexString(b[i]));
 
+        // 将StringBuffer中的内容转换为字符串并返回，这个字符串就是字节数组对应的十六进制表示形式。
         return resultSb.toString();
     }
 
+    /**
+     * 将单个字节转换为十六进制字符串的方法，先对字节进行处理（如果是负数则转换为正数范围），然后将其拆分为高4位和低4位，分别对应十六进制的一个数位，通过查找预定义的十六进制字符数组获取对应的十六进制字符，并拼接起来形成十六进制表示形式。
+     *
+     * @param b 要转换的单个字节，其值范围在 -128 到 127 之间，类型为字节类型（byte）。
+     * @return 返回该字节对应的十六进制字符串表示形式，长度为2，例如将字节值为10转换为十六进制的 "0a"，类型为字符串类型。
+     */
     private static String byteToHexString(byte b) {
+        // 将传入的字节转换为整数类型，方便后续进行位运算等操作，由于字节类型在Java中是有符号的，其范围是 -128 到 127，所以转换后的整数可能是负数。
         int n = b;
+        // 如果转换后的整数是负数，通过加上256将其转换为正数范围（0 到 255），这是因为十六进制表示时是基于无符号数的范围进行处理的，确保后续计算能正确对应十六进制值。
         if (n < 0)
             n += 256;
+        // 获取字节转换后的整数的高4位（相当于除以16取整），用于对应十六进制的高位数字，例如对于字节值为20（十六进制为 14），这里得到的就是1。
         int d1 = n / 16;
+        // 获取字节转换后的整数的低4位（相当于除以16取余），用于对应十六进制的低位数字，对于上面的例子，这里得到的就是4。
         int d2 = n % 16;
+        // 通过查找预定义的十六进制字符数组（hexDigits），获取对应高4位和低4位的十六进制字符，并将它们拼接起来返回，例如对于上面的例子，会返回 "14"，也就是十六进制表示形式。
         return hexDigits[d1] + hexDigits[d2];
     }
 
     /**
      * 返回大写MD5
+     * 这个私有方法是实现MD5加密的核心方法，它接收一个原始字符串和字符编码名称作为参数，先获取MD5算法实例，然后根据是否指定字符编码，对原始字符串进行字节编码转换后，使用MD5算法进行加密处理，
+     * 最后将加密后的字节数组转换为十六进制字符串并返回，返回的结果是大写形式的十六进制字符串表示的MD5加密值，在加密过程中如果出现异常（例如不支持的字符编码等情况），当前只是简单地返回 `null`（不过在实际应用中可能需要更完善的异常处理机制）。
      *
-     * @param origin
-     * @param charsetname
-     * @return
+     * @param origin 要进行MD5加密的原始字符串，例如用户输入的密码等敏感信息，类型为字符串类型。
+     * @param charsetname 指定的字符编码名称，用于将原始字符串转换为字节数组时使用的编码方式，如果为 `null` 或者空字符串，则使用平台默认编码，类型为字符串类型。
+     * @return 返回经过MD5加密后的大写十六进制字符串表示形式，如果加密过程出现异常则返回 `null`，类型为字符串类型。
      */
     private static String MD5Encode(String origin, String charsetname) {
+        // 先初始化一个变量，用于存储最终的加密结果字符串，初始值设置为原始字符串本身，后续会根据加密操作进行更新。
         String resultString = null;
         try {
             resultString = new String(origin);
+            // 获取MD5算法的MessageDigest实例，用于执行MD5加密操作，通过传入算法名称 "MD5" 调用MessageDigest的getInstance方法来获取，如果不支持指定的算法会抛出异常。
             MessageDigest md = MessageDigest.getInstance("MD5");
+            // 判断传入的字符编码名称是否为 `null` 或者空字符串，如果是，则使用默认编码方式将原始字符串转换为字节数组后进行MD5加密，否则使用指定的字符编码将原始字符串转换为字节数组再进行加密操作。
             if (charsetname == null || "".equals(charsetname))
                 resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
             else
                 resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
         } catch (Exception exception) {
+            // 当前代码只是简单地捕获了可能出现的异常（例如获取MD5算法实例失败、字符编码不支持等异常情况），但没有做进一步的处理，在实际应用中应该根据具体业务需求完善异常处理逻辑，比如记录日志、返回特定的错误提示等。
         }
+        // 将最终得到的加密结果字符串转换为大写形式并返回，MD5加密结果通常以十六进制字符串表示，大写形式方便统一格式展示以及后续的比较等操作（例如与存储在数据库中的加密后的密码进行比对验证等情况）。
         return resultString.toUpperCase();
     }
 
+    /**
+     * 使用UTF-8编码进行MD5加密的方法，它调用了MD5Encode方法，并指定字符编码为 "utf-8"，实现对传入的原始字符串按照UTF-8编码进行MD5加密，
+     * 这里可以在合适的位置添加加盐操作（通过在原始字符串中添加特定的盐值后再进行加密，盐值通常是一个固定的字符串或者根据一定规则生成的字符串，用于增加加密的安全性，防止彩虹表攻击等），不过当前代码示例中没有完整实现加盐功能，只是简单地进行了MD5加密并返回结果。
+     *
+     * @param origin 要进行MD5加密的原始字符串，类型为字符串类型，例如需要加密的用户密码等信息。
+     * @return 返回经过UTF-8编码的MD5加密后的大写十六进制字符串表示形式，类型为字符串类型，可用于后续存储加密后的敏感信息、验证密码等业务场景。
+     */
     public static String MD5EncodeUtf8(String origin) {
-        //这里可以加盐
+        // 这里可以加盐，例如可以在origin字符串前后添加特定的盐值字符串后再进行加密，不过当前只是简单调用MD5Encode方法进行常规的MD5加密，没有实际添加盐值操作。
         return MD5Encode(origin, "utf-8");
     }
 
+    /**
+     * 主函数，用于进行简单的测试，在类中直接运行这个方法可以验证MD5加密功能是否正确，这里示例了对字符串 "123456" 进行MD5加密，并将加密后的结果输出到控制台，
+     * 不过在实际项目中，这个主函数通常只是用于开发过程中的临时测试，项目部署运行时并不会执行这里的代码，更多是依靠单元测试等方式来全面验证工具类中各个方法的正确性和稳定性。
+     *
+     * @param args 命令行参数，这里在示例中未使用，类型为字符串数组。
+     */
     public static void main(String[] args) {
         System.out.println(MD5EncodeUtf8("123456"));
     }
 
-
+    /**
+     * 预定义的十六进制字符数组，用于在将字节转换为十六进制字符串时，根据字节的数值查找对应的十六进制字符，例如字节值为0对应字符 "0"，字节值为10对应字符 "a" 等，
+     * 通过这个数组可以方便地实现字节到十六进制字符串的转换操作，是整个MD5加密过程中将加密后的字节数组转换为十六进制表示形式的关键辅助数据结构。
+     */
     private static final String hexDigits[] = {"0", "1", "2", "3", "4", "5",
             "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
-}
+}

snailmall-user-service/src/main/java/com/njupt/swg/common/utils/ZkClient.java

@@ -13,22 +13,43 @@ import org.springframework.stereotype.Component;
  * @Date 2019/1/1 17:57
  * @CONTACT 317758022@qq.com
  * @DESC zk的curator客户端
+ * 这个类（ZkClient）主要用于创建和配置一个Apache Curator框架下的ZooKeeper客户端实例，通过依赖注入获取相关配置参数（从 `Parameters` 类中获取ZooKeeper服务器的连接信息等），
+ * 利用CuratorFrameworkFactory来构建客户端，并设置连接超时时间、重试策略等重要属性，最后启动客户端，以便在项目中与ZooKeeper进行交互，实现诸如配置管理、服务发现等基于ZooKeeper的功能。
  */
 @Component
+// 使用Spring的@Component注解将这个类标记为一个组件，意味着Spring容器在扫描到这个类时会将其纳入管理范围，能够进行依赖注入等操作，方便在项目的其他地方使用这个类创建的ZooKeeper客户端实例。
 public class ZkClient {
+
     @Autowired
+    // 通过Spring的 @Autowired注解进行依赖注入，将 `Parameters` 类的实例注入到当前类中，`Parameters` 类应该是用于存储项目相关配置参数的，在这里主要是获取ZooKeeper服务器的连接字符串等配置信息，以便后续构建ZooKeeper客户端时使用。
     private Parameters parameters;
 
+    /**
+     * @Bean注解用于将这个方法返回的对象作为一个Spring管理的Bean实例，在Spring容器启动时会调用这个方法创建并注册一个CuratorFramework类型的Bean，
+     * 这个Bean就是配置好的ZooKeeper客户端实例，其他需要使用ZooKeeper客户端的地方（比如在服务注册与发现的相关业务逻辑中）可以通过依赖注入获取这个Bean来与ZooKeeper进行交互操作。
+     *
+     * @return 返回创建并配置好的CuratorFramework类型的ZooKeeper客户端实例，该实例已经设置好了连接字符串、连接超时时间以及重试策略等关键属性，并且已经启动，可以直接用于与ZooKeeper服务器进行通信，类型为CuratorFramework。
+     */
     @Bean
-    public CuratorFramework getZkClient(){
+    public CuratorFramework getZkClient() {
 
-        CuratorFrameworkFactory.Builder builder= CuratorFrameworkFactory.builder()
+        // 使用CuratorFrameworkFactory的builder方法创建一个构建器对象，用于构建CuratorFramework类型的ZooKeeper客户端实例，通过链式调用的方式可以方便地设置各种客户端的配置属性。
+        CuratorFrameworkFactory.Builder builder = CuratorFrameworkFactory.builder()
+                // 通过调用connectString方法设置ZooKeeper服务器的连接字符串，这个连接字符串的值从注入的 `Parameters` 类实例中获取（通过调用 `parameters.getZkHost()` 方法），
+                // 连接字符串通常格式类似 "ip1:port1,ip2:port2,..."，用于指定要连接的ZooKeeper服务器节点的地址和端口信息，确保客户端能够准确连接到ZooKeeper集群。
                 .connectString(parameters.getZkHost())
+                // 设置连接超时时间为3000毫秒（3秒），通过调用connectionTimeoutMs方法进行设置，意味着客户端在尝试连接ZooKeeper服务器时，如果在3秒内无法建立连接，将会判定连接超时并可能触发相应的异常处理或者重试逻辑，
+                // 根据业务需求合理设置连接超时时间很重要，避免长时间等待连接导致程序响应缓慢等问题。
                 .connectionTimeoutMs(3000)
+                // 设置重试策略，这里使用了 `RetryNTimes` 重试策略，它表示客户端在连接ZooKeeper服务器出现失败时，会进行最多5次重试，每次重试间隔10毫秒，通过创建 `RetryNTimes` 实例并传入重试次数和重试间隔时间参数来配置，
+                // 合理的重试策略有助于提高客户端在面对网络波动等临时连接问题时的健壮性，确保能够成功连接到ZooKeeper服务器并进行后续操作。
                 .retryPolicy(new RetryNTimes(5, 10));
+
+        // 通过构建器对象的build方法构建出最终的CuratorFramework类型的ZooKeeper客户端实例，此时客户端实例已经根据前面设置的配置属性进行了相应的初始化，但还未启动。
         CuratorFramework framework = builder.build();
+        // 调用客户端实例的start方法启动ZooKeeper客户端，启动后客户端就可以与ZooKeeper服务器进行通信，例如发送请求获取节点数据、创建或删除节点等操作，完成整个客户端的创建和启动流程，最后返回这个启动好的客户端实例。
         framework.start();
         return framework;
 
     }
-}
+}