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

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

@@ -4,47 +4,85 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * UmsRoleExample 类用于构建查询条件，支持动态添加查询条件和排序。
+ */
 public class UmsRoleExample {
-    protected String orderByClause;
+    protected String orderByClause; // 存储排序子句
 
-    protected boolean distinct;
+    protected boolean distinct; // 是否去重
 
-    protected List<Criteria> oredCriteria;
+    protected List<Criteria> oredCriteria; // 存储多个查询条件
 
+    /**
+     * 构造函数，初始化oredCriteria为一个空的ArrayList。
+     */
     public UmsRoleExample() {
         oredCriteria = new ArrayList<>();
     }
 
+    /**
+     * 设置排序子句。
+     * @param orderByClause 排序子句
+     */
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    /**
+     * 获取排序子句。
+     * @return 排序子句
+     */
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    /**
+     * 设置是否去重。
+     * @param distinct 是否去重
+     */
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    /**
+     * 获取是否去重。
+     * @return 是否去重
+     */
     public boolean isDistinct() {
         return distinct;
     }
 
+    /**
+     * 获取所有查询条件。
+     * @return 查询条件列表
+     */
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    /**
+     * 添加一个新的查询条件到oredCriteria列表中。
+     * @param criteria 新的查询条件
+     */
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    /**
+     * 创建一个新的Criteria对象并添加到oredCriteria列表中。
+     * @return 新创建的Criteria对象
+     */
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    /**
+     * 创建一个Criteria对象，如果oredCriteria为空则添加到oredCriteria列表中。
+     * @return 新创建的Criteria对象
+     */
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -53,11 +91,18 @@ public class UmsRoleExample {
         return criteria;
     }
 
+    /**
+     * 内部方法，用于创建一个新的Criteria对象。
+     * @return 新创建的Criteria对象
+     */
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    /**
+     * 清除所有查询条件、排序子句和去重标志。
+     */
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
@@ -65,446 +110,559 @@ public class UmsRoleExample {
     }
 
     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");
+                throw new RuntimeException("Value for condition cannot be null"); // 如果条件为空，抛出异常
             }
-            criteria.add(new Criterion(condition));
+            criteria.add(new Criterion(condition)); // 将条件添加到criteria列表中
         }
 
+        // 添加一个带值的查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
-                throw new RuntimeException("Value for " + property + " cannot be null");
+                throw new RuntimeException("Value for " + property + " cannot be null"); // 如果值为空，抛出异常
             }
-            criteria.add(new Criterion(condition, value));
+            criteria.add(new Criterion(condition, value)); // 将条件和值添加到criteria列表中
         }
 
+        // 添加一个带两个值的查询条件（用于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");
+                throw new RuntimeException("Between values for " + property + " cannot be null"); // 如果任意一个值为空，抛出异常
             }
-            criteria.add(new Criterion(condition, value1, value2));
+            criteria.add(new Criterion(condition, value1, value2)); // 将条件和两个值添加到criteria列表中
         }
 
+        // 添加id为空的查询条件
         public Criteria andIdIsNull() {
             addCriterion("id is null");
-            return (Criteria) this;
+            return (Criteria) this; // 返回当前对象以支持链式调用
         }
 
+        // 添加id不为空的查询条件
         public Criteria andIdIsNotNull() {
             addCriterion("id is not null");
-            return (Criteria) this;
+            return (Criteria) this; // 返回当前对象以支持链式调用
         }
 
+        // 添加id等于指定值的查询条件
         public Criteria andIdEqualTo(Long value) {
             addCriterion("id =", value, "id");
-            return (Criteria) this;
+            return (Criteria) this; // 返回当前对象以支持链式调用
         }
 
+        // 添加id不等于指定值的查询条件
         public Criteria andIdNotEqualTo(Long value) {
             addCriterion("id <>", value, "id");
-            return (Criteria) this;
+            return (Criteria) this; // 返回当前对象以支持链式调用
         }
 
+        // 添加id大于指定值的查询条件
         public Criteria andIdGreaterThan(Long value) {
             addCriterion("id >", value, "id");
-            return (Criteria) this;
+            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;
         }
 
+        // 添加一个条件，要求name字段为空
         public Criteria andNameIsNull() {
             addCriterion("name is null");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求name字段不为空
         public Criteria andNameIsNotNull() {
             addCriterion("name is not null");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求name字段等于指定的值
         public Criteria andNameEqualTo(String value) {
             addCriterion("name =", value, "name");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求name字段不等于指定的值
         public Criteria andNameNotEqualTo(String value) {
             addCriterion("name <>", value, "name");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求name字段大于指定的值
         public Criteria andNameGreaterThan(String value) {
             addCriterion("name >", value, "name");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求name字段大于或等于指定的值
         public Criteria andNameGreaterThanOrEqualTo(String value) {
             addCriterion("name >=", value, "name");
             return (Criteria) this;
         }
 
+
+        // 添加一个条件，要求name字段小于指定的值
         public Criteria andNameLessThan(String value) {
             addCriterion("name <", value, "name");
             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;
         }
 
+        // 添加一个条件，要求description字段为空
         public Criteria andDescriptionIsNull() {
             addCriterion("description is null");
             return (Criteria) this;
         }
 
+
+        // 添加一个条件，要求description字段不为空
         public Criteria andDescriptionIsNotNull() {
             addCriterion("description is not null");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段等于指定的值
         public Criteria andDescriptionEqualTo(String value) {
             addCriterion("description =", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段不等于指定的值
         public Criteria andDescriptionNotEqualTo(String value) {
             addCriterion("description <>", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段大于指定的值
         public Criteria andDescriptionGreaterThan(String value) {
             addCriterion("description >", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段大于或等于指定的值
         public Criteria andDescriptionGreaterThanOrEqualTo(String value) {
             addCriterion("description >=", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段小于指定的值
         public Criteria andDescriptionLessThan(String value) {
             addCriterion("description <", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段小于或等于指定的值
         public Criteria andDescriptionLessThanOrEqualTo(String value) {
             addCriterion("description <=", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段匹配指定的模式（使用SQL的LIKE操作符）
         public Criteria andDescriptionLike(String value) {
             addCriterion("description like", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段不匹配指定的模式（使用SQL的NOT LIKE操作符）
         public Criteria andDescriptionNotLike(String value) {
             addCriterion("description not like", value, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段在指定的列表中
         public Criteria andDescriptionIn(List<String> values) {
             addCriterion("description in", values, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段不在指定的列表中
         public Criteria andDescriptionNotIn(List<String> values) {
             addCriterion("description not in", values, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段在指定的两个值之间（包含边界）
         public Criteria andDescriptionBetween(String value1, String value2) {
             addCriterion("description between", value1, value2, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求description字段不在指定的两个值之间（不包含边界）
         public Criteria andDescriptionNotBetween(String value1, String value2) {
             addCriterion("description not between", value1, value2, "description");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段为空
         public Criteria andAdminCountIsNull() {
             addCriterion("admin_count is null");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段不为空
         public Criteria andAdminCountIsNotNull() {
             addCriterion("admin_count is not null");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段等于指定的值
         public Criteria andAdminCountEqualTo(Integer value) {
             addCriterion("admin_count =", value, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段不等于指定的值
         public Criteria andAdminCountNotEqualTo(Integer value) {
             addCriterion("admin_count <>", value, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段大于指定的值
         public Criteria andAdminCountGreaterThan(Integer value) {
             addCriterion("admin_count >", value, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段大于或等于指定的值
         public Criteria andAdminCountGreaterThanOrEqualTo(Integer value) {
             addCriterion("admin_count >=", value, "adminCount");
             return (Criteria) this;
         }
 
+
+        // 添加一个条件，要求admin_count字段小于指定的值
         public Criteria andAdminCountLessThan(Integer value) {
             addCriterion("admin_count <", value, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段小于或等于指定的值
         public Criteria andAdminCountLessThanOrEqualTo(Integer value) {
             addCriterion("admin_count <=", value, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段在指定的列表中
         public Criteria andAdminCountIn(List<Integer> values) {
             addCriterion("admin_count in", values, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段不在指定的列表中
         public Criteria andAdminCountNotIn(List<Integer> values) {
             addCriterion("admin_count not in", values, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段在指定的两个值之间（包含边界）
         public Criteria andAdminCountBetween(Integer value1, Integer value2) {
             addCriterion("admin_count between", value1, value2, "adminCount");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求admin_count字段不在指定的两个值之间（不包含边界）
         public Criteria andAdminCountNotBetween(Integer value1, Integer value2) {
             addCriterion("admin_count not between", value1, value2, "adminCount");
             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;
         }
 
+        // 添加一个条件，要求status字段为空
         public Criteria andStatusIsNull() {
             addCriterion("status is null");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段不为空
         public Criteria andStatusIsNotNull() {
             addCriterion("status is not null");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段等于指定的值
         public Criteria andStatusEqualTo(Integer value) {
             addCriterion("status =", value, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段不等于指定的值
         public Criteria andStatusNotEqualTo(Integer value) {
             addCriterion("status <>", value, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段大于指定的值
         public Criteria andStatusGreaterThan(Integer value) {
             addCriterion("status >", value, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段大于或等于指定的值
         public Criteria andStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("status >=", value, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段小于指定的值
         public Criteria andStatusLessThan(Integer value) {
             addCriterion("status <", value, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段小于或等于指定的值
         public Criteria andStatusLessThanOrEqualTo(Integer value) {
             addCriterion("status <=", value, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段在指定的列表中
         public Criteria andStatusIn(List<Integer> values) {
             addCriterion("status in", values, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段不在指定的列表中
         public Criteria andStatusNotIn(List<Integer> values) {
             addCriterion("status not in", values, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段在指定的两个值之间（包含边界）
         public Criteria andStatusBetween(Integer value1, Integer value2) {
             addCriterion("status between", value1, value2, "status");
             return (Criteria) this;
         }
 
+        // 添加一个条件，要求status字段不在指定的两个值之间（不包含边界）
         public Criteria andStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("status not between", value1, value2, "status");
             return (Criteria) this;
         }
 
+
+        /**
+         * 添加一个条件，检查 'sort' 字段是否为空。
+         * @return 返回当前的 Criteria 对象，以便进行链式调用。
+         */
         public Criteria andSortIsNull() {
             addCriterion("sort is null");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，检查 'sort' 字段是否不为空。
+         * @return 返回当前的 Criteria 对象，以便进行链式调用。
+         */
         public Criteria andSortIsNotNull() {
             addCriterion("sort is not null");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，检查 'sort' 字段是否等于指定的值。
+         * @param value 要比较的值。
+         * @return 返回当前的 Criteria 对象，以便进行链式调用。
+         */
         public Criteria andSortEqualTo(Integer value) {
             addCriterion("sort =", value, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，检查 'sort' 字段是否不等于指定的值。
+         * @param value 要比较的值。
+         * @return 返回当前的 Criteria 对象，以便进行链式调用。
+         */
         public Criteria andSortNotEqualTo(Integer value) {
             addCriterion("sort <>", value, "sort");
             return (Criteria) this;
         }
 
+        /**
+         * 添加一个条件，检查 'sort' 字段是否大于指定的值。
+         * @param value 要比较的值。
+         * @return 返回当前的 Criteria 对象，以便进行链式调用。
+         */
         public Criteria andSortGreaterThan(Integer value) {
             addCriterion("sort >", value, "sort");
             return (Criteria) this;
@@ -552,6 +710,11 @@ public class UmsRoleExample {
         }
     }
 
+    /**
+     * 获取条件表达式。
+     *
+     * @return 返回条件表达式字符串。
+     */
     public static class Criterion {
         private String condition;
 
@@ -573,66 +736,123 @@ public class UmsRoleExample {
             return condition;
         }
 
+        /**
+         * 获取第一个值。
+         *
+         * @return 返回存储在 value 字段中的第一个值对象。
+         */
         public Object getValue() {
             return value;
         }
 
+        /**
+         * 获取第二个值。
+         *
+         * @return 返回存储在 secondValue 字段中的第二个值对象。
+         */
         public Object getSecondValue() {
             return secondValue;
         }
 
+        /**
+         * 判断是否没有值。
+         *
+         * @return 如果条件是 IS NULL 或 IS NOT NULL，则返回 true；否则返回 false。
+         */
         public boolean isNoValue() {
             return noValue;
         }
 
+        /**
+         * 判断是否为单一值。
+         *
+         * @return 如果条件是等于或不等于，则返回 true；否则返回 false。
+         */
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        /**
+         * 判断是否为区间值。
+         *
+         * @return 如果条件是 BETWEEN，则返回 true；否则返回 false。
+         */
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        /**
+         * 判断是否为列表值。
+         *
+         * @return 如果条件是 IN，则返回 true；否则返回 false。
+         */
         public boolean isListValue() {
             return listValue;
         }
 
+        /**
+         * 获取类型处理器。
+         *
+         * @return 返回类型处理器字符串。
+         */
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        /**
+         * Criterion 类的构造函数，用于初始化条件表达式。
+         *
+         * @param condition 条件表达式字符串，例如 "age > ?"
+         */
         protected Criterion(String condition) {
-            super();
-            this.condition = condition;
-            this.typeHandler = null;
-            this.noValue = true;
-        }
-
+            super(); // 调用父类构造函数
+            this.condition = condition; // 设置条件表达式
+            this.typeHandler = null; // 初始化类型处理器为空
+            this.noValue = true; // 默认情况下没有值
+        }
+
+        /**
+         * Criterion 类的构造函数，用于初始化条件表达式、值和类型处理器。
+         *
+         * @param condition    条件表达式字符串，例如 "age > ?"
+         * @param value        第一个值，用于单值比较或范围查询的第一个值
+         * @param typeHandler  类型处理器，用于处理自定义类型的转换
+         */
         protected Criterion(String condition, Object value, String typeHandler) {
-            super();
-            this.condition = condition;
-            this.value = value;
-            this.typeHandler = typeHandler;
+            super(); // 调用父类构造函数
+            this.condition = condition; // 设置条件表达式
+            this.value = value; // 设置第一个值
+            this.typeHandler = typeHandler; // 设置类型处理器
             if (value instanceof List<?>) {
-                this.listValue = true;
+                this.listValue = true; // 如果值是一个列表，则标记为列表值
             } else {
-                this.singleValue = true;
+                this.singleValue = true; // 否则标记为单一值
             }
         }
 
+
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        /**
+         * Criterion 类的构造函数，用于初始化条件表达式、值、第二值和类型处理器。
+         *
+         * @param condition    条件表达式字符串，例如 "age > ?"
+         * @param value        第一个值，用于单值比较或范围查询的第一个值
+         * @param secondValue  第二个值，仅在范围查询中使用
+         * @param typeHandler  类型处理器，用于处理自定义类型的转换
+         */
         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; // 标记这是一个区间值（BETWEEN）条件
         }
 
+
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

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

@@ -3,52 +3,67 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * UmsRoleMenuRelation 类表示角色和菜单之间的关系。
+ * 它实现了 Serializable 接口，以便对象可以被序列化。
+ */
 public class UmsRoleMenuRelation implements Serializable {
+    // 唯一标识符
     private Long id;
 
+    // 角色ID
     @ApiModelProperty(value = "角色ID")
     private Long roleId;
 
+    // 菜单ID
     @ApiModelProperty(value = "菜单ID")
     private Long menuId;
 
+    // 序列化版本UID，用于确保在反序列化时类的一致性
     private static final long serialVersionUID = 1L;
 
+    // 获取ID的方法
     public Long getId() {
         return id;
     }
 
+    // 设置ID的方法
     public void setId(Long id) {
         this.id = id;
     }
 
+    // 获取角色ID的方法
     public Long getRoleId() {
         return roleId;
     }
 
+    // 设置角色ID的方法
     public void setRoleId(Long roleId) {
         this.roleId = roleId;
     }
 
+    // 获取菜单ID的方法
     public Long getMenuId() {
         return menuId;
     }
 
+    // 设置菜单ID的方法
     public void setMenuId(Long menuId) {
         this.menuId = menuId;
     }
 
+    // 重写 toString 方法，用于生成对象的字符串表示形式
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
-        sb.append(getClass().getSimpleName());
+        sb.append(getClass().getSimpleName()); // 添加类名
         sb.append(" [");
-        sb.append("Hash = ").append(hashCode());
-        sb.append(", id=").append(id);
-        sb.append(", roleId=").append(roleId);
-        sb.append(", menuId=").append(menuId);
-        sb.append(", serialVersionUID=").append(serialVersionUID);
+        sb.append("Hash = ").append(hashCode()); // 添加哈希码
+        sb.append(", id=").append(id); // 添加ID
+        sb.append(", roleId=").append(roleId); // 添加角色ID
+        sb.append(", menuId=").append(menuId); // 添加菜单ID
+        sb.append(", serialVersionUID=").append(serialVersionUID); // 添加序列化版本UID
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

@@ -3,37 +3,70 @@ package com.macro.mall.model;
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * UmsRoleMenuRelationExample 是一个用于构建 UmsRoleMenuRelation 表的 SQL 查询条件的类。
+ */
 public class UmsRoleMenuRelationExample {
+    // 存储 SQL 查询中的 order by 子句
     protected String orderByClause;
 
+    // 标志是否在查询结果中去除重复记录
     protected boolean distinct;
 
+    // 存储多个 Criteria 对象，用于构建复杂的查询条件
     protected List<Criteria> oredCriteria;
 
+    /**
+     * 构造函数，初始化 oredCriteria 为一个空的 ArrayList。
+     */
     public UmsRoleMenuRelationExample() {
         oredCriteria = new ArrayList<>();
     }
 
+    /**
+     * 设置 order by 子句。
+     * @param orderByClause 要设置的 order by 子句
+     */
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    /**
+     * 获取当前的 order by 子句。
+     * @return 当前的 order by 子句
+     */
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    /**
+     * 设置是否去重的标志。
+     * @param distinct 是否去重的布尔值
+     */
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    /**
+     * 获取是否去重的标志。
+     * @return 是否去重的布尔值
+     */
     public boolean isDistinct() {
         return distinct;
     }
 
+    /**
+     * 获取当前所有的 Criteria 对象。
+     * @return 包含所有 Criteria 对象的列表
+     */
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    /**
+     * 添加一个新的 Criteria 对象到 oredCriteria 列表中。
+     * @param criteria 要添加的 Criteria 对象
+     */
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
@@ -359,21 +392,33 @@ public class UmsRoleMenuRelationExample {
             }
         }
 
+        // 构造函数，用于创建一个Criterion对象，只包含条件和值
         protected Criterion(String condition, Object value) {
+            // 调用另一个构造函数，并传递null作为typeHandler参数
             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;
         }
 
+        // 构造函数，用于创建一个Criterion对象，包含条件、值和第二个值
         protected Criterion(String condition, Object value, Object secondValue) {
+            // 调用另一个构造函数，并传递null作为typeHandler参数
             this(condition, value, secondValue, null);
         }
+
     }
 }

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

@@ -3,39 +3,74 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * UmsRolePermissionRelation 类表示角色和权限之间的关系。
+ */
 public class UmsRolePermissionRelation implements Serializable {
+    // 唯一标识符
     private Long id;
 
+    // 角色ID
     private Long roleId;
 
+    // 权限ID
     private Long permissionId;
 
+    // 序列化版本UID，用于确保在反序列化时类的一致性
     private static final long serialVersionUID = 1L;
 
+    /**
+     * 获取唯一标识符
+     * @return 唯一标识符
+     */
     public Long getId() {
         return id;
     }
 
+    /**
+     * 设置唯一标识符
+     * @param id 唯一标识符
+     */
     public void setId(Long id) {
         this.id = id;
     }
 
+    /**
+     * 获取角色ID
+     * @return 角色ID
+     */
     public Long getRoleId() {
         return roleId;
     }
 
+    /**
+     * 设置角色ID
+     * @param roleId 角色ID
+     */
     public void setRoleId(Long roleId) {
         this.roleId = roleId;
     }
 
+    /**
+     * 获取权限ID
+     * @return 权限ID
+     */
     public Long getPermissionId() {
         return permissionId;
     }
 
+    /**
+     * 设置权限ID
+     * @param permissionId 权限ID
+     */
     public void setPermissionId(Long permissionId) {
         this.permissionId = permissionId;
     }
 
+    /**
+     * 返回对象的字符串表示形式
+     * @return 对象的字符串表示形式
+     */
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
@@ -49,4 +84,4 @@ public class UmsRolePermissionRelation implements Serializable {
         sb.append("]");
         return sb.toString();
     }
-}
+}

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

@@ -3,17 +3,24 @@ package com.macro.mall.model;
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * UmsRolePermissionRelationExample 是用于构建 UmsRolePermissionRelation 表的 SQL 查询条件的类。
+ */
 public class UmsRolePermissionRelationExample {
-    protected String orderByClause;
+    protected String orderByClause; // SQL 查询中的 ORDER BY 子句
 
-    protected boolean distinct;
+    protected boolean distinct; // 是否在 SQL 查询中使用 DISTINCT
 
-    protected List<Criteria> oredCriteria;
+    protected List<Criteria> oredCriteria; // Criteria 对象的列表，每个对象代表一组条件
 
+    /**
+     * 构造函数初始化 oredCriteria 列表。
+     */
     public UmsRolePermissionRelationExample() {
         oredCriteria = new ArrayList<>();
     }
 
+
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }

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

@@ -3,41 +3,84 @@ package com.macro.mall.model;
 import io.swagger.annotations.ApiModelProperty;
 import java.io.Serializable;
 
+/**
+ * 角色资源关联实体类，表示角色与资源之间的关联关系。
+ */
 public class UmsRoleResourceRelation implements Serializable {
+    /**
+     * 主键ID。
+     */
     private Long id;
 
+    /**
+     * 角色ID。
+     */
     @ApiModelProperty(value = "角色ID")
     private Long roleId;
 
+    /**
+     * 资源ID。
+     */
     @ApiModelProperty(value = "资源ID")
     private Long resourceId;
 
+    /**
+     * 序列化版本号，用于兼容性检查。
+     */
     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 getRoleId() {
         return roleId;
     }
 
+    /**
+     * 设置角色ID。
+     * @param roleId 角色ID
+     */
     public void setRoleId(Long roleId) {
         this.roleId = roleId;
     }
 
+    /**
+     * 获取资源ID。
+     * @return 资源ID
+     */
     public Long getResourceId() {
         return resourceId;
     }
 
+    /**
+     * 设置资源ID。
+     * @param resourceId 资源ID
+     */
     public void setResourceId(Long resourceId) {
         this.resourceId = resourceId;
     }
 
+    /**
+     * 重写 toString 方法，用于打印对象信息。
+     * @return 对象信息字符串
+     */
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();

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

@@ -3,17 +3,27 @@ package com.macro.mall.model;
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * UmsRoleResourceRelationExample 类用于构建 UmsRoleResourceRelation 表的 SQL 查询条件。
+ */
 public class UmsRoleResourceRelationExample {
+    // 存储 SQL 查询的 ORDER BY 子句
     protected String orderByClause;
 
+    // 标记是否在查询中使用 DISTINCT 关键字
     protected boolean distinct;
 
+    // 持有多个 Criteria 对象的列表，每个对象代表一组条件
     protected List<Criteria> oredCriteria;
 
+    /**
+     * 构造函数，初始化 oredCriteria 列表为一个空的 ArrayList。
+     */
     public UmsRoleResourceRelationExample() {
         oredCriteria = new ArrayList<>();
     }
 
+
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }