diff --git a/mall-mbg/src/main/java/com/macro/mall/model/UmsRoleExample.java b/mall-mbg/src/main/java/com/macro/mall/model/UmsRoleExample.java
index 49692ae..7c62ae2 100644
--- a/mall-mbg/src/main/java/com/macro/mall/model/UmsRoleExample.java
+++ b/mall-mbg/src/main/java/com/macro/mall/model/UmsRoleExample.java
@@ -268,316 +268,401 @@ public class UmsRoleExample {
         }
 
 
+        // 添加一个条件，要求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;
@@ -625,6 +710,11 @@ public class UmsRoleExample {
         }
     }
 
+    /**
+     * 获取条件表达式。
+     *
+     * @return 返回条件表达式字符串。
+     */
     public static class Criterion {
         private String condition;
 
@@ -646,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);
         }