Merge remote-tracking branch 'origin/dev' into dev

# Conflicts:
#	mall-mbg/src/main/java/com/macro/mall/model/CmsHelp.java

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

@@ -1,108 +1,108 @@
-package com.macro.mall.model; // 定义包名，用于组织代码
+package com.macro.mall.model;
 
-import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解，用于API文档生成
-import java.io.Serializable; // 导入Serializable接口，用于序列化对象
-import java.util.Date; // 导入Date类，用于表示日期和时间
+import io.swagger.annotations.ApiModelProperty;
+import java.io.Serializable;
+import java.util.Date;
 
-public class CmsHelp implements Serializable { // 定义CmsHelp类，实现Serializable接口，用于序列化
-    private Long id; // 定义id属性，用于存储帮助信息的唯一标识
+public class CmsHelp implements Serializable {
+    private Long id;
 
-    private Long categoryId; // 定义categoryId属性，用于存储帮助信息的分类标识
+    private Long categoryId;
 
-    private String icon; // 定义icon属性，用于存储帮助信息的图标路径
+    private String icon;
 
-    private String title; // 定义title属性，用于存储帮助信息的标题
+    private String title;
 
-    private Integer showStatus; // 定义showStatus属性，用于存储帮助信息的显示状态
+    private Integer showStatus;
 
-    private Date createTime; // 定义createTime属性，用于存储帮助信息的创建时间
+    private Date createTime;
 
-    private Integer readCount; // 定义readCount属性，用于存储帮助信息的阅读次数
+    private Integer readCount;
 
-    private String content; // 定义content属性，用于存储帮助信息的内容
+    private String content;
 
-    private static final long serialVersionUID = 1L; // 定义serialVersionUID，用于序列化
+    private static final long serialVersionUID = 1L;
 
-    public Long getId() { // 定义getId方法，用于获取id属性的值
+    public Long getId() {
         return id;
     }
 
-    public void setId(Long id) { // 定义setId方法，用于设置id属性的值
+    public void setId(Long id) {
         this.id = id;
     }
 
-    public Long getCategoryId() { // 定义getCategoryId方法，用于获取categoryId属性的值
+    public Long getCategoryId() {
         return categoryId;
     }
 
-    public void setCategoryId(Long categoryId) { // 定义setCategoryId方法，用于设置categoryId属性的值
+    public void setCategoryId(Long categoryId) {
         this.categoryId = categoryId;
     }
 
-    public String getIcon() { // 定义getIcon方法，用于获取icon属性的值
+    public String getIcon() {
         return icon;
     }
 
-    public void setIcon(String icon) { // 定义setIcon方法，用于设置icon属性的值
+    public void setIcon(String icon) {
         this.icon = icon;
     }
 
-    public String getTitle() { // 定义getTitle方法，用于获取title属性的值
+    public String getTitle() {
         return title;
     }
 
-    public void setTitle(String title) { // 定义setTitle方法，用于设置title属性的值
+    public void setTitle(String title) {
         this.title = title;
     }
 
-    public Integer getShowStatus() { // 定义getShowStatus方法，用于获取showStatus属性的值
+    public Integer getShowStatus() {
         return showStatus;
     }
 
-    public void setShowStatus(Integer showStatus) { // 定义setShowStatus方法，用于设置showStatus属性的值
+    public void setShowStatus(Integer showStatus) {
         this.showStatus = showStatus;
     }
 
-    public Date getCreateTime() { // 定义getCreateTime方法，用于获取createTime属性的值
+    public Date getCreateTime() {
         return createTime;
     }
 
-    public void setCreateTime(Date createTime) { // 定义setCreateTime方法，用于设置createTime属性的值
+    public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
 
-    public Integer getReadCount() { // 定义getReadCount方法，用于获取readCount属性的值
+    public Integer getReadCount() {
         return readCount;
     }
 
-    public void setReadCount(Integer readCount) { // 定义setReadCount方法，用于设置readCount属性的值
+    public void setReadCount(Integer readCount) {
         this.readCount = readCount;
     }
 
-    public String getContent() { // 定义getContent方法，用于获取content属性的值
+    public String getContent() {
         return content;
     }
 
-    public void setContent(String content) { // 定义setContent方法，用于设置content属性的值
+    public void setContent(String content) {
         this.content = content;
     }
 
     @Override
-    public String toString() { // 重写toString方法，用于返回对象的字符串表示
-        StringBuilder sb = new StringBuilder(); // 创建StringBuilder对象，用于构建字符串
-        sb.append(getClass().getSimpleName()); // 追加类名
-        sb.append(" ["); // 追加左括号
-        sb.append("Hash = ").append(hashCode()); // 追加哈希码
-        sb.append(", id=").append(id); // 追加id属性及其值
-        sb.append(", categoryId=").append(categoryId); // 追加categoryId属性及其值
-        sb.append(", icon=").append(icon); // 追加icon属性及其值
-        sb.append(", title=").append(title); // 追加title属性及其值
-        sb.append(", showStatus=").append(showStatus); // 追加showStatus属性及其值
-        sb.append(", createTime=").append(createTime); // 追加createTime属性及其值
-        sb.append(", readCount=").append(readCount); // 追加readCount属性及其值
-        sb.append(", content=").append(content); // 追加content属性及其值
-        sb.append(", serialVersionUID=").append(serialVersionUID); // 追加serialVersionUID属性及其值
-        sb.append("]"); // 追加右括号
-        return sb.toString(); // 返回构建好的字符串
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(getClass().getSimpleName());
+        sb.append(" [");
+        sb.append("Hash = ").append(hashCode());
+        sb.append(", id=").append(id);
+        sb.append(", categoryId=").append(categoryId);
+        sb.append(", icon=").append(icon);
+        sb.append(", title=").append(title);
+        sb.append(", showStatus=").append(showStatus);
+        sb.append(", createTime=").append(createTime);
+        sb.append(", readCount=").append(readCount);
+        sb.append(", content=").append(content);
+        sb.append(", serialVersionUID=").append(serialVersionUID);
+        sb.append("]");
+        return sb.toString();
     }
 }

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

@@ -70,18 +70,40 @@ public class CmsHelpCategory 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);
+
+        // 追加name字段的值
         sb.append(", name=").append(name);
+
+        // 追加icon字段的值
         sb.append(", icon=").append(icon);
+
+        // 追加helpCount字段的值
         sb.append(", helpCount=").append(helpCount);
+
+        // 追加showStatus字段的值
         sb.append(", showStatus=").append(showStatus);
+
+        // 追加sort字段的值
         sb.append(", sort=").append(sort);
+
+        // 追加serialVersionUID字段的值
         sb.append(", serialVersionUID=").append(serialVersionUID);
+
+        // 结束字符串构建并返回结果
         sb.append("]");
         return sb.toString();
     }
+
 }

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

@@ -4,485 +4,620 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CmsHelpCategoryExample {
+    // 定义排序子句
     protected String orderByClause;
 
+    // 是否使用 DISTINCT 关键字
     protected boolean distinct;
 
+    // 存储查询条件的列表
     protected List<Criteria> oredCriteria;
 
+    /**
+     * 构造函数，初始化查询条件列表
+     */
     public CmsHelpCategoryExample() {
         oredCriteria = new ArrayList<>();
     }
 
+    /**
+     * 设置排序子句
+     * @param orderByClause 排序子句字符串
+     */
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    /**
+     * 获取排序子句
+     * @return 排序子句字符串
+     */
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    /**
+     * 设置是否使用 DISTINCT 关键字
+     * @param distinct true 表示使用 DISTINCT 关键字，false 表示不使用
+     */
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    /**
+     * 判断是否使用 DISTINCT 关键字
+     * @return 如果使用 DISTINCT 关键字返回 true，否则返回 false
+     */
     public boolean isDistinct() {
         return distinct;
     }
 
+    /**
+     * 获取查询条件列表
+     * @return 查询条件列表
+     */
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    /**
+     * 添加一个查询条件到查询条件列表中
+     * @param criteria 要添加的查询条件
+     */
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+
     public Criteria or() {
+        // 创建一个新的Criteria对象
         Criteria criteria = createCriteriaInternal();
+        // 将新的Criteria对象添加到oredCriteria列表中
         oredCriteria.add(criteria);
+        // 返回新创建的Criteria对象
         return criteria;
     }
 
     public Criteria createCriteria() {
+        // 创建一个新的Criteria对象
         Criteria criteria = createCriteriaInternal();
+        // 如果oredCriteria列表为空，则将新的Criteria对象添加到列表中
         if (oredCriteria.size() == 0) {
             oredCriteria.add(criteria);
         }
+        // 返回新创建的Criteria对象
         return criteria;
     }
 
     protected Criteria createCriteriaInternal() {
+        // 创建并返回一个新的Criteria对象
         Criteria criteria = new Criteria();
         return criteria;
     }
 
     public void clear() {
+        // 清空oredCriteria列表
         oredCriteria.clear();
+        // 将orderByClause设置为null
         orderByClause = null;
+        // 将distinct标志设置为false
         distinct = false;
     }
 
+
     protected abstract static class GeneratedCriteria {
-        protected List<Criterion> criteria;
+        // 存储Criterion对象的列表
+        protected List<Criterion> criteria; // 存储查询条件的列表
 
         protected GeneratedCriteria() {
+            // 调用父类的构造函数
             super();
+            // 初始化criteria列表
             criteria = new ArrayList<>();
         }
 
         public boolean isValid() {
+            // 检查criteria列表是否包含至少一个Criterion对象
             return criteria.size() > 0;
         }
 
         public List<Criterion> getAllCriteria() {
+            // 返回所有Criterion对象的列表
             return criteria;
         }
 
         public List<Criterion> getCriteria() {
+            // 返回所有Criterion对象的列表
             return criteria;
         }
 
         protected void addCriterion(String condition) {
+            // 如果条件为空，抛出运行时异常
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
             }
+            // 将新的Criterion对象添加到criteria列表中
             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");
             }
+            // 将新的Criterion对象（带值）添加到criteria列表中
             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");
             }
+            // 将新的Criterion对象（带两个值）添加到criteria列表中
             criteria.add(new Criterion(condition, value1, value2));
         }
 
         public Criteria andIdIsNull() {
+            // 添加条件“id is null”到criteria列表中
             addCriterion("id is null");
             return (Criteria) this;
         }
 
         public Criteria andIdIsNotNull() {
+            // 添加条件“id is not null”到criteria列表中
             addCriterion("id is not null");
             return (Criteria) this;
         }
 
         public Criteria andIdEqualTo(Long value) {
+            // 添加条件“id = value”到criteria列表中
             addCriterion("id =", value, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdNotEqualTo(Long value) {
+            // 添加条件“id <> value”到criteria列表中
             addCriterion("id <>", value, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdGreaterThan(Long value) {
+            // 添加条件“id > value”到criteria列表中
             addCriterion("id >", value, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdGreaterThanOrEqualTo(Long value) {
+            // 添加条件“id >= value”到criteria列表中
             addCriterion("id >=", value, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdLessThan(Long value) {
+            // 添加条件“id < value”到criteria列表中
             addCriterion("id <", value, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdLessThanOrEqualTo(Long value) {
+            // 添加条件“id <= value”到criteria列表中
             addCriterion("id <=", value, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdIn(List<Long> values) {
+            // 添加条件“id in (values)”到criteria列表中
             addCriterion("id in", values, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdNotIn(List<Long> values) {
+            // 添加条件“id not in (values)”到criteria列表中
             addCriterion("id not in", values, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdBetween(Long value1, Long value2) {
+            // 添加条件“id between value1 and value2”到criteria列表中
             addCriterion("id between", value1, value2, "id");
             return (Criteria) this;
         }
 
         public Criteria andIdNotBetween(Long value1, Long value2) {
+            // 添加条件“id not between value1 and value2”到criteria列表中
             addCriterion("id not between", value1, value2, "id");
             return (Criteria) this;
         }
 
         public Criteria andNameIsNull() {
+            // 添加条件“name is null”到criteria列表中
             addCriterion("name is null");
             return (Criteria) this;
         }
 
         public Criteria andNameIsNotNull() {
+            // 添加条件“name is not null”到criteria列表中
             addCriterion("name is not null");
             return (Criteria) this;
         }
 
         public Criteria andNameEqualTo(String value) {
+            // 添加条件“name = value”到criteria列表中
             addCriterion("name =", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameNotEqualTo(String value) {
+            // 添加条件“name <> value”到criteria列表中
             addCriterion("name <>", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameGreaterThan(String value) {
+            // 添加条件“name > value”到criteria列表中
             addCriterion("name >", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameGreaterThanOrEqualTo(String value) {
+            // 添加条件“name >= value”到criteria列表中
             addCriterion("name >=", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameLessThan(String value) {
+            // 添加条件“name < value”到criteria列表中
             addCriterion("name <", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameLessThanOrEqualTo(String value) {
+            // 添加条件 "name <= value" 到criteria列表中
             addCriterion("name <=", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameLike(String value) {
+            // 添加条件 "name like value" 到criteria列表中
             addCriterion("name like", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameNotLike(String value) {
+            // 添加条件 "name not like value" 到criteria列表中
             addCriterion("name not like", value, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameIn(List<String> values) {
+            // 添加条件 "name in (values)" 到criteria列表中
             addCriterion("name in", values, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameNotIn(List<String> values) {
+            // 添加条件 "name not in (values)" 到criteria列表中
             addCriterion("name not in", values, "name");
             return (Criteria) this;
         }
 
+
         public Criteria andNameBetween(String value1, String value2) {
+            // 添加条件 "name between value1 and value2"
             addCriterion("name between", value1, value2, "name");
             return (Criteria) this;
         }
 
         public Criteria andNameNotBetween(String value1, String value2) {
+            // 添加条件 "name not between value1 and value2"
             addCriterion("name not between", value1, value2, "name");
             return (Criteria) this;
         }
 
         public Criteria andIconIsNull() {
+            // 添加条件 "icon is null"
             addCriterion("icon is null");
             return (Criteria) this;
         }
 
         public Criteria andIconIsNotNull() {
+            // 添加条件 "icon is not null"
             addCriterion("icon is not null");
             return (Criteria) this;
         }
 
         public Criteria andIconEqualTo(String value) {
+            // 添加条件 "icon = value"
             addCriterion("icon =", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconNotEqualTo(String value) {
+            // 添加条件 "icon <> value"
             addCriterion("icon <>", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconGreaterThan(String value) {
+            // 添加条件 "icon > value"
             addCriterion("icon >", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconGreaterThanOrEqualTo(String value) {
+            // 添加条件 "icon >= value"
             addCriterion("icon >=", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconLessThan(String value) {
+            // 添加条件 "icon < value"
             addCriterion("icon <", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconLessThanOrEqualTo(String value) {
+            // 添加条件 "icon <= value"
             addCriterion("icon <=", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconLike(String value) {
+            // 添加条件 "icon like value"
             addCriterion("icon like", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconNotLike(String value) {
+            // 添加条件 "icon not like value"
             addCriterion("icon not like", value, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconIn(List<String> values) {
+            // 添加条件 "icon in (values)"
             addCriterion("icon in", values, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconNotIn(List<String> values) {
+            // 添加条件 "icon not in (values)"
             addCriterion("icon not in", values, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconBetween(String value1, String value2) {
+            // 添加条件 "icon between value1 and value2"
             addCriterion("icon between", value1, value2, "icon");
             return (Criteria) this;
         }
 
         public Criteria andIconNotBetween(String value1, String value2) {
+            // 添加条件 "icon not between value1 and value2"
             addCriterion("icon not between", value1, value2, "icon");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountIsNull() {
+            // 添加条件 "help_count is null"
             addCriterion("help_count is null");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountIsNotNull() {
+            // 添加条件 "help_count is not null"
             addCriterion("help_count is not null");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountEqualTo(Integer value) {
+            // 添加条件 "help_count = value"
             addCriterion("help_count =", value, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountNotEqualTo(Integer value) {
+            // 添加条件 "help_count <> value"
             addCriterion("help_count <>", value, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountGreaterThan(Integer value) {
+            // 添加条件 "help_count > value"
             addCriterion("help_count >", value, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountGreaterThanOrEqualTo(Integer value) {
+            // 添加条件 "help_count >= value"
             addCriterion("help_count >=", value, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountLessThan(Integer value) {
+            // 添加条件 "help_count < value"
             addCriterion("help_count <", value, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountLessThanOrEqualTo(Integer value) {
+            // 添加条件 "help_count <= value"
             addCriterion("help_count <=", value, "helpCount");
             return (Criteria) this;
         }
 
+
         public Criteria andHelpCountIn(List<Integer> values) {
+            // 添加条件 "help_count in (values)"
             addCriterion("help_count in", values, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountNotIn(List<Integer> values) {
+            // 添加条件 "help_count not in (values)"
             addCriterion("help_count not in", values, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountBetween(Integer value1, Integer value2) {
+            // 添加条件 "help_count between value1 and value2"
             addCriterion("help_count between", value1, value2, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andHelpCountNotBetween(Integer value1, Integer value2) {
+            // 添加条件 "help_count not between value1 and value2"
             addCriterion("help_count not between", value1, value2, "helpCount");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusIsNull() {
+            // 添加条件 "show_status is null"
             addCriterion("show_status is null");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusIsNotNull() {
+            // 添加条件 "show_status is not null"
             addCriterion("show_status is not null");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusEqualTo(Integer value) {
+            // 添加条件 "show_status = value"
             addCriterion("show_status =", value, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusNotEqualTo(Integer value) {
+            // 添加条件 "show_status <> value"
             addCriterion("show_status <>", value, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusGreaterThan(Integer value) {
+            // 添加条件 "show_status > value"
             addCriterion("show_status >", value, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
+            // 添加条件 "show_status >= value"
             addCriterion("show_status >=", value, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusLessThan(Integer value) {
+            // 添加条件 "show_status < value"
             addCriterion("show_status <", value, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
+            // 添加条件 "show_status <= 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 是否在给定的两个值之间（包含边界）
         public Criteria andShowStatusBetween(Integer value1, Integer value2) {
             addCriterion("show_status between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否不在给定的两个值之间（不包含边界）
         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 是否在给定的两个值之间（包含边界）
         public Criteria andSortBetween(Integer value1, Integer value2) {
             addCriterion("sort between", value1, value2, "sort");
             return (Criteria) this;
         }
 
+        // 检查 sort 是否不在给定的两个值之间（不包含边界）
         public Criteria andSortNotBetween(Integer value1, Integer value2) {
             addCriterion("sort not between", value1, value2, "sort");
             return (Criteria) this;
         }
+
     }
 
     public static class Criteria extends GeneratedCriteria {
@@ -559,19 +694,29 @@ public class CmsHelpCategoryExample {
             }
         }
 
+        // 构造函数，用于创建一个Criterion对象，只包含条件和值
         protected Criterion(String condition, Object value) {
+            // 调用另一个构造函数，并传递null作为第三个参数
             this(condition, value, null);
         }
 
+        // 构造函数，用于创建一个Criterion对象，包含条件、值、第二个值和类型处理器
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
+            // 调用父类的构造函数
             super();
+            // 初始化条件字段
             this.condition = condition;
+            // 初始化值字段
             this.value = value;
+            // 初始化第二个值字段
             this.secondValue = secondValue;
+            // 初始化类型处理器字段
             this.typeHandler = typeHandler;
+            // 设置betweenValue为true，表示这是一个范围查询
             this.betweenValue = true;
         }
 
+
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

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

@@ -5,46 +5,58 @@ import java.util.Date;
 import java.util.List;
 
 public class CmsHelpExample {
+    // 定义一个字符串变量用于存储排序子句
     protected String orderByClause;
 
+    // 定义一个布尔变量用于指示是否使用 DISTINCT 关键字
     protected boolean distinct;
 
+    // 定义一个列表用于存储查询条件（Criteria）
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化 oredCriteria 列表
     public CmsHelpExample() {
         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;
     }
 
+    // 向查询条件列表中添加一个新的 Criteria 对象
     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) {
@@ -53,37 +65,46 @@ public class CmsHelpExample {
         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 CmsHelpExample {
             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 CmsHelpExample {
             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 CmsHelpExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 以下方法用于生成具体的查询条件，例如id的各种比较操作
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
@@ -165,6 +189,7 @@ public class CmsHelpExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成category_id的各种比较操作
         public Criteria andCategoryIdIsNull() {
             addCriterion("category_id is null");
             return (Criteria) this;
@@ -225,321 +250,386 @@ public class CmsHelpExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成icon字段的各种比较操作
         public Criteria andIconIsNull() {
             addCriterion("icon is null");
             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;
         }
 
+        // 检查title字段是否为空
         public Criteria andTitleIsNull() {
             addCriterion("title is null");
             return (Criteria) this;
         }
 
+        // 检查title字段是否不为空
         public Criteria andTitleIsNotNull() {
             addCriterion("title is not null");
             return (Criteria) this;
         }
 
+        // 检查title字段是否等于指定值
         public Criteria andTitleEqualTo(String value) {
             addCriterion("title =", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否不等于指定值
         public Criteria andTitleNotEqualTo(String value) {
             addCriterion("title <>", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否大于指定值
         public Criteria andTitleGreaterThan(String value) {
             addCriterion("title >", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否大于或等于指定值
         public Criteria andTitleGreaterThanOrEqualTo(String value) {
             addCriterion("title >=", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否小于指定值
         public Criteria andTitleLessThan(String value) {
             addCriterion("title <", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否小于或等于指定值
         public Criteria andTitleLessThanOrEqualTo(String value) {
             addCriterion("title <=", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否匹配指定模式（使用LIKE）
         public Criteria andTitleLike(String value) {
             addCriterion("title like", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否不匹配指定模式（使用NOT LIKE）
         public Criteria andTitleNotLike(String value) {
             addCriterion("title not like", value, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否在指定列表中
         public Criteria andTitleIn(List<String> values) {
             addCriterion("title in", values, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否不在指定列表中
         public Criteria andTitleNotIn(List<String> values) {
             addCriterion("title not in", values, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否在指定范围内（使用BETWEEN）
         public Criteria andTitleBetween(String value1, String value2) {
             addCriterion("title between", value1, value2, "title");
             return (Criteria) this;
         }
 
+        // 检查title字段是否不在指定范围内（使用NOT BETWEEN）
         public Criteria andTitleNotBetween(String value1, String value2) {
             addCriterion("title not between", value1, value2, "title");
             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 是否在指定的范围内
         public Criteria andShowStatusBetween(Integer value1, Integer value2) {
             addCriterion("show_status between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否不在指定的范围内
         public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("show_status not between", value1, value2, "showStatus");
             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;
         }
 
+        // 检查 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;
@@ -547,94 +637,102 @@ public class CmsHelpExample {
     }
 
     public static class Criteria extends GeneratedCriteria {
+        // 默认构造函数，调用父类的构造函数
         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;
             this.typeHandler = null;
-            this.noValue = true;
+            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/CmsMemberReport.java

@@ -4,29 +4,34 @@ import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 import java.util.Date;
 
+/**
+ * CmsMemberReport 类表示一个会员举报信息。
+ * 它包含举报的详细信息，如举报类型、举报人、创建时间等。
+ */
 public class CmsMemberReport implements Serializable {
-    private Long id;
+    private Long id; // 举报的唯一标识符
 
     @ApiModelProperty(value = "举报类型：0->商品评价；1->话题内容；2->用户评论")
-    private Integer reportType;
+    private Integer reportType; // 举报的类型
 
     @ApiModelProperty(value = "举报人")
-    private String reportMemberName;
+    private String reportMemberName; // 举报人的姓名
 
-    private Date createTime;
+    private Date createTime; // 举报的创建时间
 
-    private String reportObject;
+    private String reportObject; // 被举报的对象（如商品ID或评论ID）
 
     @ApiModelProperty(value = "举报状态：0->未处理；1->已处理")
-    private Integer reportStatus;
+    private Integer reportStatus; // 举报的处理状态
 
     @ApiModelProperty(value = "处理结果：0->无效；1->有效；2->恶意")
-    private Integer handleStatus;
+    private Integer handleStatus; // 举报的处理结果
 
-    private String note;
+    private String note; // 备注信息
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // 序列化版本号
 
+    // Getter and Setter methods for each field
     public Long getId() {
         return id;
     }
@@ -91,6 +96,7 @@ public class CmsMemberReport implements Serializable {
         this.note = note;
     }
 
+    // toString method to provide a string representation of the object
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
@@ -109,4 +115,4 @@ public class CmsMemberReport implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

@@ -5,46 +5,58 @@ import java.util.Date;
 import java.util.List;
 
 public class CmsMemberReportExample {
+    // 定义一个用于排序的子句
     protected String orderByClause;
 
+    // 定义一个布尔值，用于指示查询结果是否去重
     protected boolean distinct;
 
+    // 定义一个列表，用于存储查询条件（Criteria）
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria为一个新的ArrayList
     public CmsMemberReportExample() {
         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) {
@@ -53,37 +65,46 @@ public class CmsMemberReportExample {
         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为一个新的ArrayList
         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 CmsMemberReportExample {
             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 CmsMemberReportExample {
             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,606 +128,720 @@ public class CmsMemberReportExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 添加id为空的查询条件的方法
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
         }
 
+        // 添加id不为空的查询条件的方法
         public Criteria andIdIsNotNull() {
             addCriterion("id is not null");
             return (Criteria) this;
         }
 
+        // 添加id等于指定值的查询条件的方法
         public Criteria andIdEqualTo(Long value) {
             addCriterion("id =", value, "id");
             return (Criteria) this;
         }
 
+        // 添加id不等于指定值的查询条件的方法
         public Criteria andIdNotEqualTo(Long value) {
             addCriterion("id <>", value, "id");
             return (Criteria) this;
         }
 
+        // 添加id大于指定值的查询条件的方法
         public Criteria andIdGreaterThan(Long value) {
             addCriterion("id >", value, "id");
             return (Criteria) this;
         }
 
+        // 添加id大于等于指定值的查询条件的方法
         public Criteria andIdGreaterThanOrEqualTo(Long value) {
             addCriterion("id >=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加id小于指定值的查询条件的方法
         public Criteria andIdLessThan(Long value) {
             addCriterion("id <", value, "id");
             return (Criteria) this;
         }
 
+        // 添加id小于等于指定值的查询条件的方法
         public Criteria andIdLessThanOrEqualTo(Long value) {
             addCriterion("id <=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加id在指定值列表中的查询条件的方法
         public Criteria andIdIn(List<Long> values) {
             addCriterion("id in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加id不在指定值列表中的查询条件的方法
         public Criteria andIdNotIn(List<Long> values) {
             addCriterion("id not in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加id在指定范围内的查询条件的方法
         public Criteria andIdBetween(Long value1, Long value2) {
             addCriterion("id between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加id不在指定范围内的查询条件的方法
         public Criteria andIdNotBetween(Long value1, Long value2) {
             addCriterion("id not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加report_type为空的查询条件的方法
         public Criteria andReportTypeIsNull() {
             addCriterion("report_type is null");
             return (Criteria) this;
         }
 
+        // 添加report_type不为空的查询条件的方法
         public Criteria andReportTypeIsNotNull() {
             addCriterion("report_type is not null");
             return (Criteria) this;
         }
 
+        // 添加report_type等于指定值的查询条件的方法
         public Criteria andReportTypeEqualTo(Integer value) {
             addCriterion("report_type =", value, "reportType");
             return (Criteria) this;
         }
 
+        // 添加report_type不等于指定值的查询条件的方法
         public Criteria andReportTypeNotEqualTo(Integer value) {
             addCriterion("report_type <>", value, "reportType");
             return (Criteria) this;
         }
 
+        // 添加report_type大于指定值的查询条件的方法
         public Criteria andReportTypeGreaterThan(Integer value) {
             addCriterion("report_type >", value, "reportType");
             return (Criteria) this;
         }
 
+        // 添加report_type大于等于指定值的查询条件的方法
         public Criteria andReportTypeGreaterThanOrEqualTo(Integer value) {
             addCriterion("report_type >=", value, "reportType");
             return (Criteria) this;
         }
 
+        // 添加report_type小于指定值的查询条件的方法
         public Criteria andReportTypeLessThan(Integer value) {
             addCriterion("report_type <", value, "reportType");
             return (Criteria) this;
         }
 
+
+        // 添加 report_type <= value 的条件
         public Criteria andReportTypeLessThanOrEqualTo(Integer value) {
             addCriterion("report_type <=", value, "reportType");
             return (Criteria) this;
         }
 
+        // 添加 report_type in (values) 的条件
         public Criteria andReportTypeIn(List<Integer> values) {
             addCriterion("report_type in", values, "reportType");
             return (Criteria) this;
         }
 
+        // 添加 report_type not in (values) 的条件
         public Criteria andReportTypeNotIn(List<Integer> values) {
             addCriterion("report_type not in", values, "reportType");
             return (Criteria) this;
         }
 
+        // 添加 report_type between value1 and value2 的条件
         public Criteria andReportTypeBetween(Integer value1, Integer value2) {
             addCriterion("report_type between", value1, value2, "reportType");
             return (Criteria) this;
         }
 
+        // 添加 report_type not between value1 and value2 的条件
         public Criteria andReportTypeNotBetween(Integer value1, Integer value2) {
             addCriterion("report_type not between", value1, value2, "reportType");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name is null 的条件
         public Criteria andReportMemberNameIsNull() {
             addCriterion("report_member_name is null");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name is not null 的条件
         public Criteria andReportMemberNameIsNotNull() {
             addCriterion("report_member_name is not null");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name = value 的条件
         public Criteria andReportMemberNameEqualTo(String value) {
             addCriterion("report_member_name =", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name <> value 的条件
         public Criteria andReportMemberNameNotEqualTo(String value) {
             addCriterion("report_member_name <>", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name > value 的条件
         public Criteria andReportMemberNameGreaterThan(String value) {
             addCriterion("report_member_name >", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name >= value 的条件
         public Criteria andReportMemberNameGreaterThanOrEqualTo(String value) {
             addCriterion("report_member_name >=", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name < value 的条件
         public Criteria andReportMemberNameLessThan(String value) {
             addCriterion("report_member_name <", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name <= value 的条件
         public Criteria andReportMemberNameLessThanOrEqualTo(String value) {
             addCriterion("report_member_name <=", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name like value 的条件
         public Criteria andReportMemberNameLike(String value) {
             addCriterion("report_member_name like", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name not like value 的条件
         public Criteria andReportMemberNameNotLike(String value) {
             addCriterion("report_member_name not like", value, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name in (values) 的条件
         public Criteria andReportMemberNameIn(List<String> values) {
             addCriterion("report_member_name in", values, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name not in (values) 的条件
         public Criteria andReportMemberNameNotIn(List<String> values) {
             addCriterion("report_member_name not in", values, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name between value1 and value2 的条件
         public Criteria andReportMemberNameBetween(String value1, String value2) {
             addCriterion("report_member_name between", value1, value2, "reportMemberName");
             return (Criteria) this;
         }
 
+        // 添加 report_member_name not between value1 and value2 的条件
         public Criteria andReportMemberNameNotBetween(String value1, String value2) {
             addCriterion("report_member_name not between", value1, value2, "reportMemberName");
             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;
         }
 
+        // 添加 create_time <> value 的条件
         public Criteria andCreateTimeNotEqualTo(Date value) {
             addCriterion("create_time <>", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加 create_time > value 的条件
         public Criteria andCreateTimeGreaterThan(Date value) {
             addCriterion("create_time >", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加 create_time >= value 的条件
         public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("create_time >=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加 create_time < value 的条件
         public Criteria andCreateTimeLessThan(Date value) {
             addCriterion("create_time <", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加 create_time <= value 的条件
         public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
             addCriterion("create_time <=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加 create_time in (values) 的条件
         public Criteria andCreateTimeIn(List<Date> values) {
             addCriterion("create_time in", values, "createTime");
             return (Criteria) this;
         }
 
+        // 添加 create_time not in (values) 的条件
         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 andReportObjectIsNull() {
             addCriterion("report_object is null");
             return (Criteria) this;
         }
 
+        // 添加报告对象不为空的条件
         public Criteria andReportObjectIsNotNull() {
             addCriterion("report_object is not null");
             return (Criteria) this;
         }
 
+        // 添加报告对象等于指定值的条件
         public Criteria andReportObjectEqualTo(String value) {
             addCriterion("report_object =", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象不等于指定值的条件
         public Criteria andReportObjectNotEqualTo(String value) {
             addCriterion("report_object <>", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象大于指定值的条件
         public Criteria andReportObjectGreaterThan(String value) {
             addCriterion("report_object >", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象大于或等于指定值的条件
         public Criteria andReportObjectGreaterThanOrEqualTo(String value) {
             addCriterion("report_object >=", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象小于指定值的条件
         public Criteria andReportObjectLessThan(String value) {
             addCriterion("report_object <", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象小于或等于指定值的条件
         public Criteria andReportObjectLessThanOrEqualTo(String value) {
             addCriterion("report_object <=", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象匹配指定模式的条件
         public Criteria andReportObjectLike(String value) {
             addCriterion("report_object like", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象不匹配指定模式的条件
         public Criteria andReportObjectNotLike(String value) {
             addCriterion("report_object not like", value, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象在指定列表中的条件
         public Criteria andReportObjectIn(List<String> values) {
             addCriterion("report_object in", values, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象不在指定列表中的条件
         public Criteria andReportObjectNotIn(List<String> values) {
             addCriterion("report_object not in", values, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象在指定范围内的条件
         public Criteria andReportObjectBetween(String value1, String value2) {
             addCriterion("report_object between", value1, value2, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告对象不在指定范围内的条件
         public Criteria andReportObjectNotBetween(String value1, String value2) {
             addCriterion("report_object not between", value1, value2, "reportObject");
             return (Criteria) this;
         }
 
+        // 添加报告状态为空的条件
         public Criteria andReportStatusIsNull() {
             addCriterion("report_status is null");
             return (Criteria) this;
         }
 
+        // 添加报告状态不为空的条件
         public Criteria andReportStatusIsNotNull() {
             addCriterion("report_status is not null");
             return (Criteria) this;
         }
 
+        // 添加报告状态等于指定值的条件
         public Criteria andReportStatusEqualTo(Integer value) {
             addCriterion("report_status =", value, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态不等于指定值的条件
         public Criteria andReportStatusNotEqualTo(Integer value) {
             addCriterion("report_status <>", value, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态大于指定值的条件
         public Criteria andReportStatusGreaterThan(Integer value) {
             addCriterion("report_status >", value, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态大于或等于指定值的条件
         public Criteria andReportStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("report_status >=", value, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态小于指定值的条件
         public Criteria andReportStatusLessThan(Integer value) {
             addCriterion("report_status <", value, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态小于或等于指定值的条件
         public Criteria andReportStatusLessThanOrEqualTo(Integer value) {
             addCriterion("report_status <=", value, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态在指定列表中的条件
         public Criteria andReportStatusIn(List<Integer> values) {
             addCriterion("report_status in", values, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态不在指定列表中的条件
         public Criteria andReportStatusNotIn(List<Integer> values) {
             addCriterion("report_status not in", values, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态在指定范围内的条件
         public Criteria andReportStatusBetween(Integer value1, Integer value2) {
             addCriterion("report_status between", value1, value2, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加报告状态不在指定范围内的条件
         public Criteria andReportStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("report_status not between", value1, value2, "reportStatus");
             return (Criteria) this;
         }
 
+        // 添加处理状态为空的条件
         public Criteria andHandleStatusIsNull() {
             addCriterion("handle_status is null");
             return (Criteria) this;
         }
 
+        // 添加处理状态不为空的条件
         public Criteria andHandleStatusIsNotNull() {
             addCriterion("handle_status is not null");
             return (Criteria) this;
         }
 
+        // 添加处理状态等于指定值的条件
         public Criteria andHandleStatusEqualTo(Integer value) {
             addCriterion("handle_status =", value, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加处理状态不等于指定值的条件
         public Criteria andHandleStatusNotEqualTo(Integer value) {
             addCriterion("handle_status <>", value, "handleStatus");
             return (Criteria) this;
         }
 
+
+        // 添加条件：handle_status > value
         public Criteria andHandleStatusGreaterThan(Integer value) {
             addCriterion("handle_status >", value, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：handle_status >= value
         public Criteria andHandleStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("handle_status >=", value, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：handle_status < value
         public Criteria andHandleStatusLessThan(Integer value) {
             addCriterion("handle_status <", value, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：handle_status <= value
         public Criteria andHandleStatusLessThanOrEqualTo(Integer value) {
             addCriterion("handle_status <=", value, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：handle_status in values
         public Criteria andHandleStatusIn(List<Integer> values) {
             addCriterion("handle_status in", values, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：handle_status not in values
         public Criteria andHandleStatusNotIn(List<Integer> values) {
             addCriterion("handle_status not in", values, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：handle_status between value1 and value2
         public Criteria andHandleStatusBetween(Integer value1, Integer value2) {
             addCriterion("handle_status between", value1, value2, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：handle_status not between value1 and value2
         public Criteria andHandleStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("handle_status not between", value1, value2, "handleStatus");
             return (Criteria) this;
         }
 
+        // 添加条件：note is null
         public Criteria andNoteIsNull() {
             addCriterion("note is null");
             return (Criteria) this;
         }
 
+        // 添加条件：note is not null
         public Criteria andNoteIsNotNull() {
             addCriterion("note is not null");
             return (Criteria) this;
         }
 
+        // 添加条件：note = value
         public Criteria andNoteEqualTo(String value) {
             addCriterion("note =", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note <> value
         public Criteria andNoteNotEqualTo(String value) {
             addCriterion("note <>", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note > value
         public Criteria andNoteGreaterThan(String value) {
             addCriterion("note >", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note >= value
         public Criteria andNoteGreaterThanOrEqualTo(String value) {
             addCriterion("note >=", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note < value
         public Criteria andNoteLessThan(String value) {
             addCriterion("note <", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note <= value
         public Criteria andNoteLessThanOrEqualTo(String value) {
             addCriterion("note <=", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note like value
         public Criteria andNoteLike(String value) {
             addCriterion("note like", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note not like value
         public Criteria andNoteNotLike(String value) {
             addCriterion("note not like", value, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note in values
         public Criteria andNoteIn(List<String> values) {
             addCriterion("note in", values, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note not in values
         public Criteria andNoteNotIn(List<String> values) {
             addCriterion("note not in", values, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note between value1 and value2
         public Criteria andNoteBetween(String value1, String value2) {
             addCriterion("note between", value1, value2, "note");
             return (Criteria) this;
         }
 
+        // 添加条件：note not between value1 and value2
         public Criteria andNoteNotBetween(String value1, String value2) {
             addCriterion("note not between", value1, value2, "note");
             return (Criteria) this;
         }
+
     }
 
     public static class Criteria extends GeneratedCriteria {
+        // 默认构造函数，调用父类的构造函数
         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; // 是否是between查询
+        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;
         }
 
+        // 判断是否是between查询
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断是否是列表值
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取类型处理器
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，仅包含条件表达式
         protected Criterion(String condition) {
             super();
             this.condition = condition;
             this.typeHandler = null;
-            this.noValue = true;
+            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作为类型处理器
         }
 
+        // 构造函数，包含条件表达式、两个值和可选的类型处理器，用于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查询
         }
 
+        // 构造函数，包含条件表达式、两个值，不包含类型处理器，用于between查询
         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/CmsPrefrenceArea.java

@@ -3,22 +3,26 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * CmsPrefrenceArea 实体类，用于表示CMS首选项区域。
+ */
 public class CmsPrefrenceArea implements Serializable {
-    private Long id;
+    private Long id; // 主键ID
 
-    private String name;
+    private String name; // 名称
 
-    private String subTitle;
+    private String subTitle; // 副标题
 
-    private Integer sort;
+    private Integer sort; // 排序
 
-    private Integer showStatus;
+    private Integer showStatus; // 显示状态
 
     @ApiModelProperty(value = "展示图片")
-    private byte[] pic;
+    private byte[] pic; // 展示图片，以字节数组形式存储
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // 序列化版本号
 
+    // Getter和Setter方法
     public Long getId() {
         return id;
     }
@@ -67,6 +71,7 @@ public class CmsPrefrenceArea implements Serializable {
         this.pic = pic;
     }
 
+    // toString方法，用于生成对象的字符串表示形式
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
@@ -83,4 +88,4 @@ public class CmsPrefrenceArea implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

@@ -4,46 +4,58 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CmsPrefrenceAreaExample {
+    // 定义一个用于排序的子句
     protected String orderByClause;
 
+    // 定义一个布尔值，用于指示查询是否使用 DISTINCT 关键字
     protected boolean distinct;
 
+    // 定义一个 Criteria 对象的列表，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化 oredCriteria 列表
     public CmsPrefrenceAreaExample() {
         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) {
@@ -52,37 +64,46 @@ public class CmsPrefrenceAreaExample {
         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 {
+        // 定义一个Criterion对象的列表，用于存储查询条件
         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");
@@ -90,6 +111,7 @@ public class CmsPrefrenceAreaExample {
             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 CmsPrefrenceAreaExample {
             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");
@@ -104,6 +127,8 @@ public class CmsPrefrenceAreaExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+// 以下方法用于生成具体的查询条件，例如id和name的各种比较操作
+
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
@@ -224,262 +249,308 @@ public class CmsPrefrenceAreaExample {
             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;
         }
 
+        // 检查sub_title字段是否为空
         public Criteria andSubTitleIsNull() {
             addCriterion("sub_title is null");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否不为空
         public Criteria andSubTitleIsNotNull() {
             addCriterion("sub_title is not null");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否等于给定的值
         public Criteria andSubTitleEqualTo(String value) {
             addCriterion("sub_title =", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否不等于给定的值
         public Criteria andSubTitleNotEqualTo(String value) {
             addCriterion("sub_title <>", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否大于给定的值
         public Criteria andSubTitleGreaterThan(String value) {
             addCriterion("sub_title >", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否大于或等于给定的值
         public Criteria andSubTitleGreaterThanOrEqualTo(String value) {
             addCriterion("sub_title >=", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否小于给定的值
         public Criteria andSubTitleLessThan(String value) {
             addCriterion("sub_title <", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否小于或等于给定的值
         public Criteria andSubTitleLessThanOrEqualTo(String value) {
             addCriterion("sub_title <=", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否包含给定的值（模糊匹配）
         public Criteria andSubTitleLike(String value) {
             addCriterion("sub_title like", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否不包含给定的值（模糊匹配）
         public Criteria andSubTitleNotLike(String value) {
             addCriterion("sub_title not like", value, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否在给定的值列表中
         public Criteria andSubTitleIn(List<String> values) {
             addCriterion("sub_title in", values, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否不在给定的值列表中
         public Criteria andSubTitleNotIn(List<String> values) {
             addCriterion("sub_title not in", values, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否在给定的两个值之间
         public Criteria andSubTitleBetween(String value1, String value2) {
             addCriterion("sub_title between", value1, value2, "subTitle");
             return (Criteria) this;
         }
 
+        // 检查sub_title字段是否不在给定的两个值之间
         public Criteria andSubTitleNotBetween(String value1, String value2) {
             addCriterion("sub_title not between", value1, value2, "subTitle");
             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字段是否在给定的两个值之间
         public Criteria andSortBetween(Integer value1, Integer value2) {
             addCriterion("sort between", value1, value2, "sort");
             return (Criteria) this;
         }
 
+        // 检查sort字段是否不在给定的两个值之间
         public Criteria andSortNotBetween(Integer value1, Integer value2) {
             addCriterion("sort not between", value1, value2, "sort");
             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;
         }
 
+
         public Criteria andShowStatusIn(List<Integer> values) {
+            // 添加条件：show_status 在指定的值列表中
             addCriterion("show_status in", values, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusNotIn(List<Integer> values) {
+            // 添加条件：show_status 不在指定的值列表中
             addCriterion("show_status not in", values, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusBetween(Integer value1, Integer value2) {
+            // 添加条件：show_status 在指定的两个值之间（包含边界）
             addCriterion("show_status between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
         public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
+            // 添加条件：show_status 不在指定的两个值之间（不包含边界）
             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;
@@ -487,33 +558,38 @@ public class CmsPrefrenceAreaExample {
             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);
         }
 
+        // 构造函数，包含条件表达式、两个值和类型处理器
         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);
         }
     }
+
 }

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

@@ -3,39 +3,74 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * 商品与优选区域关系的实体类
+ */
 public class CmsPrefrenceAreaProductRelation implements Serializable {
+    // 主键ID
     private Long id;
 
+    // 优选区域ID
     private Long prefrenceAreaId;
 
+    // 商品ID
     private Long productId;
 
+    // 序列化版本号，用于反序列化时验证版本一致性
     private static final long serialVersionUID = 1L;
 
+    /**
+     * 获取主键ID
+     * @return 主键ID
+     */
     public Long getId() {
         return id;
     }
 
+    /**
+     * 设置主键ID
+     * @param id 主键ID
+     */
     public void setId(Long id) {
         this.id = id;
     }
 
+    /**
+     * 获取优选区域ID
+     * @return 优选区域ID
+     */
     public Long getPrefrenceAreaId() {
         return prefrenceAreaId;
     }
 
+    /**
+     * 设置优选区域ID
+     * @param prefrenceAreaId 优选区域ID
+     */
     public void setPrefrenceAreaId(Long prefrenceAreaId) {
         this.prefrenceAreaId = prefrenceAreaId;
     }
 
+    /**
+     * 获取商品ID
+     * @return 商品ID
+     */
     public Long getProductId() {
         return productId;
     }
 
+    /**
+     * 设置商品ID
+     * @param productId 商品ID
+     */
     public void setProductId(Long productId) {
         this.productId = productId;
     }
 
+    /**
+     * 返回对象的字符串表示形式
+     * @return 对象的字符串表示形式
+     */
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
@@ -49,4 +84,4 @@ public class CmsPrefrenceAreaProductRelation implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

@@ -4,46 +4,58 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CmsPrefrenceAreaProductRelationExample {
+    // 定义排序子句
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 存储查询条件列表
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化查询条件列表
     public CmsPrefrenceAreaProductRelationExample() {
         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) {
@@ -52,37 +64,46 @@ public class CmsPrefrenceAreaProductRelationExample {
         return 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 CmsPrefrenceAreaProductRelationExample {
             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 CmsPrefrenceAreaProductRelationExample {
             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 CmsPrefrenceAreaProductRelationExample {
             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 CmsPrefrenceAreaProductRelationExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成prefrence_area_id相关的查询条件
         public Criteria andPrefrenceAreaIdIsNull() {
             addCriterion("prefrence_area_id is null");
             return (Criteria) this;
@@ -224,6 +249,7 @@ public class CmsPrefrenceAreaProductRelationExample {
             return (Criteria) this;
         }
 
+        // 以下方法用于生成product_id相关的查询条件
         public Criteria andProductIdIsNull() {
             addCriterion("product_id is null");
             return (Criteria) this;
@@ -259,87 +285,124 @@ public class CmsPrefrenceAreaProductRelationExample {
             return (Criteria) this;
         }
 
+
+        /**
+         * 添加一个条件，要求 product_id 小于或等于指定的值。
+         *
+         * @param value 要比较的值
+         * @return 当前的 Criteria 对象
+         */
         public Criteria andProductIdLessThanOrEqualTo(Long value) {
             addCriterion("product_id <=", value, "productId");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 product_id 在指定的值列表中。
+         *
+         * @param values 要匹配的值列表
+         * @return 当前的 Criteria 对象
+         */
         public Criteria andProductIdIn(List<Long> values) {
             addCriterion("product_id in", values, "productId");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 product_id 不在指定的值列表中。
+         *
+         * @param values 不匹配的值列表
+         * @return 当前的 Criteria 对象
+         */
         public Criteria andProductIdNotIn(List<Long> values) {
             addCriterion("product_id not in", values, "productId");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 product_id 在指定的两个值之间（包含边界）。
+         *
+         * @param value1 范围的起始值
+         * @param value2 范围的结束值
+         * @return 当前的 Criteria 对象
+         */
         public Criteria andProductIdBetween(Long value1, Long value2) {
             addCriterion("product_id between", value1, value2, "productId");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 product_id 不在指定的两个值之间（不包含边界）。
+         *
+         * @param value1 范围的起始值
+         * @param value2 范围的结束值
+         * @return 当前的 Criteria 对象
+         */
         public Criteria andProductIdNotBetween(Long value1, Long value2) {
             addCriterion("product_id not between", value1, value2, "productId");
             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;
@@ -347,33 +410,38 @@ public class CmsPrefrenceAreaProductRelationExample {
             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/CmsSubject.java

@@ -175,28 +175,72 @@ public class CmsSubject implements Serializable {
 
     @Override
     public String toString() {
+        // 创建一个StringBuilder对象，用于构建字符串
         StringBuilder sb = new StringBuilder();
+
+        // 添加类的简单名称到StringBuilder中
         sb.append(getClass().getSimpleName());
+
+        // 添加一个左方括号
         sb.append(" [");
+
+        // 添加对象的哈希码到StringBuilder中
         sb.append("Hash = ").append(hashCode());
+
+        // 添加id字段的值到StringBuilder中
         sb.append(", id=").append(id);
+
+        // 添加categoryId字段的值到StringBuilder中
         sb.append(", categoryId=").append(categoryId);
+
+        // 添加title字段的值到StringBuilder中
         sb.append(", title=").append(title);
+
+        // 添加pic字段的值到StringBuilder中
         sb.append(", pic=").append(pic);
+
+        // 添加productCount字段的值到StringBuilder中
         sb.append(", productCount=").append(productCount);
+
+        // 添加recommendStatus字段的值到StringBuilder中
         sb.append(", recommendStatus=").append(recommendStatus);
+
+        // 添加createTime字段的值到StringBuilder中
         sb.append(", createTime=").append(createTime);
+
+        // 添加collectCount字段的值到StringBuilder中
         sb.append(", collectCount=").append(collectCount);
+
+        // 添加readCount字段的值到StringBuilder中
         sb.append(", readCount=").append(readCount);
+
+        // 添加commentCount字段的值到StringBuilder中
         sb.append(", commentCount=").append(commentCount);
+
+        // 添加albumPics字段的值到StringBuilder中
         sb.append(", albumPics=").append(albumPics);
+
+        // 添加description字段的值到StringBuilder中
         sb.append(", description=").append(description);
+
+        // 添加showStatus字段的值到StringBuilder中
         sb.append(", showStatus=").append(showStatus);
+
+        // 添加forwardCount字段的值到StringBuilder中
         sb.append(", forwardCount=").append(forwardCount);
+
+        // 添加categoryName字段的值到StringBuilder中
         sb.append(", categoryName=").append(categoryName);
+
+        // 添加content字段的值到StringBuilder中
         sb.append(", content=").append(content);
+
+        // 添加serialVersionUID字段的值到StringBuilder中
         sb.append(", serialVersionUID=").append(serialVersionUID);
+
+        // 添加右方括号并返回最终的字符串
         sb.append("]");
         return sb.toString();
     }
+
 }

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

@@ -3,23 +3,34 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * 商品专题分类模型类
+ */
 public class CmsSubjectCategory implements Serializable {
     private Long id;
+    // 分类ID
 
     private String name;
+    // 分类名称
 
     @ApiModelProperty(value = "分类图标")
     private String icon;
+    // 分类图标
 
     @ApiModelProperty(value = "专题数量")
     private Integer subjectCount;
+    // 专题数量
 
     private Integer showStatus;
+    // 显示状态：0->不显示；1->显示
 
     private Integer sort;
+    // 排序
 
     private static final long serialVersionUID = 1L;
+    // 序列化版本号
 
+    // Getter和Setter方法
     public Long getId() {
         return id;
     }
@@ -68,6 +79,7 @@ public class CmsSubjectCategory implements Serializable {
         this.sort = sort;
     }
 
+    // 重写toString方法，用于打印对象信息
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
@@ -84,4 +96,4 @@ public class CmsSubjectCategory implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

@@ -4,46 +4,58 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CmsSubjectCategoryExample {
+    // 定义一个用于排序的子句
     protected String orderByClause;
 
+    // 定义一个布尔值，用于指示查询是否使用 DISTINCT 关键字
     protected boolean distinct;
 
+    // 定义一个 Criteria 对象的列表，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化 oredCriteria 列表
     public CmsSubjectCategoryExample() {
         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) {
@@ -52,37 +64,46 @@ public class CmsSubjectCategoryExample {
         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;
         }
 
+        // 添加一个简单的查询条件（例如 "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 CmsSubjectCategoryExample {
             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 CmsSubjectCategoryExample {
             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,7 @@ public class CmsSubjectCategoryExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 以下方法用于生成具体的查询条件，例如 id 和 name 的条件判断
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
@@ -254,292 +278,381 @@ public class CmsSubjectCategoryExample {
             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字段是否匹配给定的模式（使用SQL的LIKE操作符）
         public Criteria andIconLike(String value) {
             addCriterion("icon like", value, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否不匹配给定的模式（使用SQL的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字段是否在给定的两个值之间
         public Criteria andIconBetween(String value1, String value2) {
             addCriterion("icon between", value1, value2, "icon");
             return (Criteria) this;
         }
 
+        // 检查icon字段是否不在给定的两个值之间
         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字段是否在给定的两个值之间
         public Criteria andSubjectCountBetween(Integer value1, Integer value2) {
             addCriterion("subject_count between", value1, value2, "subjectCount");
             return (Criteria) this;
         }
 
+        // 检查subject_count字段是否不在给定的两个值之间
         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字段是否在给定的两个值之间
         public Criteria andShowStatusBetween(Integer value1, Integer value2) {
             addCriterion("show_status between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查show_status字段是否不在给定的两个值之间
         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' 字段的值必须大于或等于指定的值。
+         *
+         * @param value 要比较的值
+         * @return 当前的 Criteria 实例
+         */
         public Criteria andSortGreaterThanOrEqualTo(Integer value) {
             addCriterion("sort >=", value, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 'sort' 字段的值必须小于指定的值。
+         *
+         * @param value 要比较的值
+         * @return 当前的 Criteria 实例
+         */
         public Criteria andSortLessThan(Integer value) {
             addCriterion("sort <", value, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 'sort' 字段的值必须小于或等于指定的值。
+         *
+         * @param value 要比较的值
+         * @return 当前的 Criteria 实例
+         */
         public Criteria andSortLessThanOrEqualTo(Integer value) {
             addCriterion("sort <=", value, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 'sort' 字段的值必须在指定的列表中。
+         *
+         * @param values 要匹配的值的列表
+         * @return 当前的 Criteria 实例
+         */
         public Criteria andSortIn(List<Integer> values) {
             addCriterion("sort in", values, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 'sort' 字段的值不必须在指定的列表中。
+         *
+         * @param values 要排除的值的列表
+         * @return 当前的 Criteria 实例
+         */
         public Criteria andSortNotIn(List<Integer> values) {
             addCriterion("sort not in", values, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 'sort' 字段的值在指定的范围内（包含边界）。
+         *
+         * @param value1 范围的起始值
+         * @param value2 范围的结束值
+         * @return 当前的 Criteria 实例
+         */
         public Criteria andSortBetween(Integer value1, Integer value2) {
             addCriterion("sort between", value1, value2, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，要求 'sort' 字段的值不在指定的范围内（包含边界）。
+         *
+         * @param value1 范围的起始值
+         * @param value2 范围的结束值
+         * @return 当前的 Criteria 实例
+         */
         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 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;
@@ -547,33 +660,38 @@ public class CmsSubjectCategoryExample {
             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/CmsSubjectComment.java

@@ -1,26 +1,28 @@
-package com.macro.mall.model;
+package com.macro.mall.model; // 定义包名
 
-import io.swagger.annotations.ApiModelProperty;
-import java.io.Serializable;
-import java.util.Date;
+import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解库
+import java.io.Serializable; // 导入序列化接口
+import java.util.Date; // 导入日期类
 
+// 定义CmsSubjectComment类，实现Serializable接口
 public class CmsSubjectComment implements Serializable {
-    private Long id;
+    private Long id; // 评论ID
 
-    private Long subjectId;
+    private Long subjectId; // 专题ID
 
-    private String memberNickName;
+    private String memberNickName; // 会员昵称
 
-    private String memberIcon;
+    private String memberIcon; // 会员头像
 
-    private String content;
+    private String content; // 评论内容
 
-    private Date createTime;
+    private Date createTime; // 创建时间
 
-    private Integer showStatus;
+    private Integer showStatus; // 显示状态
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // 序列化版本号
 
+    // Getter和Setter方法
     public Long getId() {
         return id;
     }
@@ -77,21 +79,22 @@ public class CmsSubjectComment implements Serializable {
         this.showStatus = showStatus;
     }
 
+    // 重写toString方法，用于打印对象信息
     @Override
     public String toString() {
-        StringBuilder sb = new StringBuilder();
-        sb.append(getClass().getSimpleName());
-        sb.append(" [");
-        sb.append("Hash = ").append(hashCode());
-        sb.append(", id=").append(id);
-        sb.append(", subjectId=").append(subjectId);
-        sb.append(", memberNickName=").append(memberNickName);
-        sb.append(", memberIcon=").append(memberIcon);
-        sb.append(", content=").append(content);
-        sb.append(", createTime=").append(createTime);
-        sb.append(", showStatus=").append(showStatus);
-        sb.append(", serialVersionUID=").append(serialVersionUID);
-        sb.append("]");
-        return sb.toString();
+        StringBuilder sb = new StringBuilder(); // 创建StringBuilder对象
+        sb.append(getClass().getSimpleName()); // 添加类名
+        sb.append(" ["); // 添加左方括号
+        sb.append("Hash = ").append(hashCode()); // 添加哈希码
+        sb.append(", id=").append(id); // 添加ID
+        sb.append(", subjectId=").append(subjectId); // 添加专题ID
+        sb.append(", memberNickName=").append(memberNickName); // 添加会员昵称
+        sb.append(", memberIcon=").append(memberIcon); // 添加会员头像
+        sb.append(", content=").append(content); // 添加评论内容
+        sb.append(", createTime=").append(createTime); // 添加创建时间
+        sb.append(", showStatus=").append(showStatus); // 添加显示状态
+        sb.append(", serialVersionUID=").append(serialVersionUID); // 添加序列化版本号
+        sb.append("]"); // 添加右方括号
+        return sb.toString(); // 返回字符串表示形式
     }
-}
+}

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

@@ -5,46 +5,58 @@ import java.util.Date;
 import java.util.List;
 
 public class CmsSubjectCommentExample {
+    // 用于存储排序子句的字符串
     protected String orderByClause;
 
+    // 用于指示查询是否为distinct（去重）
     protected boolean distinct;
 
+    // 用于存储多个查询条件的列表
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria为一个空的ArrayList
     public CmsSubjectCommentExample() {
         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;
     }
 
+    // 将一个Criteria对象添加到查询条件列表中的方法
     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) {
@@ -53,37 +65,46 @@ public class CmsSubjectCommentExample {
         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为一个新的ArrayList
         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 CmsSubjectCommentExample {
             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 CmsSubjectCommentExample {
             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,512 +128,604 @@ public class CmsSubjectCommentExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 以下是各种具体的查询条件的生成方法，例如id、subjectId和memberNickName等字段的条件
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
         }
 
+        // 检查id是否不为空
         public Criteria andIdIsNotNull() {
             addCriterion("id is not null");
             return (Criteria) this;
         }
 
+        // 检查id是否等于指定值
         public Criteria andIdEqualTo(Long value) {
             addCriterion("id =", value, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否不等于指定值
         public Criteria andIdNotEqualTo(Long value) {
             addCriterion("id <>", value, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否大于指定值
         public Criteria andIdGreaterThan(Long value) {
             addCriterion("id >", value, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否大于或等于指定值
         public Criteria andIdGreaterThanOrEqualTo(Long value) {
             addCriterion("id >=", value, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否小于指定值
         public Criteria andIdLessThan(Long value) {
             addCriterion("id <", value, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否小于或等于指定值
         public Criteria andIdLessThanOrEqualTo(Long value) {
             addCriterion("id <=", value, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否在指定的列表中
         public Criteria andIdIn(List<Long> values) {
             addCriterion("id in", values, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否不在指定的列表中
         public Criteria andIdNotIn(List<Long> values) {
             addCriterion("id not in", values, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否在指定的范围内（包含边界）
         public Criteria andIdBetween(Long value1, Long value2) {
             addCriterion("id between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 检查id是否不在指定的范围内（不包含边界）
         public Criteria andIdNotBetween(Long value1, Long value2) {
             addCriterion("id not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否为空
         public Criteria andSubjectIdIsNull() {
             addCriterion("subject_id is null");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否不为空
         public Criteria andSubjectIdIsNotNull() {
             addCriterion("subject_id is not null");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否等于指定值
         public Criteria andSubjectIdEqualTo(Long value) {
             addCriterion("subject_id =", value, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否不等于指定值
         public Criteria andSubjectIdNotEqualTo(Long value) {
             addCriterion("subject_id <>", value, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否大于指定值
         public Criteria andSubjectIdGreaterThan(Long value) {
             addCriterion("subject_id >", value, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否大于或等于指定值
         public Criteria andSubjectIdGreaterThanOrEqualTo(Long value) {
             addCriterion("subject_id >=", value, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否小于指定值
         public Criteria andSubjectIdLessThan(Long value) {
             addCriterion("subject_id <", value, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否小于或等于指定值
         public Criteria andSubjectIdLessThanOrEqualTo(Long value) {
             addCriterion("subject_id <=", value, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否在指定的列表中
         public Criteria andSubjectIdIn(List<Long> values) {
             addCriterion("subject_id in", values, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否不在指定的列表中
         public Criteria andSubjectIdNotIn(List<Long> values) {
             addCriterion("subject_id not in", values, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否在指定的范围内（包含边界）
         public Criteria andSubjectIdBetween(Long value1, Long value2) {
             addCriterion("subject_id between", value1, value2, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查subject_id是否不在指定的范围内（不包含边界）
         public Criteria andSubjectIdNotBetween(Long value1, Long value2) {
             addCriterion("subject_id not between", value1, value2, "subjectId");
             return (Criteria) this;
         }
 
+        // 检查member_nick_name是否为空
         public Criteria andMemberNickNameIsNull() {
             addCriterion("member_nick_name is null");
             return (Criteria) this;
         }
 
+        // 检查member_nick_name是否不为空
         public Criteria andMemberNickNameIsNotNull() {
             addCriterion("member_nick_name is not null");
             return (Criteria) this;
         }
 
+        // 检查member_nick_name是否等于指定值
         public Criteria andMemberNickNameEqualTo(String value) {
             addCriterion("member_nick_name =", value, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查member_nick_name是否不等于指定值
         public Criteria andMemberNickNameNotEqualTo(String value) {
             addCriterion("member_nick_name <>", value, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查member_nick_name是否大于指定值
         public Criteria andMemberNickNameGreaterThan(String value) {
             addCriterion("member_nick_name >", value, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查member_nick_name是否大于或等于指定值
         public Criteria andMemberNickNameGreaterThanOrEqualTo(String value) {
             addCriterion("member_nick_name >=", value, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查member_nick_name是否小于指定值
         public Criteria andMemberNickNameLessThan(String value) {
             addCriterion("member_nick_name <", value, "memberNickName");
             return (Criteria) this;
         }
 
+
+        // 检查 member_nick_name 是否小于或等于给定的值
         public Criteria andMemberNickNameLessThanOrEqualTo(String value) {
             addCriterion("member_nick_name <=", value, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查 member_nick_name 是否包含给定的值（模糊匹配）
         public Criteria andMemberNickNameLike(String value) {
             addCriterion("member_nick_name like", value, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查 member_nick_name 是否不包含给定的值（模糊匹配）
         public Criteria andMemberNickNameNotLike(String value) {
             addCriterion("member_nick_name not like", value, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查 member_nick_name 是否在给定的值列表中
         public Criteria andMemberNickNameIn(List<String> values) {
             addCriterion("member_nick_name in", values, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查 member_nick_name 是否不在给定的值列表中
         public Criteria andMemberNickNameNotIn(List<String> values) {
             addCriterion("member_nick_name not in", values, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查 member_nick_name 是否在给定的两个值之间
         public Criteria andMemberNickNameBetween(String value1, String value2) {
             addCriterion("member_nick_name between", value1, value2, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查 member_nick_name 是否不在给定的两个值之间
         public Criteria andMemberNickNameNotBetween(String value1, String value2) {
             addCriterion("member_nick_name not between", value1, value2, "memberNickName");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否为空
         public Criteria andMemberIconIsNull() {
             addCriterion("member_icon is null");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否不为空
         public Criteria andMemberIconIsNotNull() {
             addCriterion("member_icon is not null");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否等于给定的值
         public Criteria andMemberIconEqualTo(String value) {
             addCriterion("member_icon =", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否不等于给定的值
         public Criteria andMemberIconNotEqualTo(String value) {
             addCriterion("member_icon <>", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否大于给定的值
         public Criteria andMemberIconGreaterThan(String value) {
             addCriterion("member_icon >", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否大于或等于给定的值
         public Criteria andMemberIconGreaterThanOrEqualTo(String value) {
             addCriterion("member_icon >=", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否小于给定的值
         public Criteria andMemberIconLessThan(String value) {
             addCriterion("member_icon <", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否小于或等于给定的值
         public Criteria andMemberIconLessThanOrEqualTo(String value) {
             addCriterion("member_icon <=", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否包含给定的值（模糊匹配）
         public Criteria andMemberIconLike(String value) {
             addCriterion("member_icon like", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否不包含给定的值（模糊匹配）
         public Criteria andMemberIconNotLike(String value) {
             addCriterion("member_icon not like", value, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否在给定的值列表中
         public Criteria andMemberIconIn(List<String> values) {
             addCriterion("member_icon in", values, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否不在给定的值列表中
         public Criteria andMemberIconNotIn(List<String> values) {
             addCriterion("member_icon not in", values, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否在给定的两个值之间
         public Criteria andMemberIconBetween(String value1, String value2) {
             addCriterion("member_icon between", value1, value2, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 member_icon 是否不在给定的两个值之间
         public Criteria andMemberIconNotBetween(String value1, String value2) {
             addCriterion("member_icon not between", value1, value2, "memberIcon");
             return (Criteria) this;
         }
 
+        // 检查 content 是否为空
         public Criteria andContentIsNull() {
             addCriterion("content is null");
             return (Criteria) this;
         }
 
+        // 检查 content 是否不为空
         public Criteria andContentIsNotNull() {
             addCriterion("content is not null");
             return (Criteria) this;
         }
 
+        // 检查 content 是否等于给定的值
         public Criteria andContentEqualTo(String value) {
             addCriterion("content =", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否不等于给定的值
         public Criteria andContentNotEqualTo(String value) {
             addCriterion("content <>", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否大于给定的值
         public Criteria andContentGreaterThan(String value) {
             addCriterion("content >", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否大于或等于给定的值
         public Criteria andContentGreaterThanOrEqualTo(String value) {
             addCriterion("content >=", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否小于给定的值
         public Criteria andContentLessThan(String value) {
             addCriterion("content <", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否小于或等于给定的值
         public Criteria andContentLessThanOrEqualTo(String value) {
             addCriterion("content <=", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否包含给定的值（模糊匹配）
         public Criteria andContentLike(String value) {
             addCriterion("content like", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否不包含给定的值（模糊匹配）
         public Criteria andContentNotLike(String value) {
             addCriterion("content not like", value, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否在给定的值列表中
         public Criteria andContentIn(List<String> values) {
             addCriterion("content in", values, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否不在给定的值列表中
         public Criteria andContentNotIn(List<String> values) {
             addCriterion("content not in", values, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否在给定的两个值之间
         public Criteria andContentBetween(String value1, String value2) {
             addCriterion("content between", value1, value2, "content");
             return (Criteria) this;
         }
 
+        // 检查 content 是否不在给定的两个值之间
         public Criteria andContentNotBetween(String value1, String value2) {
             addCriterion("content not between", value1, value2, "content");
             return (Criteria) this;
         }
 
-        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;
         }
 
+        // 检查 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 是否在给定的两个值之间
         public Criteria andShowStatusBetween(Integer value1, Integer value2) {
             addCriterion("show_status between", value1, value2, "showStatus");
             return (Criteria) this;
         }
 
+        // 检查 show_status 是否不在给定的两个值之间
         public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("show_status not between", value1, value2, "showStatus");
             return (Criteria) this;
         }
+
     }
 
+    // 定义一个静态内部类 Criteria，继承自 GeneratedCriteria
     public static class Criteria extends GeneratedCriteria {
+        // 构造函数，调用父类的构造函数
         protected Criteria() {
             super();
         }
     }
 
+    // 定义一个静态内部类 Criterion，用于封装查询条件
     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;
         }
 
+        // 构造函数，只包含条件，默认没有值，使用 null 作为类型处理器
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -618,6 +733,7 @@ public class CmsSubjectCommentExample {
             this.noValue = true;
         }
 
+        // 构造函数，包含条件和值，根据值的类型设置 singleValue 或 listValue
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -630,10 +746,12 @@ public class CmsSubjectCommentExample {
             }
         }
 
+        // 构造函数，包含条件和值，不指定类型处理器
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，包含条件、第一个值和第二个值，以及类型处理器，设置 betweenValue 为 true
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -643,8 +761,10 @@ public class CmsSubjectCommentExample {
             this.betweenValue = true;
         }
 
+        // 构造函数，包含条件、第一个值和第二个值，不指定类型处理器
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }
     }
+
 }

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 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;
-            this.typeHandler = null;
-            this.noValue = true;
+            super(); // 调用父类的构造函数
+            this.condition = condition; // 设置条件
+            this.typeHandler = null; // 初始化类型处理器为空
+            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;
+            super(); // 调用父类的构造函数
+            this.condition = condition; // 设置条件
+            this.value = value; // 设置值
+            this.typeHandler = typeHandler; // 设置类型处理器
+            if (value instanceof List<?>) { // 如果值是列表类型
+                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();
-            this.condition = condition;
-            this.value = value;
-            this.secondValue = secondValue;
-            this.typeHandler = typeHandler;
-            this.betweenValue = true;
+            super(); // 调用父类的构造函数
+            this.condition = condition; // 设置条件
+            this.value = value; // 设置第一个值
+            this.secondValue = secondValue; // 设置第二个值
+            this.typeHandler = typeHandler; // 设置类型处理器
+            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;
     }
@@ -154,4 +158,4 @@ public class CmsTopic implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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;
     }
@@ -84,4 +88,4 @@ public class CmsTopicCategory implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

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

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

@@ -3,38 +3,42 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * OmsCompanyAddress 类表示公司地址信息，用于存储和管理公司的发货和收货地址。
+ */
 public class OmsCompanyAddress implements Serializable {
-    private Long id;
+    private Long id; // 地址ID
 
     @ApiModelProperty(value = "地址名称")
-    private String addressName;
+    private String addressName; // 地址名称
 
     @ApiModelProperty(value = "默认发货地址：0->否；1->是")
-    private Integer sendStatus;
+    private Integer sendStatus; // 是否为默认发货地址
 
     @ApiModelProperty(value = "是否默认收货地址：0->否；1->是")
-    private Integer receiveStatus;
+    private Integer receiveStatus; // 是否为默认收货地址
 
     @ApiModelProperty(value = "收发货人姓名")
-    private String name;
+    private String name; // 收发货人姓名
 
     @ApiModelProperty(value = "收货人电话")
-    private String phone;
+    private String phone; // 收货人电话
 
     @ApiModelProperty(value = "省/直辖市")
-    private String province;
+    private String province; // 省或直辖市
 
     @ApiModelProperty(value = "市")
-    private String city;
+    private String city; // 城市
 
     @ApiModelProperty(value = "区")
-    private String region;
+    private String region; // 区域
 
     @ApiModelProperty(value = "详细地址")
-    private String detailAddress;
+    private String detailAddress; // 详细地址
 
-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // 序列化版本号
 
+    // Getter and Setter methods for each field
     public Long getId() {
         return id;
     }
@@ -135,4 +139,4 @@ public class OmsCompanyAddress implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}