营销模块中退款保证

mall-mbg/src/main/java/com/macro/mall/model/CmsSubjectProductRelation.java

@@ -38,15 +38,35 @@ public class CmsSubjectProductRelation implements Serializable {
 
     @Override
     public String toString() {
+        // 创建一个StringBuilder对象，用于构建字符串
         StringBuilder sb = new StringBuilder();
+
+        // 获取当前类的简单名称并追加到StringBuilder中
         sb.append(getClass().getSimpleName());
+
+        // 追加一个左方括号
         sb.append(" [");
+
+        // 追加当前对象的哈希码
         sb.append("Hash = ").append(hashCode());
+
+        // 追加id字段的值
         sb.append(", id=").append(id);
+
+        // 追加subjectId字段的值
         sb.append(", subjectId=").append(subjectId);
+
+        // 追加productId字段的值
         sb.append(", productId=").append(productId);
+
+        // 追加serialVersionUID字段的值
         sb.append(", serialVersionUID=").append(serialVersionUID);
+
+        // 追加右方括号
         sb.append("]");
+
+        // 将StringBuilder转换为字符串并返回
         return sb.toString();
     }
+
 }

mall-mbg/src/main/java/com/macro/mall/model/CmsSubjectProductRelationExample.java

@@ -4,46 +4,58 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CmsSubjectProductRelationExample {
+    // 定义排序子句
     protected String orderByClause;
 
+    // 是否使用 DISTINCT 关键字
     protected boolean distinct;
 
+    // 存储查询条件的列表
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化查询条件列表
     public CmsSubjectProductRelationExample() {
         oredCriteria = new ArrayList<>();
     }
 
+    // 设置排序子句
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序子句
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否使用 DISTINCT 关键字
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 判断是否使用 DISTINCT 关键字
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件列表
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加一个查询条件到列表中
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建一个新的 Criteria 对象并添加到查询条件列表中
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建一个 Criteria 对象，如果查询条件列表为空则添加到列表中
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -52,37 +64,46 @@ public class CmsSubjectProductRelationExample {
         return criteria;
     }
 
+    // 内部方法，用于创建一个新的 Criteria 对象
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清除所有查询条件和排序子句，重置状态
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+
     protected abstract static class GeneratedCriteria {
+        // 定义一个列表来存储所有的查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria列表
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<>();
         }
 
+        // 检查是否有任何查询条件
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件的副本
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加一个简单的查询条件（没有值）
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -90,6 +111,7 @@ public class CmsSubjectProductRelationExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加一个带值的查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -97,6 +119,7 @@ public class CmsSubjectProductRelationExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加一个范围查询条件（两个值）
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -104,6 +127,7 @@ public class CmsSubjectProductRelationExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 以下方法用于生成具体的查询条件，例如id是否为空、id等于某个值等
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
@@ -164,6 +188,7 @@ public class CmsSubjectProductRelationExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成subject_id相关的查询条件
         public Criteria andSubjectIdIsNull() {
             addCriterion("subject_id is null");
             return (Criteria) this;
@@ -224,6 +249,7 @@ public class CmsSubjectProductRelationExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成product_id相关的查询条件
         public Criteria andProductIdIsNull() {
             addCriterion("product_id is null");
             return (Criteria) this;
@@ -239,141 +265,160 @@ public class CmsSubjectProductRelationExample {
             return (Criteria) this;
         }
 
+
+        // 检查 product_id 是否不等于指定的值
         public Criteria andProductIdNotEqualTo(Long value) {
             addCriterion("product_id <>", value, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否大于指定的值
         public Criteria andProductIdGreaterThan(Long value) {
             addCriterion("product_id >", value, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否大于或等于指定的值
         public Criteria andProductIdGreaterThanOrEqualTo(Long value) {
             addCriterion("product_id >=", value, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否小于指定的值
         public Criteria andProductIdLessThan(Long value) {
             addCriterion("product_id <", value, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否小于或等于指定的值
         public Criteria andProductIdLessThanOrEqualTo(Long value) {
             addCriterion("product_id <=", value, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否在指定的值列表中
         public Criteria andProductIdIn(List<Long> values) {
             addCriterion("product_id in", values, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否不在指定的值列表中
         public Criteria andProductIdNotIn(List<Long> values) {
             addCriterion("product_id not in", values, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否在指定的两个值之间（包含边界）
         public Criteria andProductIdBetween(Long value1, Long value2) {
             addCriterion("product_id between", value1, value2, "productId");
             return (Criteria) this;
         }
 
+        // 检查 product_id 是否不在指定的两个值之间（不包含边界）
         public Criteria andProductIdNotBetween(Long value1, Long value2) {
             addCriterion("product_id not between", value1, value2, "productId");
             return (Criteria) this;
         }
+
     }
 
     public static class Criteria extends GeneratedCriteria {
+        // 默认构造函数，调用父类的构造函数
         protected Criteria() {
             super();
         }
     }
 
     public static class Criterion {
-        private String condition;
+        private String condition; // 查询条件
-
+        private Object value; // 查询条件的值
-        private Object value;
+        private Object secondValue; // 第二个值，用于between查询
-
+        private boolean noValue; // 是否没有值
-        private Object secondValue;
+        private boolean singleValue; // 是否是单一值
-
+        private boolean betweenValue; // 是否是区间值
-        private boolean noValue;
+        private boolean listValue; // 是否是列表值
-
+        private String typeHandler; // 类型处理器
-        private boolean singleValue;
+
-
+        // 获取查询条件
-        private boolean betweenValue;
-
-        private boolean listValue;
-
-        private String typeHandler;
-
         public String getCondition() {
             return condition;
         }
 
+        // 获取查询条件的值
         public Object getValue() {
             return value;
         }
 
+        // 获取第二个值
         public Object getSecondValue() {
             return secondValue;
         }
 
+        // 判断是否没有值
         public boolean isNoValue() {
             return noValue;
         }
 
+        // 判断是否是单一值
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        // 判断是否是区间值
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断是否是列表值
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取类型处理器
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，仅包含条件
         protected Criterion(String condition) {
-            super();
+            super(); // 调用父类的构造函数
-            this.condition = condition;
+            this.condition = condition; // 设置条件
-            this.typeHandler = null;
+            this.typeHandler = null; // 初始化类型处理器为空
-            this.noValue = true;
+            this.noValue = true; // 标记没有值
         }
 
+        // 构造函数，包含条件和值（带类型处理器）
         protected Criterion(String condition, Object value, String typeHandler) {
-            super();
+            super(); // 调用父类的构造函数
-            this.condition = condition;
+            this.condition = condition; // 设置条件
-            this.value = value;
+            this.value = value; // 设置值
-            this.typeHandler = typeHandler;
+            this.typeHandler = typeHandler; // 设置类型处理器
-            if (value instanceof List<?>) {
+            if (value instanceof List<?>) { // 如果值是列表类型
-                this.listValue = true;
+                this.listValue = true; // 标记为列表值
             } else {
-                this.singleValue = true;
+                this.singleValue = true; // 否则标记为单一值
             }
         }
 
+        // 构造函数，包含条件和值（无类型处理器）
         protected Criterion(String condition, Object value) {
-            this(condition, value, null);
+            this(condition, value, null); // 调用另一个构造函数，并传递 null 作为类型处理器
         }
 
+        // 构造函数，包含条件、值和第二个值（带类型处理器）
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
-            super();
+            super(); // 调用父类的构造函数
-            this.condition = condition;
+            this.condition = condition; // 设置条件
-            this.value = value;
+            this.value = value; // 设置第一个值
-            this.secondValue = secondValue;
+            this.secondValue = secondValue; // 设置第二个值
-            this.typeHandler = typeHandler;
+            this.typeHandler = typeHandler; // 设置类型处理器
-            this.betweenValue = true;
+            this.betweenValue = true; // 标记为区间值
         }
 
+        // 构造函数，包含条件、值和第二个值（无类型处理器）
         protected Criterion(String condition, Object value, Object secondValue) {
-            this(condition, value, secondValue, null);
+            this(condition, value, secondValue, null); // 调用另一个构造函数，并传递 null 作为类型处理器
         }
     }
+
 }

mall-mbg/src/main/java/com/macro/mall/model/CmsTopic.java

@@ -4,38 +4,42 @@ import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 import java.util.Date;
 
+/**
+ * 话题模型类，用于表示一个话题的详细信息。
+ */
 public class CmsTopic implements Serializable {
-    private Long id;
+    private Long id; // 话题的唯一标识符
 
-    private Long categoryId;
+    private Long categoryId; // 话题所属分类的ID
 
-    private String name;
+    private String name; // 话题的名称
 
-    private Date createTime;
+    private Date createTime; // 话题的创建时间
 
-    private Date startTime;
+    private Date startTime; // 话题的开始时间
 
-    private Date endTime;
+    private Date endTime; // 话题的结束时间
 
     @ApiModelProperty(value = "参与人数")
-    private Integer attendCount;
+    private Integer attendCount; // 参与该话题的人数
 
     @ApiModelProperty(value = "关注人数")
-    private Integer attentionCount;
+    private Integer attentionCount; // 关注该话题的人数
 
-    private Integer readCount;
+    private Integer readCount; // 阅读该话题的次数
 
     @ApiModelProperty(value = "奖品名称")
-    private String awardName;
+    private String awardName; // 与该话题相关的奖品名称
 
     @ApiModelProperty(value = "参与方式")
-    private String attendType;
+    private String attendType; // 参与该话题的方式
 
     @ApiModelProperty(value = "话题内容")
-    private String content;
+    private String content; // 话题的具体内容
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // 序列化版本号
 
+    // Getter和Setter方法
     public Long getId() {
         return id;
     }

mall-mbg/src/main/java/com/macro/mall/model/CmsTopicCategory.java

@@ -3,23 +3,27 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * CmsTopicCategory 类表示专题分类的实体。
+ */
 public class CmsTopicCategory implements Serializable {
-    private Long id;
+    private Long id; // 分类的唯一标识符
 
-    private String name;
+    private String name; // 分类的名称
 
     @ApiModelProperty(value = "分类图标")
-    private String icon;
+    private String icon; // 分类的图标URL
 
     @ApiModelProperty(value = "专题数量")
-    private Integer subjectCount;
+    private Integer subjectCount; // 该分类下的专题数量
 
-    private Integer showStatus;
+    private Integer showStatus; // 显示状态（0：不显示，1：显示）
 
-    private Integer sort;
+    private Integer sort; // 排序字段
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // 序列化版本号
 
+    // Getter和Setter方法
     public Long getId() {
         return id;
     }

mall-mbg/src/main/java/com/macro/mall/model/CmsTopicCategoryExample.java

@@ -4,46 +4,58 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CmsTopicCategoryExample {
+    // 定义一个用于排序的子句
     protected String orderByClause;
 
+    // 定义一个布尔值，用于指示查询结果是否去重
     protected boolean distinct;
 
+    // 定义一个列表，用于存储查询条件（Criteria）
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria为一个新的ArrayList
     public CmsTopicCategoryExample() {
         oredCriteria = new ArrayList<>();
     }
 
+    // 设置排序子句的方法
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序子句的方法
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重的方法
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重的方法
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件列表的方法
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加一个查询条件到oredCriteria列表中的方法
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建一个新的Criteria对象并添加到oredCriteria列表中的方法
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建一个Criteria对象，如果oredCriteria列表为空则将其添加到列表中的方法
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -52,37 +64,46 @@ public class CmsTopicCategoryExample {
         return criteria;
     }
 
+    // 内部方法，用于创建一个新的Criteria对象
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清除所有查询条件和排序子句，并将distinct设置为false的方法
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+
     protected abstract static class GeneratedCriteria {
+        // 定义一个列表来存储所有的查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria列表
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<>();
         }
 
+        // 判断是否有有效的查询条件
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取当前查询条件列表
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加一个简单的查询条件（例如 "id is null"）
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -90,6 +111,7 @@ public class CmsTopicCategoryExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加一个带值的查询条件（例如 "id = 1"）
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -97,6 +119,7 @@ public class CmsTopicCategoryExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加一个范围查询条件（例如 "id between 1 and 10"）
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -104,6 +127,8 @@ public class CmsTopicCategoryExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+// 以下方法用于生成具体的查询条件，并返回当前的Criteria对象以支持链式调用
+
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
@@ -239,307 +264,362 @@ public class CmsTopicCategoryExample {
             return (Criteria) this;
         }
 
+
+        // 检查icon字段是否不为空
         public Criteria andIconIsNotNull() {
             addCriterion("icon is not null");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否等于指定值
         public Criteria andIconEqualTo(String value) {
             addCriterion("icon =", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否不等于指定值
         public Criteria andIconNotEqualTo(String value) {
             addCriterion("icon <>", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否大于指定值
         public Criteria andIconGreaterThan(String value) {
             addCriterion("icon >", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否大于或等于指定值
         public Criteria andIconGreaterThanOrEqualTo(String value) {
             addCriterion("icon >=", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否小于指定值
         public Criteria andIconLessThan(String value) {
             addCriterion("icon <", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否小于或等于指定值
         public Criteria andIconLessThanOrEqualTo(String value) {
             addCriterion("icon <=", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否匹配指定模式（使用LIKE）
         public Criteria andIconLike(String value) {
             addCriterion("icon like", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否不匹配指定模式（使用NOT LIKE）
         public Criteria andIconNotLike(String value) {
             addCriterion("icon not like", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否在指定的值列表中
         public Criteria andIconIn(List<String> values) {
             addCriterion("icon in", values, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否不在指定的值列表中
         public Criteria andIconNotIn(List<String> values) {
             addCriterion("icon not in", values, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否在指定的范围内（between）
         public Criteria andIconBetween(String value1, String value2) {
             addCriterion("icon between", value1, value2, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否不在指定的范围内（not between）
         public Criteria andIconNotBetween(String value1, String value2) {
             addCriterion("icon not between", value1, value2, "icon");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否为空
         public Criteria andSubjectCountIsNull() {
             addCriterion("subject_count is null");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否不为空
         public Criteria andSubjectCountIsNotNull() {
             addCriterion("subject_count is not null");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否等于指定值
         public Criteria andSubjectCountEqualTo(Integer value) {
             addCriterion("subject_count =", value, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否不等于指定值
         public Criteria andSubjectCountNotEqualTo(Integer value) {
             addCriterion("subject_count <>", value, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否大于指定值
         public Criteria andSubjectCountGreaterThan(Integer value) {
             addCriterion("subject_count >", value, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否大于或等于指定值
         public Criteria andSubjectCountGreaterThanOrEqualTo(Integer value) {
             addCriterion("subject_count >=", value, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否小于指定值
         public Criteria andSubjectCountLessThan(Integer value) {
             addCriterion("subject_count <", value, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否小于或等于指定值
         public Criteria andSubjectCountLessThanOrEqualTo(Integer value) {
             addCriterion("subject_count <=", value, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否在指定的值列表中
         public Criteria andSubjectCountIn(List<Integer> values) {
             addCriterion("subject_count in", values, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否不在指定的值列表中
         public Criteria andSubjectCountNotIn(List<Integer> values) {
             addCriterion("subject_count not in", values, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否在指定的范围内（between）
         public Criteria andSubjectCountBetween(Integer value1, Integer value2) {
             addCriterion("subject_count between", value1, value2, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否不在指定的范围内（not between）
         public Criteria andSubjectCountNotBetween(Integer value1, Integer value2) {
             addCriterion("subject_count not between", value1, value2, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查show_status字段是否为空
         public Criteria andShowStatusIsNull() {
             addCriterion("show_status is null");
             return (Criteria) this;
         }
 
+        // 检查show_status字段是否不为空
         public Criteria andShowStatusIsNotNull() {
             addCriterion("show_status is not null");
             return (Criteria) this;
         }
 
+        // 检查show_status字段是否等于指定值
         public Criteria andShowStatusEqualTo(Integer value) {
             addCriterion("show_status =", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查show_status字段是否不等于指定值
         public Criteria andShowStatusNotEqualTo(Integer value) {
             addCriterion("show_status <>", value, "showStatus");
             return (Criteria) this;
         }
 
+
+        // 检查 show_status 是否大于指定值
         public Criteria andShowStatusGreaterThan(Integer value) {
             addCriterion("show_status >", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否大于或等于指定值
         public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("show_status >=", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否小于指定值
         public Criteria andShowStatusLessThan(Integer value) {
             addCriterion("show_status <", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否小于或等于指定值
         public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
             addCriterion("show_status <=", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否在指定的值列表中
         public Criteria andShowStatusIn(List<Integer> values) {
             addCriterion("show_status in", values, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否不在指定的值列表中
         public Criteria andShowStatusNotIn(List<Integer> values) {
             addCriterion("show_status not in", values, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否在指定的范围内（between）
         public Criteria andShowStatusBetween(Integer value1, Integer value2) {
             addCriterion("show_status between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否不在指定的范围内（not between）
         public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("show_status not between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否为空
         public Criteria andSortIsNull() {
             addCriterion("sort is null");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否不为空
         public Criteria andSortIsNotNull() {
             addCriterion("sort is not null");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否等于指定值
         public Criteria andSortEqualTo(Integer value) {
             addCriterion("sort =", value, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否不等于指定值
         public Criteria andSortNotEqualTo(Integer value) {
             addCriterion("sort <>", value, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否大于指定值
         public Criteria andSortGreaterThan(Integer value) {
             addCriterion("sort >", value, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否大于或等于指定值
         public Criteria andSortGreaterThanOrEqualTo(Integer value) {
             addCriterion("sort >=", value, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否小于指定值
         public Criteria andSortLessThan(Integer value) {
             addCriterion("sort <", value, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否小于或等于指定值
         public Criteria andSortLessThanOrEqualTo(Integer value) {
             addCriterion("sort <=", value, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否在指定的值列表中
         public Criteria andSortIn(List<Integer> values) {
             addCriterion("sort in", values, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否不在指定的值列表中
         public Criteria andSortNotIn(List<Integer> values) {
             addCriterion("sort not in", values, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否在指定的范围内（between）
         public Criteria andSortBetween(Integer value1, Integer value2) {
             addCriterion("sort between", value1, value2, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否不在指定的范围内（not between）
         public Criteria andSortNotBetween(Integer value1, Integer value2) {
             addCriterion("sort not between", value1, value2, "sort");
             return (Criteria) this;
         }
+
     }
 
     public static class Criteria extends GeneratedCriteria {
+        // 构造函数，初始化Criteria对象
         protected Criteria() {
             super();
         }
     }
 
     public static class Criterion {
-        private String condition;
+        private String condition; // 条件表达式
-
+        private Object value; // 条件值
-        private Object value;
+        private Object secondValue; // 第二个条件值（用于between查询）
-
+        private boolean noValue; // 是否没有值
-        private Object secondValue;
+        private boolean singleValue; // 是否为单一值
-
+        private boolean betweenValue; // 是否为区间值
-        private boolean noValue;
+        private boolean listValue; // 是否为列表值
-
+        private String typeHandler; // 类型处理器
-        private boolean singleValue;
+
-
+        // 获取条件表达式
-        private boolean betweenValue;
-
-        private boolean listValue;
-
-        private String typeHandler;
-
         public String getCondition() {
             return condition;
         }
 
+        // 获取条件值
         public Object getValue() {
             return value;
         }
 
+        // 获取第二个条件值
         public Object getSecondValue() {
             return secondValue;
         }
 
+        // 判断是否没有值
         public boolean isNoValue() {
             return noValue;
         }
 
+        // 判断是否为单一值
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        // 判断是否为区间值
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断是否为列表值
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取类型处理器
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，仅包含条件表达式
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -547,33 +627,38 @@ public class CmsTopicCategoryExample {
             this.noValue = true;
         }
 
+        // 构造函数，包含条件表达式和值，以及可选的类型处理器
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
             this.value = value;
             this.typeHandler = typeHandler;
             if (value instanceof List<?>) {
-                this.listValue = true;
+                this.listValue = true; // 如果值为列表，则设置listValue为true
             } else {
-                this.singleValue = true;
+                this.singleValue = true; // 否则设置为单一值
             }
         }
 
+        // 构造函数，包含条件表达式和值，不包含类型处理器
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，包含条件表达式、两个值和可选的类型处理器，用于between查询
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
             this.value = value;
             this.secondValue = secondValue;
             this.typeHandler = typeHandler;
-            this.betweenValue = true;
+            this.betweenValue = true; // 设置为区间值
         }
 
+        // 构造函数，包含条件表达式、两个值，不包含类型处理器，用于between查询
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }
     }
+
 }