营销模块中退款保证

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

@@ -4,23 +4,33 @@ import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 import java.util.Date;
 
+/**
+ * CmsTopicComment class represents a comment on a topic in the CMS (Content Management System).
+ */
 public class CmsTopicComment implements Serializable {
-    private Long id;
+    private Long id; // Unique identifier for the comment
 
-    private String memberNickName;
+    @ApiModelProperty(value = "Nickname of the member who posted the comment")
+    private String memberNickName; // Nickname of the member who posted the comment
 
-    private Long topicId;
+    @ApiModelProperty(value = "ID of the topic to which this comment is related")
+    private Long topicId; // ID of the topic to which this comment is related
 
-    private String memberIcon;
+    @ApiModelProperty(value = "Icon URL of the member who posted the comment")
+    private String memberIcon; // Icon URL of the member who posted the comment
 
-    private String content;
+    @ApiModelProperty(value = "Content of the comment")
+    private String content; // Content of the comment
 
-    private Date createTime;
+    @ApiModelProperty(value = "Creation time of the comment")
+    private Date createTime; // Creation time of the comment
 
-    private Integer showStatus;
+    @ApiModelProperty(value = "Status indicating whether the comment is displayed or not")
+    private Integer showStatus; // Status indicating whether the comment is displayed or not
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // Serial version UID for serialization
 
+    // Getters and Setters for each field
     public Long getId() {
         return id;
     }
@@ -77,6 +87,7 @@ public class CmsTopicComment implements Serializable {
         this.showStatus = showStatus;
     }
 
+    // Overriding toString method to provide string representation of the object
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
@@ -94,4 +105,4 @@ public class CmsTopicComment implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

@@ -5,46 +5,58 @@ import java.util.Date;
 import java.util.List;
 
 public class CmsTopicCommentExample {
+    // 定义一个用于排序的字符串
     protected String orderByClause;
 
+    // 定义一个布尔值，表示查询结果是否去重
     protected boolean distinct;
 
+    // 定义一个列表，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria为一个新的ArrayList
     public CmsTopicCommentExample() {
         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;
     }
 
+    // 添加一个查询条件到列表中的方法
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建一个新的查询条件并添加到列表中的方法
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建一个新的查询条件的方法，如果当前没有查询条件则添加到列表中
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -53,37 +65,46 @@ public class CmsTopicCommentExample {
         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;
         }
 
+        // 添加一个简单的查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -91,6 +112,7 @@ public class CmsTopicCommentExample {
             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");
@@ -98,6 +120,7 @@ public class CmsTopicCommentExample {
             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");
@@ -105,6 +128,7 @@ public class CmsTopicCommentExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 以下是具体的查询条件方法，用于构建不同的查询条件
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
@@ -265,352 +289,416 @@ public class CmsTopicCommentExample {
             return (Criteria) this;
         }
 
+
+        // 添加条件：topic_id < value
         public Criteria andTopicIdLessThan(Long value) {
             addCriterion("topic_id <", value, "topicId");
             return (Criteria) this;
         }
 
+        // 添加条件：topic_id <= value
         public Criteria andTopicIdLessThanOrEqualTo(Long value) {
             addCriterion("topic_id <=", value, "topicId");
             return (Criteria) this;
         }
 
+        // 添加条件：topic_id IN (values)
         public Criteria andTopicIdIn(List<Long> values) {
             addCriterion("topic_id in", values, "topicId");
             return (Criteria) this;
         }
 
+        // 添加条件：topic_id NOT IN (values)
         public Criteria andTopicIdNotIn(List<Long> values) {
             addCriterion("topic_id not in", values, "topicId");
             return (Criteria) this;
         }
 
+        // 添加条件：topic_id BETWEEN value1 AND value2
         public Criteria andTopicIdBetween(Long value1, Long value2) {
             addCriterion("topic_id between", value1, value2, "topicId");
             return (Criteria) this;
         }
 
+        // 添加条件：topic_id NOT BETWEEN value1 AND value2
         public Criteria andTopicIdNotBetween(Long value1, Long value2) {
             addCriterion("topic_id not between", value1, value2, "topicId");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon IS NULL
         public Criteria andMemberIconIsNull() {
             addCriterion("member_icon is null");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon IS NOT NULL
         public Criteria andMemberIconIsNotNull() {
             addCriterion("member_icon is not null");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon = value
         public Criteria andMemberIconEqualTo(String value) {
             addCriterion("member_icon =", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon <> value
         public Criteria andMemberIconNotEqualTo(String value) {
             addCriterion("member_icon <>", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon > value
         public Criteria andMemberIconGreaterThan(String value) {
             addCriterion("member_icon >", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon >= value
         public Criteria andMemberIconGreaterThanOrEqualTo(String value) {
             addCriterion("member_icon >=", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon < value
         public Criteria andMemberIconLessThan(String value) {
             addCriterion("member_icon <", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon <= value
         public Criteria andMemberIconLessThanOrEqualTo(String value) {
             addCriterion("member_icon <=", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon LIKE value
         public Criteria andMemberIconLike(String value) {
             addCriterion("member_icon like", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon NOT LIKE value
         public Criteria andMemberIconNotLike(String value) {
             addCriterion("member_icon not like", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon IN (values)
         public Criteria andMemberIconIn(List<String> values) {
             addCriterion("member_icon in", values, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon NOT IN (values)
         public Criteria andMemberIconNotIn(List<String> values) {
             addCriterion("member_icon not in", values, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon BETWEEN value1 AND value2
         public Criteria andMemberIconBetween(String value1, String value2) {
             addCriterion("member_icon between", value1, value2, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：member_icon NOT BETWEEN value1 AND value2
         public Criteria andMemberIconNotBetween(String value1, String value2) {
             addCriterion("member_icon not between", value1, value2, "memberIcon");
             return (Criteria) this;
         }
 
+        // 添加条件：content IS NULL
         public Criteria andContentIsNull() {
             addCriterion("content is null");
             return (Criteria) this;
         }
 
+        // 添加条件：content IS NOT NULL
         public Criteria andContentIsNotNull() {
             addCriterion("content is not null");
             return (Criteria) this;
         }
 
+        // 添加条件：content = value
         public Criteria andContentEqualTo(String value) {
             addCriterion("content =", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content <> value
         public Criteria andContentNotEqualTo(String value) {
             addCriterion("content <>", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content > value
         public Criteria andContentGreaterThan(String value) {
             addCriterion("content >", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content >= value
         public Criteria andContentGreaterThanOrEqualTo(String value) {
             addCriterion("content >=", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content < value
         public Criteria andContentLessThan(String value) {
             addCriterion("content <", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content <= value
         public Criteria andContentLessThanOrEqualTo(String value) {
             addCriterion("content <=", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content LIKE value
         public Criteria andContentLike(String value) {
             addCriterion("content like", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content NOT LIKE value
         public Criteria andContentNotLike(String value) {
             addCriterion("content not like", value, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content IN (values)
         public Criteria andContentIn(List<String> values) {
             addCriterion("content in", values, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content NOT IN (values)
         public Criteria andContentNotIn(List<String> values) {
             addCriterion("content not in", values, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content BETWEEN value1 AND value2
         public Criteria andContentBetween(String value1, String value2) {
             addCriterion("content between", value1, value2, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：content NOT BETWEEN value1 AND value2
         public Criteria andContentNotBetween(String value1, String value2) {
             addCriterion("content not between", value1, value2, "content");
             return (Criteria) this;
         }
 
+        // 添加条件：create_time IS NULL
         public Criteria andCreateTimeIsNull() {
             addCriterion("create_time is null");
             return (Criteria) this;
         }
 
+        // 添加条件：create_time IS NOT NULL
         public Criteria andCreateTimeIsNotNull() {
             addCriterion("create_time is not null");
             return (Criteria) this;
         }
 
+        // 添加条件：create_time = value
         public Criteria andCreateTimeEqualTo(Date value) {
             addCriterion("create_time =", value, "createTime");
             return (Criteria) this;
         }
 
+
+        // 检查创建时间是否不等于指定值
         public Criteria andCreateTimeNotEqualTo(Date value) {
             addCriterion("create_time <>", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否大于指定值
         public Criteria andCreateTimeGreaterThan(Date value) {
             addCriterion("create_time >", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否大于或等于指定值
         public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("create_time >=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否小于指定值
         public Criteria andCreateTimeLessThan(Date value) {
             addCriterion("create_time <", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否小于或等于指定值
         public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
             addCriterion("create_time <=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否在指定的日期列表中
         public Criteria andCreateTimeIn(List<Date> values) {
             addCriterion("create_time in", values, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否不在指定的日期列表中
         public Criteria andCreateTimeNotIn(List<Date> values) {
             addCriterion("create_time not in", values, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否在指定的日期范围内
         public Criteria andCreateTimeBetween(Date value1, Date value2) {
             addCriterion("create_time between", value1, value2, "createTime");
             return (Criteria) this;
         }
 
+        // 检查创建时间是否不在指定的日期范围内
         public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
             addCriterion("create_time not between", value1, value2, "createTime");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否为空
         public Criteria andShowStatusIsNull() {
             addCriterion("show_status is null");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否不为空
         public Criteria andShowStatusIsNotNull() {
             addCriterion("show_status is not null");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否等于指定值
         public Criteria andShowStatusEqualTo(Integer value) {
             addCriterion("show_status =", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否不等于指定值
         public Criteria andShowStatusNotEqualTo(Integer value) {
             addCriterion("show_status <>", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否大于指定值
         public Criteria andShowStatusGreaterThan(Integer value) {
             addCriterion("show_status >", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否大于或等于指定值
         public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("show_status >=", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否小于指定值
         public Criteria andShowStatusLessThan(Integer value) {
             addCriterion("show_status <", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否小于或等于指定值
         public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
             addCriterion("show_status <=", value, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否在指定的整数列表中
         public Criteria andShowStatusIn(List<Integer> values) {
             addCriterion("show_status in", values, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否不在指定的整数列表中
         public Criteria andShowStatusNotIn(List<Integer> values) {
             addCriterion("show_status not in", values, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否在指定的整数范围内
         public Criteria andShowStatusBetween(Integer value1, Integer value2) {
             addCriterion("show_status between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查显示状态是否不在指定的整数范围内
         public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("show_status not between", value1, value2, "showStatus");
             return (Criteria) this;
         }
+
     }
 
     public static class Criteria extends GeneratedCriteria {
+        // 构造函数，初始化Criteria对象
         protected Criteria() {
             super();
         }
     }
 
     public static class Criterion {
-        private String condition;
-
-        private Object value;
-
-        private Object secondValue;
-
-        private boolean noValue;
-
-        private boolean singleValue;
-
-        private boolean betweenValue;
-
-        private boolean listValue;
-
-        private String typeHandler;
-
+        private String condition; // 条件表达式
+        private Object value; // 条件值
+        private Object secondValue; // 第二个条件值（用于between查询）
+        private boolean noValue; // 是否没有值
+        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;
@@ -618,33 +706,38 @@ public class CmsTopicCommentExample {
             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);
         }
     }
+
 }

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

@@ -5,46 +5,58 @@ import java.util.Date;
 import java.util.List;
 
 public class CmsTopicExample {
+    // 定义一个用于排序的子句
     protected String orderByClause;
 
+    // 定义一个布尔值，用于指示查询是否使用 DISTINCT 关键字
     protected boolean distinct;
 
+    // 定义一个 Criteria 对象的列表，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化 oredCriteria 为一个新的 ArrayList
     public CmsTopicExample() {
         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;
     }
 
+    // 获取 Criteria 对象列表的方法
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 将一个 Criteria 对象添加到 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) {
@@ -53,37 +65,46 @@ public class CmsTopicExample {
         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;
         }
 
+        // 获取查询条件的列表（与getAllCriteria相同）
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加一个简单的查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -91,6 +112,7 @@ public class CmsTopicExample {
             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");
@@ -98,6 +120,7 @@ public class CmsTopicExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加一个范围查询条件（例如BETWEEN语句）
         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");
@@ -105,6 +128,7 @@ public class CmsTopicExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 以下方法用于生成具体的查询条件，例如id的各种比较操作
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
@@ -165,6 +189,7 @@ public class CmsTopicExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成category_id的各种比较操作
         public Criteria andCategoryIdIsNull() {
             addCriterion("category_id is null");
             return (Criteria) this;
@@ -225,6 +250,7 @@ public class CmsTopicExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成name的各种比较操作
         public Criteria andNameIsNull() {
             addCriterion("name is null");
             return (Criteria) this;
@@ -260,597 +286,711 @@ public class CmsTopicExample {
             return (Criteria) this;
         }
 
+
+        // 检查name字段是否小于或等于给定值
         public Criteria andNameLessThanOrEqualTo(String value) {
             addCriterion("name <=", value, "name");
             return (Criteria) this;
         }
 
+        // 检查name字段是否包含给定的值（使用SQL的LIKE操作符）
         public Criteria andNameLike(String value) {
             addCriterion("name like", value, "name");
             return (Criteria) this;
         }
 
+        // 检查name字段是否不包含给定的值（使用SQL的NOT LIKE操作符）
         public Criteria andNameNotLike(String value) {
             addCriterion("name not like", value, "name");
             return (Criteria) this;
         }
 
+        // 检查name字段是否在给定的值列表中
         public Criteria andNameIn(List<String> values) {
             addCriterion("name in", values, "name");
             return (Criteria) this;
         }
 
+        // 检查name字段是否不在给定的值列表中
         public Criteria andNameNotIn(List<String> values) {
             addCriterion("name not in", values, "name");
             return (Criteria) this;
         }
 
+        // 检查name字段是否在给定的两个值之间
         public Criteria andNameBetween(String value1, String value2) {
             addCriterion("name between", value1, value2, "name");
             return (Criteria) this;
         }
 
+        // 检查name字段是否不在给定的两个值之间
         public Criteria andNameNotBetween(String value1, String value2) {
             addCriterion("name not between", value1, value2, "name");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否为空
         public Criteria andCreateTimeIsNull() {
             addCriterion("create_time is null");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否不为空
         public Criteria andCreateTimeIsNotNull() {
             addCriterion("create_time is not null");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否等于给定值
         public Criteria andCreateTimeEqualTo(Date value) {
             addCriterion("create_time =", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否不等于给定值
         public Criteria andCreateTimeNotEqualTo(Date value) {
             addCriterion("create_time <>", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否大于给定值
         public Criteria andCreateTimeGreaterThan(Date value) {
             addCriterion("create_time >", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否大于或等于给定值
         public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("create_time >=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否小于给定值
         public Criteria andCreateTimeLessThan(Date value) {
             addCriterion("create_time <", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否小于或等于给定值
         public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
             addCriterion("create_time <=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否在给定的值列表中
         public Criteria andCreateTimeIn(List<Date> values) {
             addCriterion("create_time in", values, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否不在给定的值列表中
         public Criteria andCreateTimeNotIn(List<Date> values) {
             addCriterion("create_time not in", values, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否在给定的两个值之间
         public Criteria andCreateTimeBetween(Date value1, Date value2) {
             addCriterion("create_time between", value1, value2, "createTime");
             return (Criteria) this;
         }
 
+        // 检查create_time字段是否不在给定的两个值之间
         public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
             addCriterion("create_time not between", value1, value2, "createTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否为空
         public Criteria andStartTimeIsNull() {
             addCriterion("start_time is null");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否不为空
         public Criteria andStartTimeIsNotNull() {
             addCriterion("start_time is not null");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否等于给定值
         public Criteria andStartTimeEqualTo(Date value) {
             addCriterion("start_time =", value, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否不等于给定值
         public Criteria andStartTimeNotEqualTo(Date value) {
             addCriterion("start_time <>", value, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否大于给定值
         public Criteria andStartTimeGreaterThan(Date value) {
             addCriterion("start_time >", value, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否大于或等于给定值
         public Criteria andStartTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("start_time >=", value, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否小于给定值
         public Criteria andStartTimeLessThan(Date value) {
             addCriterion("start_time <", value, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否小于或等于给定值
         public Criteria andStartTimeLessThanOrEqualTo(Date value) {
             addCriterion("start_time <=", value, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否在给定的值列表中
         public Criteria andStartTimeIn(List<Date> values) {
             addCriterion("start_time in", values, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否不在给定的值列表中
         public Criteria andStartTimeNotIn(List<Date> values) {
             addCriterion("start_time not in", values, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否在给定的两个值之间
         public Criteria andStartTimeBetween(Date value1, Date value2) {
             addCriterion("start_time between", value1, value2, "startTime");
             return (Criteria) this;
         }
 
+        // 检查start_time字段是否不在给定的两个值之间
         public Criteria andStartTimeNotBetween(Date value1, Date value2) {
             addCriterion("start_time not between", value1, value2, "startTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否为空
         public Criteria andEndTimeIsNull() {
             addCriterion("end_time is null");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否不为空
         public Criteria andEndTimeIsNotNull() {
             addCriterion("end_time is not null");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否等于给定值
         public Criteria andEndTimeEqualTo(Date value) {
             addCriterion("end_time =", value, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否不等于给定值
         public Criteria andEndTimeNotEqualTo(Date value) {
             addCriterion("end_time <>", value, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否大于给定值
         public Criteria andEndTimeGreaterThan(Date value) {
             addCriterion("end_time >", value, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否大于或等于给定值
         public Criteria andEndTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("end_time >=", value, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否小于给定值
         public Criteria andEndTimeLessThan(Date value) {
             addCriterion("end_time <", value, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否小于或等于给定值
         public Criteria andEndTimeLessThanOrEqualTo(Date value) {
             addCriterion("end_time <=", value, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否在给定的值列表中
         public Criteria andEndTimeIn(List<Date> values) {
             addCriterion("end_time in", values, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否不在给定的值列表中
         public Criteria andEndTimeNotIn(List<Date> values) {
             addCriterion("end_time not in", values, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否在给定的两个值之间
         public Criteria andEndTimeBetween(Date value1, Date value2) {
             addCriterion("end_time between", value1, value2, "endTime");
             return (Criteria) this;
         }
 
+        // 检查end_time字段是否不在给定的两个值之间
         public Criteria andEndTimeNotBetween(Date value1, Date value2) {
             addCriterion("end_time not between", value1, value2, "endTime");
             return (Criteria) this;
         }
 
+
+        // 检查 attend_count 是否为空
         public Criteria andAttendCountIsNull() {
             addCriterion("attend_count is null");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否不为空
         public Criteria andAttendCountIsNotNull() {
             addCriterion("attend_count is not null");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否等于指定值
         public Criteria andAttendCountEqualTo(Integer value) {
             addCriterion("attend_count =", value, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否不等于指定值
         public Criteria andAttendCountNotEqualTo(Integer value) {
             addCriterion("attend_count <>", value, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否大于指定值
         public Criteria andAttendCountGreaterThan(Integer value) {
             addCriterion("attend_count >", value, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否大于或等于指定值
         public Criteria andAttendCountGreaterThanOrEqualTo(Integer value) {
             addCriterion("attend_count >=", value, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否小于指定值
         public Criteria andAttendCountLessThan(Integer value) {
             addCriterion("attend_count <", value, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否小于或等于指定值
         public Criteria andAttendCountLessThanOrEqualTo(Integer value) {
             addCriterion("attend_count <=", value, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否在指定的值列表中
         public Criteria andAttendCountIn(List<Integer> values) {
             addCriterion("attend_count in", values, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否不在指定的值列表中
         public Criteria andAttendCountNotIn(List<Integer> values) {
             addCriterion("attend_count not in", values, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否在指定的范围内
         public Criteria andAttendCountBetween(Integer value1, Integer value2) {
             addCriterion("attend_count between", value1, value2, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attend_count 是否不在指定的范围内
         public Criteria andAttendCountNotBetween(Integer value1, Integer value2) {
             addCriterion("attend_count not between", value1, value2, "attendCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否为空
         public Criteria andAttentionCountIsNull() {
             addCriterion("attention_count is null");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否不为空
         public Criteria andAttentionCountIsNotNull() {
             addCriterion("attention_count is not null");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否等于指定值
         public Criteria andAttentionCountEqualTo(Integer value) {
             addCriterion("attention_count =", value, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否不等于指定值
         public Criteria andAttentionCountNotEqualTo(Integer value) {
             addCriterion("attention_count <>", value, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否大于指定值
         public Criteria andAttentionCountGreaterThan(Integer value) {
             addCriterion("attention_count >", value, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否大于或等于指定值
         public Criteria andAttentionCountGreaterThanOrEqualTo(Integer value) {
             addCriterion("attention_count >=", value, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否小于指定值
         public Criteria andAttentionCountLessThan(Integer value) {
             addCriterion("attention_count <", value, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否小于或等于指定值
         public Criteria andAttentionCountLessThanOrEqualTo(Integer value) {
             addCriterion("attention_count <=", value, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否在指定的值列表中
         public Criteria andAttentionCountIn(List<Integer> values) {
             addCriterion("attention_count in", values, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否不在指定的值列表中
         public Criteria andAttentionCountNotIn(List<Integer> values) {
             addCriterion("attention_count not in", values, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否在指定的范围内
         public Criteria andAttentionCountBetween(Integer value1, Integer value2) {
             addCriterion("attention_count between", value1, value2, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 attention_count 是否不在指定的范围内
         public Criteria andAttentionCountNotBetween(Integer value1, Integer value2) {
             addCriterion("attention_count not between", value1, value2, "attentionCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否为空
         public Criteria andReadCountIsNull() {
             addCriterion("read_count is null");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否不为空
         public Criteria andReadCountIsNotNull() {
             addCriterion("read_count is not null");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否等于指定值
         public Criteria andReadCountEqualTo(Integer value) {
             addCriterion("read_count =", value, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否不等于指定值
         public Criteria andReadCountNotEqualTo(Integer value) {
             addCriterion("read_count <>", value, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否大于指定值
         public Criteria andReadCountGreaterThan(Integer value) {
             addCriterion("read_count >", value, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否大于或等于指定值
         public Criteria andReadCountGreaterThanOrEqualTo(Integer value) {
             addCriterion("read_count >=", value, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否小于指定值
         public Criteria andReadCountLessThan(Integer value) {
             addCriterion("read_count <", value, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否小于或等于指定值
         public Criteria andReadCountLessThanOrEqualTo(Integer value) {
             addCriterion("read_count <=", value, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否在指定的值列表中
         public Criteria andReadCountIn(List<Integer> values) {
             addCriterion("read_count in", values, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否不在指定的值列表中
         public Criteria andReadCountNotIn(List<Integer> values) {
             addCriterion("read_count not in", values, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否在指定的范围内
         public Criteria andReadCountBetween(Integer value1, Integer value2) {
             addCriterion("read_count between", value1, value2, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 read_count 是否不在指定的范围内
         public Criteria andReadCountNotBetween(Integer value1, Integer value2) {
             addCriterion("read_count not between", value1, value2, "readCount");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否为空
         public Criteria andAwardNameIsNull() {
             addCriterion("award_name is null");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否不为空
         public Criteria andAwardNameIsNotNull() {
             addCriterion("award_name is not null");
             return (Criteria) this;
         }
 
+
+        // 检查 award_name 是否等于指定值
         public Criteria andAwardNameEqualTo(String value) {
             addCriterion("award_name =", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否不等于指定值
         public Criteria andAwardNameNotEqualTo(String value) {
             addCriterion("award_name <>", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否大于指定值
         public Criteria andAwardNameGreaterThan(String value) {
             addCriterion("award_name >", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否大于或等于指定值
         public Criteria andAwardNameGreaterThanOrEqualTo(String value) {
             addCriterion("award_name >=", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否小于指定值
         public Criteria andAwardNameLessThan(String value) {
             addCriterion("award_name <", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否小于或等于指定值
         public Criteria andAwardNameLessThanOrEqualTo(String value) {
             addCriterion("award_name <=", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否匹配指定模式（使用 LIKE）
         public Criteria andAwardNameLike(String value) {
             addCriterion("award_name like", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否不匹配指定模式（使用 NOT LIKE）
         public Criteria andAwardNameNotLike(String value) {
             addCriterion("award_name not like", value, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否在指定的值列表中
         public Criteria andAwardNameIn(List<String> values) {
             addCriterion("award_name in", values, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否不在指定的值列表中
         public Criteria andAwardNameNotIn(List<String> values) {
             addCriterion("award_name not in", values, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否在指定的范围内（使用 BETWEEN）
         public Criteria andAwardNameBetween(String value1, String value2) {
             addCriterion("award_name between", value1, value2, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 award_name 是否不在指定的范围内（使用 NOT BETWEEN）
         public Criteria andAwardNameNotBetween(String value1, String value2) {
             addCriterion("award_name not between", value1, value2, "awardName");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否为空
         public Criteria andAttendTypeIsNull() {
             addCriterion("attend_type is null");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否不为空
         public Criteria andAttendTypeIsNotNull() {
             addCriterion("attend_type is not null");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否等于指定值
         public Criteria andAttendTypeEqualTo(String value) {
             addCriterion("attend_type =", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否不等于指定值
         public Criteria andAttendTypeNotEqualTo(String value) {
             addCriterion("attend_type <>", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否大于指定值
         public Criteria andAttendTypeGreaterThan(String value) {
             addCriterion("attend_type >", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否大于或等于指定值
         public Criteria andAttendTypeGreaterThanOrEqualTo(String value) {
             addCriterion("attend_type >=", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否小于指定值
         public Criteria andAttendTypeLessThan(String value) {
             addCriterion("attend_type <", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否小于或等于指定值
         public Criteria andAttendTypeLessThanOrEqualTo(String value) {
             addCriterion("attend_type <=", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否匹配指定模式（使用 LIKE）
         public Criteria andAttendTypeLike(String value) {
             addCriterion("attend_type like", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否不匹配指定模式（使用 NOT LIKE）
         public Criteria andAttendTypeNotLike(String value) {
             addCriterion("attend_type not like", value, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否在指定的值列表中
         public Criteria andAttendTypeIn(List<String> values) {
             addCriterion("attend_type in", values, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否不在指定的值列表中
         public Criteria andAttendTypeNotIn(List<String> values) {
             addCriterion("attend_type not in", values, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否在指定的范围内（使用 BETWEEN）
         public Criteria andAttendTypeBetween(String value1, String value2) {
             addCriterion("attend_type between", value1, value2, "attendType");
             return (Criteria) this;
         }
 
+        // 检查 attend_type 是否不在指定的范围内（使用 NOT BETWEEN）
         public Criteria andAttendTypeNotBetween(String value1, String value2) {
             addCriterion("attend_type not between", value1, value2, "attendType");
             return (Criteria) this;
         }
+
     }
 
     public static class Criteria extends GeneratedCriteria {
+        // 构造函数，初始化Criteria对象
         protected Criteria() {
             super();
         }
     }
 
     public static class Criterion {
-        private String condition;
-
-        private Object value;
-
-        private Object secondValue;
-
-        private boolean noValue;
-
-        private boolean singleValue;
-
-        private boolean betweenValue;
-
-        private boolean listValue;
-
-        private String typeHandler;
-
+        private String condition; // 条件表达式
+        private Object value; // 条件值
+        private Object secondValue; // 第二个条件值（用于between查询）
+        private boolean noValue; // 是否没有值
+        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;
@@ -858,33 +998,38 @@ public class CmsTopicExample {
             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);
+            this(condition, value, null); // 调用另一个构造函数，并传递null作为类型处理器
         }
 
+        // 构造函数，包含条件表达式、两个值和类型处理器
         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; // 设置为区间值
         }
 
+        // 构造函数，包含条件表达式、两个值
         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/OmsCartItem.java

@@ -202,10 +202,17 @@ public class OmsCartItem implements Serializable {
 
     @Override
     public String toString() {
+        // 创建一个StringBuilder对象，用于高效地构建字符串
         StringBuilder sb = new StringBuilder();
+
+        // 获取类的简单名称并追加到StringBuilder中
         sb.append(getClass().getSimpleName());
         sb.append(" [");
+
+        // 追加对象的哈希码
         sb.append("Hash = ").append(hashCode());
+
+        // 追加各个字段的值
         sb.append(", id=").append(id);
         sb.append(", productId=").append(productId);
         sb.append(", productSkuId=").append(productSkuId);
@@ -225,7 +232,10 @@ public class OmsCartItem implements Serializable {
         sb.append(", productSn=").append(productSn);
         sb.append(", productAttr=").append(productAttr);
         sb.append(", serialVersionUID=").append(serialVersionUID);
+
+        // 关闭方括号并返回最终的字符串
         sb.append("]");
         return sb.toString();
     }
+
 }