wzw

src/main/java/com/xmomen/module/account/credentials/RetryLimitHashedCredentialsMatcher.java

@@ -9,11 +9,6 @@ import org.apache.shiro.cache.CacheManager;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-/**
- * <p>User: Zhang Kaitao
- * <p>Date: 14-1-28
- * <p>Version: 1.0
- */
 public class RetryLimitHashedCredentialsMatcher extends HashedCredentialsMatcher {
 
     //密码重试缓存

src/main/java/com/xmomen/module/account/model/CreateUser.java

@@ -5,11 +5,6 @@ import java.util.List;
 
 import lombok.Data;
 
-/**
- * <p>User: Zhang Kaitao
- * <p>Date: 14-1-28
- * <p>Version: 1.0
- */
 public @Data class CreateUser implements Serializable {
 	
     // 用户名

src/main/java/com/xmomen/module/account/model/User.java

@@ -5,9 +5,6 @@ import java.util.List;
 
 import lombok.Data;
 
-/**
- * Created by Jeng on 2016/1/28.
- */
 public @Data class User implements Serializable {
 
     //用户ID

src/main/java/com/xmomen/module/account/realm/UserRealm.java

@@ -17,12 +17,6 @@ import org.apache.shiro.util.ByteSource;
 
 import java.util.Set;
 
-
-/**
- * <p>User: Zhang Kaitao
- * <p>Date: 14-1-28
- * <p>Version: 1.0
- */
 public class UserRealm extends AuthorizingRealm {
 
     // 注入UserService

src/main/java/com/xmomen/module/account/service/PasswordHelper.java

@@ -5,11 +5,6 @@ import org.apache.shiro.crypto.SecureRandomNumberGenerator;
 import org.apache.shiro.crypto.hash.SimpleHash;
 import org.apache.shiro.util.ByteSource;
 
-/**
- * <p>User: Zhang Kaitao
- * <p>Date: 14-1-28
- * <p>Version: 1.0
- */
 public class PasswordHelper {
 
     // 随机数生成器

src/main/java/com/xmomen/module/account/service/PermissionService.java

@@ -3,11 +3,6 @@ package com.xmomen.module.account.service;
 
 import com.xmomen.module.user.entity.SysPermissions;
 
-/**
- * <p>User: Zhang Kaitao
- * <p>Date: 14-1-28
- * <p>Version: 1.0
- */
 public interface PermissionService {
     //创建权限
     public SysPermissions createPermission(SysPermissions permission);

src/main/java/com/xmomen/module/account/service/PermissionServiceImpl.java

@@ -7,11 +7,6 @@ import com.xmomen.framework.mybatis.dao.MybatisDao;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-/**
- * <p>User: Zhang Kaitao
- * <p>Date: 14-1-28
- * <p>Version: 1.0
- */
 @Service
 public class PermissionServiceImpl implements PermissionService {
 

src/main/java/com/xmomen/module/account/service/RoleService.java

@@ -7,11 +7,6 @@ import com.xmomen.framework.mybatis.page.Page;
 
 import java.util.List;
 
-/**
- * <p>User: Zhang Kaitao
- * <p>Date: 14-1-28
- * <p>Version: 1.0
- */
 public interface RoleService {
 
      // 根据角色ID查询用户

src/main/java/com/xmomen/module/base/entity/CdCouponRefExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义一个CdCouponRefExample类，继承自BaseMybatisExample类
 public class CdCouponRefExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria变量
     public CdCouponRefExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause变量的值
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause变量的值
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct变量的值
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct变量的值
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria变量的值
     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 +66,46 @@ public class CdCouponRefExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建一个新的查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空oredCriteria变量和orderByClause变量和distinct变量的值
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义一个GeneratedCriteria类，用于存储查询条件
     protected abstract static class GeneratedCriteria {
+        // 定义一个criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria变量
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断是否有查询条件
         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 +113,7 @@ public class CdCouponRefExample extends BaseMybatisExample {
             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 +121,7 @@ public class CdCouponRefExample extends BaseMybatisExample {
             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,401 +129,481 @@ public class CdCouponRefExample extends BaseMybatisExample {
             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(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否为空
         public Criteria andCdCouponIdIsNull() {
             addCriterion("CD_COUPON_ID is null");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否不为空
         public Criteria andCdCouponIdIsNotNull() {
             addCriterion("CD_COUPON_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否等于某个值
         public Criteria andCdCouponIdEqualTo(Integer value) {
             addCriterion("CD_COUPON_ID =", value, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否不等于某个值
         public Criteria andCdCouponIdNotEqualTo(Integer value) {
             addCriterion("CD_COUPON_ID <>", value, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否大于某个值
         public Criteria andCdCouponIdGreaterThan(Integer value) {
             addCriterion("CD_COUPON_ID >", value, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否大于等于某个值
         public Criteria andCdCouponIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_COUPON_ID >=", value, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否小于某个值
         public Criteria andCdCouponIdLessThan(Integer value) {
             addCriterion("CD_COUPON_ID <", value, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否小于等于某个值
         public Criteria andCdCouponIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_COUPON_ID <=", value, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否在某个范围内
         public Criteria andCdCouponIdIn(List<Integer> values) {
             addCriterion("CD_COUPON_ID in", values, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否不在某个范围内
         public Criteria andCdCouponIdNotIn(List<Integer> values) {
             addCriterion("CD_COUPON_ID not in", values, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否在某个范围内
         public Criteria andCdCouponIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_COUPON_ID between", value1, value2, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断CD_COUPON_ID是否不在某个范围内
         public Criteria andCdCouponIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_COUPON_ID not between", value1, value2, "cdCouponId");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否为空
         public Criteria andCouponNumberIsNull() {
             addCriterion("COUPON_NUMBER is null");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否不为空
         public Criteria andCouponNumberIsNotNull() {
             addCriterion("COUPON_NUMBER is not null");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否等于某个值
         public Criteria andCouponNumberEqualTo(String value) {
             addCriterion("COUPON_NUMBER =", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否不等于某个值
         public Criteria andCouponNumberNotEqualTo(String value) {
             addCriterion("COUPON_NUMBER <>", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否大于某个值
         public Criteria andCouponNumberGreaterThan(String value) {
             addCriterion("COUPON_NUMBER >", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否大于等于某个值
         public Criteria andCouponNumberGreaterThanOrEqualTo(String value) {
             addCriterion("COUPON_NUMBER >=", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否小于某个值
         public Criteria andCouponNumberLessThan(String value) {
             addCriterion("COUPON_NUMBER <", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否小于等于某个值
         public Criteria andCouponNumberLessThanOrEqualTo(String value) {
             addCriterion("COUPON_NUMBER <=", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否包含某个值
         public Criteria andCouponNumberLike(String value) {
             addCriterion("COUPON_NUMBER like", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否不包含某个值
         public Criteria andCouponNumberNotLike(String value) {
             addCriterion("COUPON_NUMBER not like", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否在某个范围内
         public Criteria andCouponNumberIn(List<String> values) {
             addCriterion("COUPON_NUMBER in", values, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否不在某个范围内
         public Criteria andCouponNumberNotIn(List<String> values) {
             addCriterion("COUPON_NUMBER not in", values, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否在某个范围内
         public Criteria andCouponNumberBetween(String value1, String value2) {
             addCriterion("COUPON_NUMBER between", value1, value2, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断COUPON_NUMBER是否不在某个范围内
         public Criteria andCouponNumberNotBetween(String value1, String value2) {
             addCriterion("COUPON_NUMBER not between", value1, value2, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否为空
         public Criteria andRefTypeIsNull() {
             addCriterion("REF_TYPE is null");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不为空
         public Criteria andRefTypeIsNotNull() {
             addCriterion("REF_TYPE is not null");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否等于某个值
         public Criteria andRefTypeEqualTo(String value) {
             addCriterion("REF_TYPE =", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不等于某个值
         public Criteria andRefTypeNotEqualTo(String value) {
             addCriterion("REF_TYPE <>", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否大于某个值
         public Criteria andRefTypeGreaterThan(String value) {
             addCriterion("REF_TYPE >", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否大于等于某个值
         public Criteria andRefTypeGreaterThanOrEqualTo(String value) {
             addCriterion("REF_TYPE >=", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否小于某个值
         public Criteria andRefTypeLessThan(String value) {
             addCriterion("REF_TYPE <", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否小于等于某个值
         public Criteria andRefTypeLessThanOrEqualTo(String value) {
             addCriterion("REF_TYPE <=", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否包含某个值
         public Criteria andRefTypeLike(String value) {
             addCriterion("REF_TYPE like", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不包含某个值
         public Criteria andRefTypeNotLike(String value) {
             addCriterion("REF_TYPE not like", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否在某个范围内
         public Criteria andRefTypeIn(List<String> values) {
             addCriterion("REF_TYPE in", values, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不在某个范围内
         public Criteria andRefTypeNotIn(List<String> values) {
             addCriterion("REF_TYPE not in", values, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否在某个范围内
         public Criteria andRefTypeBetween(String value1, String value2) {
             addCriterion("REF_TYPE between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不在某个范围内
         public Criteria andRefTypeNotBetween(String value1, String value2) {
             addCriterion("REF_TYPE not between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否为空
         public Criteria andRefNameIsNull() {
             addCriterion("REF_NAME is null");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否不为空
         public Criteria andRefNameIsNotNull() {
             addCriterion("REF_NAME is not null");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否等于某个值
         public Criteria andRefNameEqualTo(String value) {
             addCriterion("REF_NAME =", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否不等于某个值
         public Criteria andRefNameNotEqualTo(String value) {
             addCriterion("REF_NAME <>", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否大于某个值
         public Criteria andRefNameGreaterThan(String value) {
             addCriterion("REF_NAME >", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否大于等于某个值
         public Criteria andRefNameGreaterThanOrEqualTo(String value) {
             addCriterion("REF_NAME >=", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否小于某个值
         public Criteria andRefNameLessThan(String value) {
             addCriterion("REF_NAME <", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否小于等于某个值
         public Criteria andRefNameLessThanOrEqualTo(String value) {
             addCriterion("REF_NAME <=", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否包含某个值
         public Criteria andRefNameLike(String value) {
             addCriterion("REF_NAME like", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否不包含某个值
         public Criteria andRefNameNotLike(String value) {
             addCriterion("REF_NAME not like", value, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否在某个范围内
         public Criteria andRefNameIn(List<String> values) {
             addCriterion("REF_NAME in", values, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否不在某个范围内
         public Criteria andRefNameNotIn(List<String> values) {
             addCriterion("REF_NAME not in", values, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否在某个范围内
         public Criteria andRefNameBetween(String value1, String value2) {
             addCriterion("REF_NAME between", value1, value2, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_NAME是否不在某个范围内
         public Criteria andRefNameNotBetween(String value1, String value2) {
             addCriterion("REF_NAME not between", value1, value2, "refName");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否为空
         public Criteria andRefValueIsNull() {
             addCriterion("REF_VALUE is null");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不为空
         public Criteria andRefValueIsNotNull() {
             addCriterion("REF_VALUE is not null");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否等于某个值
         public Criteria andRefValueEqualTo(String value) {
             addCriterion("REF_VALUE =", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不等于某个值
         public Criteria andRefValueNotEqualTo(String value) {
             addCriterion("REF_VALUE <>", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否大于某个值
         public Criteria andRefValueGreaterThan(String value) {
             addCriterion("REF_VALUE >", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否大于等于某个值
         public Criteria andRefValueGreaterThanOrEqualTo(String value) {
             addCriterion("REF_VALUE >=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否小于某个值
         public Criteria andRefValueLessThan(String value) {
             addCriterion("REF_VALUE <", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否小于等于某个值
         public Criteria andRefValueLessThanOrEqualTo(String value) {
             addCriterion("REF_VALUE <=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否包含某个值
         public Criteria andRefValueLike(String value) {
             addCriterion("REF_VALUE like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不包含某个值
         public Criteria andRefValueNotLike(String value) {
             addCriterion("REF_VALUE not like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否在某个范围内
         public Criteria andRefValueIn(List<String> values) {
             addCriterion("REF_VALUE in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不在某个范围内
         public Criteria andRefValueNotIn(List<String> values) {
             addCriterion("REF_VALUE not in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否在某个范围内
         public Criteria andRefValueBetween(String value1, String value2) {
             addCriterion("REF_VALUE between", value1, value2, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不在某个范围内
         public Criteria andRefValueNotBetween(String value1, String value2) {
             addCriterion("REF_VALUE not between", value1, value2, "refValue");
             return (Criteria) this;

src/main/java/com/xmomen/module/base/entity/CdExpress.java

@@ -11,19 +11,13 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_express")
 public class CdExpress extends BaseMybatisModel {
-    /**
+    // 快递ID
-     * 主键
-     */
     private Integer id;
 
-    /**
+    // 快递编码
-     * 快递编号
-     */
     private String expressCode;
 
-    /**
+    // 快递名称
-     * 快递公司名
-     */
     private String expressName;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdExpressExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义一个CdExpressExample类，继承自BaseMybatisExample类
 public class CdExpressExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria变量
     public CdExpressExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause变量的值
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause变量的值
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct变量的值
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct变量的值
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria变量的值
     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 +66,46 @@ public class CdExpressExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建一个新的查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空oredCriteria变量和orderByClause变量和distinct变量的值
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义一个GeneratedCriteria内部类，用于存储查询条件
     protected abstract static class GeneratedCriteria {
+        // 定义一个criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria变量
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断是否有查询条件
         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 +113,7 @@ public class CdExpressExample extends BaseMybatisExample {
             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 +121,7 @@ public class CdExpressExample extends BaseMybatisExample {
             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,207 +129,248 @@ public class CdExpressExample extends BaseMybatisExample {
             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(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否为空
         public Criteria andExpressCodeIsNull() {
             addCriterion("EXPRESS_CODE is null");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否不为空
         public Criteria andExpressCodeIsNotNull() {
             addCriterion("EXPRESS_CODE is not null");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否等于某个值
         public Criteria andExpressCodeEqualTo(String value) {
             addCriterion("EXPRESS_CODE =", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否不等于某个值
         public Criteria andExpressCodeNotEqualTo(String value) {
             addCriterion("EXPRESS_CODE <>", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否大于某个值
         public Criteria andExpressCodeGreaterThan(String value) {
             addCriterion("EXPRESS_CODE >", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否大于等于某个值
         public Criteria andExpressCodeGreaterThanOrEqualTo(String value) {
             addCriterion("EXPRESS_CODE >=", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否小于某个值
         public Criteria andExpressCodeLessThan(String value) {
             addCriterion("EXPRESS_CODE <", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否小于等于某个值
         public Criteria andExpressCodeLessThanOrEqualTo(String value) {
             addCriterion("EXPRESS_CODE <=", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否包含某个值
         public Criteria andExpressCodeLike(String value) {
             addCriterion("EXPRESS_CODE like", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否不包含某个值
         public Criteria andExpressCodeNotLike(String value) {
             addCriterion("EXPRESS_CODE not like", value, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否在某个范围内
         public Criteria andExpressCodeIn(List<String> values) {
             addCriterion("EXPRESS_CODE in", values, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否不在某个范围内
         public Criteria andExpressCodeNotIn(List<String> values) {
             addCriterion("EXPRESS_CODE not in", values, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否在某个范围内
         public Criteria andExpressCodeBetween(String value1, String value2) {
             addCriterion("EXPRESS_CODE between", value1, value2, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressCode是否不在某个范围内
         public Criteria andExpressCodeNotBetween(String value1, String value2) {
             addCriterion("EXPRESS_CODE not between", value1, value2, "expressCode");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否为空
         public Criteria andExpressNameIsNull() {
             addCriterion("EXPRESS_NAME is null");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否不为空
         public Criteria andExpressNameIsNotNull() {
             addCriterion("EXPRESS_NAME is not null");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否等于某个值
         public Criteria andExpressNameEqualTo(String value) {
             addCriterion("EXPRESS_NAME =", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否不等于某个值
         public Criteria andExpressNameNotEqualTo(String value) {
             addCriterion("EXPRESS_NAME <>", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否大于某个值
         public Criteria andExpressNameGreaterThan(String value) {
             addCriterion("EXPRESS_NAME >", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否大于等于某个值
         public Criteria andExpressNameGreaterThanOrEqualTo(String value) {
             addCriterion("EXPRESS_NAME >=", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否小于某个值
         public Criteria andExpressNameLessThan(String value) {
             addCriterion("EXPRESS_NAME <", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否小于等于某个值
         public Criteria andExpressNameLessThanOrEqualTo(String value) {
             addCriterion("EXPRESS_NAME <=", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否包含某个值
         public Criteria andExpressNameLike(String value) {
             addCriterion("EXPRESS_NAME like", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否不包含某个值
         public Criteria andExpressNameNotLike(String value) {
             addCriterion("EXPRESS_NAME not like", value, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否在某个范围内
         public Criteria andExpressNameIn(List<String> values) {
             addCriterion("EXPRESS_NAME in", values, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否不在某个范围内
         public Criteria andExpressNameNotIn(List<String> values) {
             addCriterion("EXPRESS_NAME not in", values, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否在某个范围内
         public Criteria andExpressNameBetween(String value1, String value2) {
             addCriterion("EXPRESS_NAME between", value1, value2, "expressName");
             return (Criteria) this;
         }
 
+        // 添加一个查询条件，判断expressName是否不在某个范围内
         public Criteria andExpressNameNotBetween(String value1, String value2) {
             addCriterion("EXPRESS_NAME not between", value1, value2, "expressName");
             return (Criteria) this;
         }
     }
 
+    // 定义一个Criteria内部类，继承自GeneratedCriteria类
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -313,6 +378,7 @@ public class CdExpressExample extends BaseMybatisExample {
         }
     }
 
+    // 定义一个Criterion内部类，用于存储查询条件
     public static class Criterion {
         private String condition;
 
@@ -330,38 +396,47 @@ public class CdExpressExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取condition变量的值
         public String getCondition() {
             return condition;
         }
 
+        // 获取value变量的值
         public Object getValue() {
             return value;
         }
 
+        // 获取secondValue变量的值
         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;
         }
 
+        // 获取typeHandler变量的值
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，初始化condition变量和typeHandler变量和noValue变量
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -369,6 +444,7 @@ public class CdExpressExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 构造函数，初始化condition变量和value变量和typeHandler变量和singleValue变量
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -381,10 +457,12 @@ public class CdExpressExample extends BaseMybatisExample {
             }
         }
 
+        // 构造函数，初始化condition变量和value变量和singleValue变量
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，初始化condition变量和value变量和secondValue变量和typeHandler变量和betweenValue变量
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -394,6 +472,7 @@ public class CdExpressExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 构造函数，初始化condition变量和value变量和secondValue变量和betweenValue变量
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

src/main/java/com/xmomen/module/base/entity/CdExpressMember.java

@@ -11,24 +11,17 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_express_member")
 public class CdExpressMember extends BaseMybatisModel {
-    /**
+
-     * 主键
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+    // 快递ID
-     * 快递商id
-     */
     private Integer cdExpressId;
 
-    /**
+    // 会员名称
-     * 快递员姓名
-     */
     private String memberName;
 
-    /**
+    // 电话
-     * 电话号码
-     */
     private String phone;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdExpressMemberExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义一个CdExpressMemberExample类，继承自BaseMybatisExample
 public class CdExpressMemberExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria
     public CdExpressMemberExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause的值
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause的值
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct的值
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct的值
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria的值
     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 +66,46 @@ public class CdExpressMemberExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建一个新的查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空oredCriteria、orderByClause和distinct的值
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义一个GeneratedCriteria内部类，用于存储查询条件
     protected abstract static class GeneratedCriteria {
+        // 定义一个criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断是否有查询条件
         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 +113,7 @@ public class CdExpressMemberExample extends BaseMybatisExample {
             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 +121,7 @@ public class CdExpressMemberExample extends BaseMybatisExample {
             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,267 +129,320 @@ public class CdExpressMemberExample extends BaseMybatisExample {
             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(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否为空
         public Criteria andCdExpressIdIsNull() {
             addCriterion("CD_EXPRESS_ID is null");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否不为空
         public Criteria andCdExpressIdIsNotNull() {
             addCriterion("CD_EXPRESS_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否等于某个值
         public Criteria andCdExpressIdEqualTo(Integer value) {
             addCriterion("CD_EXPRESS_ID =", value, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否不等于某个值
         public Criteria andCdExpressIdNotEqualTo(Integer value) {
             addCriterion("CD_EXPRESS_ID <>", value, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否大于某个值
         public Criteria andCdExpressIdGreaterThan(Integer value) {
             addCriterion("CD_EXPRESS_ID >", value, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否大于等于某个值
         public Criteria andCdExpressIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_EXPRESS_ID >=", value, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否小于某个值
         public Criteria andCdExpressIdLessThan(Integer value) {
             addCriterion("CD_EXPRESS_ID <", value, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否小于等于某个值
         public Criteria andCdExpressIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_EXPRESS_ID <=", value, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否在某个范围内
         public Criteria andCdExpressIdIn(List<Integer> values) {
             addCriterion("CD_EXPRESS_ID in", values, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否不在某个范围内
         public Criteria andCdExpressIdNotIn(List<Integer> values) {
             addCriterion("CD_EXPRESS_ID not in", values, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否在某个范围内
         public Criteria andCdExpressIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_EXPRESS_ID between", value1, value2, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断CD_EXPRESS_ID是否不在某个范围内
         public Criteria andCdExpressIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_EXPRESS_ID not between", value1, value2, "cdExpressId");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否为空
         public Criteria andMemberNameIsNull() {
             addCriterion("MEMBER_NAME is null");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否不为空
         public Criteria andMemberNameIsNotNull() {
             addCriterion("MEMBER_NAME is not null");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否等于某个值
         public Criteria andMemberNameEqualTo(String value) {
             addCriterion("MEMBER_NAME =", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否不等于某个值
         public Criteria andMemberNameNotEqualTo(String value) {
             addCriterion("MEMBER_NAME <>", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否大于某个值
         public Criteria andMemberNameGreaterThan(String value) {
             addCriterion("MEMBER_NAME >", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否大于等于某个值
         public Criteria andMemberNameGreaterThanOrEqualTo(String value) {
             addCriterion("MEMBER_NAME >=", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否小于某个值
         public Criteria andMemberNameLessThan(String value) {
             addCriterion("MEMBER_NAME <", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否小于等于某个值
         public Criteria andMemberNameLessThanOrEqualTo(String value) {
             addCriterion("MEMBER_NAME <=", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否包含某个值
         public Criteria andMemberNameLike(String value) {
             addCriterion("MEMBER_NAME like", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否不包含某个值
         public Criteria andMemberNameNotLike(String value) {
             addCriterion("MEMBER_NAME not like", value, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否在某个范围内
         public Criteria andMemberNameIn(List<String> values) {
             addCriterion("MEMBER_NAME in", values, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否不在某个范围内
         public Criteria andMemberNameNotIn(List<String> values) {
             addCriterion("MEMBER_NAME not in", values, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否在某个范围内
         public Criteria andMemberNameBetween(String value1, String value2) {
             addCriterion("MEMBER_NAME between", value1, value2, "memberName");
             return (Criteria) this;
         }
 
+        // 判断MEMBER_NAME是否不在某个范围内
         public Criteria andMemberNameNotBetween(String value1, String value2) {
             addCriterion("MEMBER_NAME not between", value1, value2, "memberName");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否为空
         public Criteria andPhoneIsNull() {
             addCriterion("PHONE is null");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否不为空
         public Criteria andPhoneIsNotNull() {
             addCriterion("PHONE is not null");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否等于某个值
         public Criteria andPhoneEqualTo(String value) {
             addCriterion("PHONE =", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否不等于某个值
         public Criteria andPhoneNotEqualTo(String value) {
             addCriterion("PHONE <>", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否大于某个值
         public Criteria andPhoneGreaterThan(String value) {
             addCriterion("PHONE >", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否大于等于某个值
         public Criteria andPhoneGreaterThanOrEqualTo(String value) {
             addCriterion("PHONE >=", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否小于某个值
         public Criteria andPhoneLessThan(String value) {
             addCriterion("PHONE <", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否小于等于某个值
         public Criteria andPhoneLessThanOrEqualTo(String value) {
             addCriterion("PHONE <=", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否包含某个值
         public Criteria andPhoneLike(String value) {
             addCriterion("PHONE like", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否不包含某个值
         public Criteria andPhoneNotLike(String value) {
             addCriterion("PHONE not like", value, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否在某个范围内
         public Criteria andPhoneIn(List<String> values) {
             addCriterion("PHONE in", values, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否不在某个范围内
         public Criteria andPhoneNotIn(List<String> values) {
             addCriterion("PHONE not in", values, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否在某个范围内
         public Criteria andPhoneBetween(String value1, String value2) {
             addCriterion("PHONE between", value1, value2, "phone");
             return (Criteria) this;
         }
 
+        // 判断PHONE是否不在某个范围内
         public Criteria andPhoneNotBetween(String value1, String value2) {
             addCriterion("PHONE not between", value1, value2, "phone");
             return (Criteria) this;
         }
     }
 
+    // 定义一个Criteria内部类，继承自GeneratedCriteria
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -373,6 +450,7 @@ public class CdExpressMemberExample extends BaseMybatisExample {
         }
     }
 
+    // 定义一个Criterion内部类，用于存储查询条件
     public static class Criterion {
         private String condition;
 
@@ -390,38 +468,47 @@ public class CdExpressMemberExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取condition的值
         public String getCondition() {
             return condition;
         }
 
+        // 获取value的值
         public Object getValue() {
             return value;
         }
 
+        // 获取secondValue的值
         public Object getSecondValue() {
             return secondValue;
         }
 
+        // 判断是否有value
         public boolean isNoValue() {
             return noValue;
         }
 
+        // 判断是否只有一个value
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        // 判断是否在某个范围内
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断是否在某个范围内
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取typeHandler的值
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，初始化condition、typeHandler和noValue
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -429,6 +516,7 @@ public class CdExpressMemberExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 构造函数，初始化condition、value、typeHandler和singleValue
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -441,10 +529,12 @@ public class CdExpressMemberExample extends BaseMybatisExample {
             }
         }
 
+        // 构造函数，初始化condition、value和singleValue
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，初始化condition、value、secondValue、typeHandler和betweenValue
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -454,6 +544,7 @@ public class CdExpressMemberExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 构造函数，初始化condition、value、secondValue和betweenValue
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

src/main/java/com/xmomen/module/base/entity/CdItem.java

@@ -13,134 +13,83 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_item")
 public class CdItem extends BaseMybatisModel {
-    /**
+
-     * 
+    // 商品ID
-     */
     private Integer id;
 
-    /**
+    // 商品编码
-     * 产品编号
-     */
     private String itemCode;
 
-    /**
+    // 商品分类ID
-     * 产品归属的类别
-     */
     private Integer cdCategoryId;
 
-    /**
+    // 商品名称
-     * 产品名称
-     */
     private String itemName;
 
-    /**
+    // 商品描述
-     * 产品描述
-     */
     private String itemDescribe;
 
-    /**
+    // 商品类型
-     * 产品类型(1-常规商品，2-组合商品)
-     */
     private Integer itemType;
 
-    /**
+    // 产量
-     * 生产地
-     */
     private String yieldly;
 
-    /**
+    // 规格
-     * 产品规格
-     */
     private String spec;
 
-    /**
+    // 基准价格
-     * 基础价格
-     */
     private BigDecimal basePrice;
 
-    /**
+    // 会员价格
-     * 会员价格
-     */
     private BigDecimal memberPrice;
 
-    /**
+    // 定价方式
-     * 计价方式
-     */
     private String pricingManner;
 
-    /**
+    // 销售状态
-     * 0-下架 1-上架
-     */
     private Integer sellStatus;
 
-    /**
+    // 销售单位
-     * 销售单位
-     */
     private String sellUnit;
 
-    /**
+    // 销售价格
-     * 销售金额
-     */
     private BigDecimal sellPrice;
 
-    /**
+    // 是否审核
-     * 0-未审核，1-审核
-     */
     private Integer isAudit;
 
-    /**
+    // 创建时间
-     * 录入时间
-     */
     private Date createDateTime;
 
-    /**
+    // 创建人编码
-     * 录入人
-     */
     private String createUserCode;
 
-    /**
+    // 质检人
-     * 采摘人
-     */
     private String caizaiUser;
 
-    /**
+    // 检测人
-     * 检测人
-     */
     private String jianceUser;
 
-    /**
+    // 农残率
-     * 农残率
-     */
     private String nongCanLv;
 
-    /**
+    // 养殖成分
-     * 营养成分
-     */
     private String yiYangChenFen;
 
-    /**
+    // 保质期
-     * 保质期
-     */
     private Integer baoZhiQi;
 
-    /**
+    // 适用人群
-     * 适应人群
-     */
     private String shiYiRenQun;
 
-    /**
+    // 限时抢购
-     * 限时抢购
-     */
     private Integer xianShiQiangGou;
 
-    /**
+    // 新品常鲜
-     * 新品尝鲜
-     */
     private Integer xinPinChangXian;
 
-    /**
+    // 优惠推荐
-     * 热卖推荐
-     */
     private Integer reMaiTuiJian;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdItemDetail.java

@@ -11,19 +11,14 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_item_detail")
 public class CdItemDetail extends BaseMybatisModel {
-    /**
+
-     * 主键
+    // 主键
-     */
     private Integer id;
 
-    /**
+    // cd_item表的主键
-     * 商品ID
-     */
     private Integer cdItemId;
 
-    /**
+    // 项目详情内容
-     * 商品的详细内容
-     */
     private String itemDetailContent;
 
     @Column(name = "id")

src/main/java/com/xmomen/module/base/entity/CdItemDetailExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义CdItemDetailExample类，继承BaseMybatisExample类
 public class CdItemDetailExample extends BaseMybatisExample {
+    // 定义orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria变量
     public CdItemDetailExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause变量
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause变量
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct变量
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct变量
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria变量
     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 +66,46 @@ public class CdItemDetailExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义GeneratedCriteria内部类
     protected abstract static class GeneratedCriteria {
+        // 定义criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria变量
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         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 +113,7 @@ public class CdItemDetailExample extends BaseMybatisExample {
             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 +121,7 @@ public class CdItemDetailExample extends BaseMybatisExample {
             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,127 +129,152 @@ public class CdItemDetailExample extends BaseMybatisExample {
             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(Integer value) {
             addCriterion("id =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否不等于指定值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("id <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否大于指定值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("id >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否大于等于指定值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("id >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否小于指定值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("id <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否小于等于指定值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("id <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否在指定范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("id in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否不在指定范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("id not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否在指定范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("id between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否不在指定范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("id not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否为空
         public Criteria andCdItemIdIsNull() {
             addCriterion("cd_item_id is null");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否不为空
         public Criteria andCdItemIdIsNotNull() {
             addCriterion("cd_item_id is not null");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否等于指定值
         public Criteria andCdItemIdEqualTo(Integer value) {
             addCriterion("cd_item_id =", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否不等于指定值
         public Criteria andCdItemIdNotEqualTo(Integer value) {
             addCriterion("cd_item_id <>", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否大于指定值
         public Criteria andCdItemIdGreaterThan(Integer value) {
             addCriterion("cd_item_id >", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否大于等于指定值
         public Criteria andCdItemIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("cd_item_id >=", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否小于指定值
         public Criteria andCdItemIdLessThan(Integer value) {
             addCriterion("cd_item_id <", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否小于等于指定值
         public Criteria andCdItemIdLessThanOrEqualTo(Integer value) {
             addCriterion("cd_item_id <=", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否在指定范围内
         public Criteria andCdItemIdIn(List<Integer> values) {
             addCriterion("cd_item_id in", values, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否不在指定范围内
         public Criteria andCdItemIdNotIn(List<Integer> values) {
             addCriterion("cd_item_id not in", values, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否在指定范围内
         public Criteria andCdItemIdBetween(Integer value1, Integer value2) {
             addCriterion("cd_item_id between", value1, value2, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断cdItemId是否不在指定范围内
         public Criteria andCdItemIdNotBetween(Integer value1, Integer value2) {
             addCriterion("cd_item_id not between", value1, value2, "cdItemId");
             return (Criteria) this;
         }
     }
 
+    // 定义Criteria内部类
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -233,6 +282,7 @@ public class CdItemDetailExample extends BaseMybatisExample {
         }
     }
 
+    // 定义Criterion内部类
     public static class Criterion {
         private String condition;
 
@@ -250,38 +300,47 @@ public class CdItemDetailExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取condition变量
         public String getCondition() {
             return condition;
         }
 
+        // 获取value变量
         public Object getValue() {
             return value;
         }
 
+        // 获取secondValue变量
         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;
         }
 
+        // 获取typeHandler变量
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，初始化condition变量
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -289,6 +348,7 @@ public class CdItemDetailExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 构造函数，初始化condition、value和typeHandler变量
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -301,10 +361,12 @@ public class CdItemDetailExample extends BaseMybatisExample {
             }
         }
 
+        // 构造函数，初始化condition和value变量
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，初始化condition、value、secondValue和typeHandler变量
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -314,6 +376,7 @@ public class CdItemDetailExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 构造函数，初始化condition、value和secondValue变量
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

src/main/java/com/xmomen/module/base/entity/CdItemRef.java

@@ -11,34 +11,22 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_item_ref")
 public class CdItemRef extends BaseMybatisModel {
-    /**
+    // 主键ID
-     * 
-     */
     private Integer cdItemRefId;
 
-    /**
+    // 引用类型
-     * 拓展类型
-     */
     private String refType;
 
-    /**
+    // 引用名称
-     * 拓展描述
-     */
     private String refName;
 
-    /**
+    // 引用值
-     * 拓展值
-     */
     private String refValue;
 
-    /**
+    // 引用ID
-     * 对应产品
-     */
     private Integer cdItemId;
 
-    /**
+    // 引用数量
-     * 份数
-     */
     private Integer refCount;
 
     @Column(name = "CD_ITEM_REF_ID")

src/main/java/com/xmomen/module/base/entity/CdItemRefExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义CdItemRefExample类，继承BaseMybatisExample类
 public class CdItemRefExample extends BaseMybatisExample {
+    // 定义orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria变量
     public CdItemRefExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause变量
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause变量
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct变量
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct变量
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria变量
     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 +66,46 @@ public class CdItemRefExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义GeneratedCriteria内部类
     protected abstract static class GeneratedCriteria {
+        // 定义criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria变量
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         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 +113,7 @@ public class CdItemRefExample extends BaseMybatisExample {
             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 +121,7 @@ public class CdItemRefExample extends BaseMybatisExample {
             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,392 +129,470 @@ public class CdItemRefExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否为空
         public Criteria andCdItemRefIdIsNull() {
             addCriterion("CD_ITEM_REF_ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否不为空
         public Criteria andCdItemRefIdIsNotNull() {
             addCriterion("CD_ITEM_REF_ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否等于某个值
         public Criteria andCdItemRefIdEqualTo(Integer value) {
             addCriterion("CD_ITEM_REF_ID =", value, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否不等于某个值
         public Criteria andCdItemRefIdNotEqualTo(Integer value) {
             addCriterion("CD_ITEM_REF_ID <>", value, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否大于某个值
         public Criteria andCdItemRefIdGreaterThan(Integer value) {
             addCriterion("CD_ITEM_REF_ID >", value, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否大于等于某个值
         public Criteria andCdItemRefIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_ITEM_REF_ID >=", value, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否小于某个值
         public Criteria andCdItemRefIdLessThan(Integer value) {
             addCriterion("CD_ITEM_REF_ID <", value, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否小于等于某个值
         public Criteria andCdItemRefIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_ITEM_REF_ID <=", value, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否在某个范围内
         public Criteria andCdItemRefIdIn(List<Integer> values) {
             addCriterion("CD_ITEM_REF_ID in", values, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否不在某个范围内
         public Criteria andCdItemRefIdNotIn(List<Integer> values) {
             addCriterion("CD_ITEM_REF_ID not in", values, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否在某个范围内
         public Criteria andCdItemRefIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_ITEM_REF_ID between", value1, value2, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_REF_ID是否不在某个范围内
         public Criteria andCdItemRefIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_ITEM_REF_ID not between", value1, value2, "cdItemRefId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否为空
         public Criteria andRefTypeIsNull() {
             addCriterion("REF_TYPE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否不为空
         public Criteria andRefTypeIsNotNull() {
             addCriterion("REF_TYPE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否等于某个值
         public Criteria andRefTypeEqualTo(String value) {
             addCriterion("REF_TYPE =", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否不等于某个值
         public Criteria andRefTypeNotEqualTo(String value) {
             addCriterion("REF_TYPE <>", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否大于某个值
         public Criteria andRefTypeGreaterThan(String value) {
             addCriterion("REF_TYPE >", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否大于等于某个值
         public Criteria andRefTypeGreaterThanOrEqualTo(String value) {
             addCriterion("REF_TYPE >=", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否小于某个值
         public Criteria andRefTypeLessThan(String value) {
             addCriterion("REF_TYPE <", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否小于等于某个值
         public Criteria andRefTypeLessThanOrEqualTo(String value) {
             addCriterion("REF_TYPE <=", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否包含某个值
         public Criteria andRefTypeLike(String value) {
             addCriterion("REF_TYPE like", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否不包含某个值
         public Criteria andRefTypeNotLike(String value) {
             addCriterion("REF_TYPE not like", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否在某个范围内
         public Criteria andRefTypeIn(List<String> values) {
             addCriterion("REF_TYPE in", values, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否不在某个范围内
         public Criteria andRefTypeNotIn(List<String> values) {
             addCriterion("REF_TYPE not in", values, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否在某个范围内
         public Criteria andRefTypeBetween(String value1, String value2) {
             addCriterion("REF_TYPE between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_TYPE是否不在某个范围内
         public Criteria andRefTypeNotBetween(String value1, String value2) {
             addCriterion("REF_TYPE not between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否为空
         public Criteria andRefNameIsNull() {
             addCriterion("REF_NAME is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否不为空
         public Criteria andRefNameIsNotNull() {
             addCriterion("REF_NAME is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否等于某个值
         public Criteria andRefNameEqualTo(String value) {
             addCriterion("REF_NAME =", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否不等于某个值
         public Criteria andRefNameNotEqualTo(String value) {
             addCriterion("REF_NAME <>", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否大于某个值
         public Criteria andRefNameGreaterThan(String value) {
             addCriterion("REF_NAME >", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否大于等于某个值
         public Criteria andRefNameGreaterThanOrEqualTo(String value) {
             addCriterion("REF_NAME >=", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否小于某个值
         public Criteria andRefNameLessThan(String value) {
             addCriterion("REF_NAME <", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否小于等于某个值
         public Criteria andRefNameLessThanOrEqualTo(String value) {
             addCriterion("REF_NAME <=", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否包含某个值
         public Criteria andRefNameLike(String value) {
             addCriterion("REF_NAME like", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否不包含某个值
         public Criteria andRefNameNotLike(String value) {
             addCriterion("REF_NAME not like", value, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否在某个范围内
         public Criteria andRefNameIn(List<String> values) {
             addCriterion("REF_NAME in", values, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否不在某个范围内
         public Criteria andRefNameNotIn(List<String> values) {
             addCriterion("REF_NAME not in", values, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否在某个范围内
         public Criteria andRefNameBetween(String value1, String value2) {
             addCriterion("REF_NAME between", value1, value2, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_NAME是否不在某个范围内
         public Criteria andRefNameNotBetween(String value1, String value2) {
             addCriterion("REF_NAME not between", value1, value2, "refName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否为空
         public Criteria andRefValueIsNull() {
             addCriterion("REF_VALUE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否不为空
         public Criteria andRefValueIsNotNull() {
             addCriterion("REF_VALUE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否等于某个值
         public Criteria andRefValueEqualTo(String value) {
             addCriterion("REF_VALUE =", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否不等于某个值
         public Criteria andRefValueNotEqualTo(String value) {
             addCriterion("REF_VALUE <>", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否大于某个值
         public Criteria andRefValueGreaterThan(String value) {
             addCriterion("REF_VALUE >", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否大于等于某个值
         public Criteria andRefValueGreaterThanOrEqualTo(String value) {
             addCriterion("REF_VALUE >=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否小于某个值
         public Criteria andRefValueLessThan(String value) {
             addCriterion("REF_VALUE <", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否小于等于某个值
         public Criteria andRefValueLessThanOrEqualTo(String value) {
             addCriterion("REF_VALUE <=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否包含某个值
         public Criteria andRefValueLike(String value) {
             addCriterion("REF_VALUE like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否不包含某个值
         public Criteria andRefValueNotLike(String value) {
             addCriterion("REF_VALUE not like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否在某个范围内
         public Criteria andRefValueIn(List<String> values) {
             addCriterion("REF_VALUE in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否不在某个范围内
         public Criteria andRefValueNotIn(List<String> values) {
             addCriterion("REF_VALUE not in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否在某个范围内
         public Criteria andRefValueBetween(String value1, String value2) {
             addCriterion("REF_VALUE between", value1, value2, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断REF_VALUE是否不在某个范围内
         public Criteria andRefValueNotBetween(String value1, String value2) {
             addCriterion("REF_VALUE not between", value1, value2, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否为空
         public Criteria andCdItemIdIsNull() {
             addCriterion("CD_ITEM_ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否不为空
         public Criteria andCdItemIdIsNotNull() {
             addCriterion("CD_ITEM_ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否等于某个值
         public Criteria andCdItemIdEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID =", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否不等于某个值
         public Criteria andCdItemIdNotEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID <>", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否大于某个值
         public Criteria andCdItemIdGreaterThan(Integer value) {
             addCriterion("CD_ITEM_ID >", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否大于等于某个值
         public Criteria andCdItemIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID >=", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否小于某个值
         public Criteria andCdItemIdLessThan(Integer value) {
             addCriterion("CD_ITEM_ID <", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否小于等于某个值
         public Criteria andCdItemIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID <=", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否在某个范围内
         public Criteria andCdItemIdIn(List<Integer> values) {
             addCriterion("CD_ITEM_ID in", values, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否不在某个范围内
         public Criteria andCdItemIdNotIn(List<Integer> values) {
             addCriterion("CD_ITEM_ID not in", values, "cdItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件，判断CD_ITEM_ID是否在某个范围内
         public Criteria andCdItemIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_ITEM_ID between", value1, value2, "cdItemId");
             return (Criteria) this;
         }
 
         public Criteria andCdItemIdNotBetween(Integer value1, Integer value2) {
+            // 添加条件：CD_ITEM_ID 不在 value1 和 value2 之间
             addCriterion("CD_ITEM_ID not between", value1, value2, "cdItemId");
             return (Criteria) this;
         }
 
         public Criteria andRefCountIsNull() {
+            // 添加条件：REF_COUNT 为空
             addCriterion("REF_COUNT is null");
             return (Criteria) this;
         }
 
         public Criteria andRefCountIsNotNull() {
+            // 添加条件：REF_COUNT 不为空
             addCriterion("REF_COUNT is not null");
             return (Criteria) this;
         }
 
         public Criteria andRefCountEqualTo(Integer value) {
+            // 添加条件：REF_COUNT 等于 value
             addCriterion("REF_COUNT =", value, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountNotEqualTo(Integer value) {
+            // 添加条件：REF_COUNT 不等于 value
             addCriterion("REF_COUNT <>", value, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountGreaterThan(Integer value) {
+            // 添加条件：REF_COUNT 大于 value
             addCriterion("REF_COUNT >", value, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountGreaterThanOrEqualTo(Integer value) {
+            // 添加条件：REF_COUNT 大于等于 value
             addCriterion("REF_COUNT >=", value, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountLessThan(Integer value) {
+            // 添加条件：REF_COUNT 小于 value
             addCriterion("REF_COUNT <", value, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountLessThanOrEqualTo(Integer value) {
+            // 添加条件：REF_COUNT 小于等于 value
             addCriterion("REF_COUNT <=", value, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountIn(List<Integer> values) {
+            // 添加条件：REF_COUNT 在 values 列表中
             addCriterion("REF_COUNT in", values, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountNotIn(List<Integer> values) {
+            // 添加条件：REF_COUNT 不在 values 列表中
             addCriterion("REF_COUNT not in", values, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountBetween(Integer value1, Integer value2) {
+            // 添加条件：REF_COUNT 在 value1 和 value2 之间
             addCriterion("REF_COUNT between", value1, value2, "refCount");
             return (Criteria) this;
         }
 
         public Criteria andRefCountNotBetween(Integer value1, Integer value2) {
+            // 添加条件：REF_COUNT 不在 value1 和 value2 之间
             addCriterion("REF_COUNT not between", value1, value2, "refCount");
             return (Criteria) this;
         }

src/main/java/com/xmomen/module/base/entity/CdManagerCompany.java

@@ -11,19 +11,14 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_manager_company")
 public class CdManagerCompany extends BaseMybatisModel {
-    /**
+
-     * 
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+    // 公司ID
-     * 单位
-     */
     private Integer cdCompanyId;
 
-    /**
+    // 管理员ID
-     * 客户经理
-     */
     private Integer cdManagerId;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdManagerCompanyExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义一个CdManagerCompanyExample类，继承自BaseMybatisExample类
 public class CdManagerCompanyExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria变量
     public CdManagerCompanyExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause变量的值
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause变量的值
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct变量的值
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct变量的值
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria变量的值
     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 +66,46 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建一个新的查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空oredCriteria变量和orderByClause变量和distinct变量的值
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义一个GeneratedCriteria内部类，用于存储查询条件
     protected abstract static class GeneratedCriteria {
+        // 定义一个criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria变量
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断是否有查询条件
         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 +113,7 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
             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 +121,7 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
             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,187 +129,224 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
             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(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否为空
         public Criteria andCdCompanyIdIsNull() {
             addCriterion("CD_COMPANY_ID is null");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否不为空
         public Criteria andCdCompanyIdIsNotNull() {
             addCriterion("CD_COMPANY_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否等于某个值
         public Criteria andCdCompanyIdEqualTo(Integer value) {
             addCriterion("CD_COMPANY_ID =", value, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否不等于某个值
         public Criteria andCdCompanyIdNotEqualTo(Integer value) {
             addCriterion("CD_COMPANY_ID <>", value, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否大于某个值
         public Criteria andCdCompanyIdGreaterThan(Integer value) {
             addCriterion("CD_COMPANY_ID >", value, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否大于等于某个值
         public Criteria andCdCompanyIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_COMPANY_ID >=", value, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否小于某个值
         public Criteria andCdCompanyIdLessThan(Integer value) {
             addCriterion("CD_COMPANY_ID <", value, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否小于等于某个值
         public Criteria andCdCompanyIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_COMPANY_ID <=", value, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否在某个范围内
         public Criteria andCdCompanyIdIn(List<Integer> values) {
             addCriterion("CD_COMPANY_ID in", values, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否不在某个范围内
         public Criteria andCdCompanyIdNotIn(List<Integer> values) {
             addCriterion("CD_COMPANY_ID not in", values, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否在某个范围内
         public Criteria andCdCompanyIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_COMPANY_ID between", value1, value2, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_COMPANY_ID是否不在某个范围内
         public Criteria andCdCompanyIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_COMPANY_ID not between", value1, value2, "cdCompanyId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否为空
         public Criteria andCdManagerIdIsNull() {
             addCriterion("CD_MANAGER_ID is null");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否不为空
         public Criteria andCdManagerIdIsNotNull() {
             addCriterion("CD_MANAGER_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否等于某个值
         public Criteria andCdManagerIdEqualTo(Integer value) {
             addCriterion("CD_MANAGER_ID =", value, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否不等于某个值
         public Criteria andCdManagerIdNotEqualTo(Integer value) {
             addCriterion("CD_MANAGER_ID <>", value, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否大于某个值
         public Criteria andCdManagerIdGreaterThan(Integer value) {
             addCriterion("CD_MANAGER_ID >", value, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否大于等于某个值
         public Criteria andCdManagerIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_MANAGER_ID >=", value, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否小于某个值
         public Criteria andCdManagerIdLessThan(Integer value) {
             addCriterion("CD_MANAGER_ID <", value, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否小于等于某个值
         public Criteria andCdManagerIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_MANAGER_ID <=", value, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否在某个范围内
         public Criteria andCdManagerIdIn(List<Integer> values) {
             addCriterion("CD_MANAGER_ID in", values, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否不在某个范围内
         public Criteria andCdManagerIdNotIn(List<Integer> values) {
             addCriterion("CD_MANAGER_ID not in", values, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否在某个范围内
         public Criteria andCdManagerIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_MANAGER_ID between", value1, value2, "cdManagerId");
             return (Criteria) this;
         }
 
+        // 判断CD_MANAGER_ID是否不在某个范围内
         public Criteria andCdManagerIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_MANAGER_ID not between", value1, value2, "cdManagerId");
             return (Criteria) this;
         }
     }
 
+    // 定义一个Criteria内部类，继承自GeneratedCriteria类
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -293,6 +354,7 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
         }
     }
 
+    // 定义一个Criterion内部类，用于存储查询条件
     public static class Criterion {
         private String condition;
 
@@ -310,38 +372,47 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取condition变量的值
         public String getCondition() {
             return condition;
         }
 
+        // 获取value变量的值
         public Object getValue() {
             return value;
         }
 
+        // 获取secondValue变量的值
         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;
         }
 
+        // 获取typeHandler变量的值
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，初始化condition变量和typeHandler变量和noValue变量
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -349,6 +420,7 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 构造函数，初始化condition变量和value变量和typeHandler变量和singleValue变量
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -361,10 +433,12 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
             }
         }
 
+        // 构造函数，初始化condition变量和value变量和singleValue变量
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，初始化condition变量和value变量和secondValue变量和typeHandler变量和betweenValue变量
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -374,6 +448,7 @@ public class CdManagerCompanyExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 构造函数，初始化condition变量和value变量和secondValue变量和betweenValue变量
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

src/main/java/com/xmomen/module/base/entity/CdMember.java

@@ -13,94 +13,58 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_member")
 public class CdMember extends BaseMybatisModel {
-    /**
+    // 会员ID
-     *
-     */
     private Integer id;
 
-    /**
+    // 会员名称
-     * 姓名
-     */
     private String name;
 
-    /**
+    // 会员密码
-     * 密码
-     */
     private String password;
 
-    /**
+    // 会员电话号码
-     * 手机号
-     */
     private String phoneNumber;
 
-    /**
+    // 会员地址
-     * 收货地址
-     */
     private String address;
 
-    /**
+    // 会员所属公司ID
-     * 所属单位
-     */
     private Integer cdCompanyId;
 
-    /**
+    // 会员所属用户ID
-     * 所属客服经理
-     */
     private Integer cdUserId;
 
-    /**
+    // 备用姓名
-     * 备用收货人
-     */
     private String spareName;
 
-    /**
+    // 备用姓名2
-     * 备用收货人2
-     */
     private String spareName2;
 
-    /**
+    // 备用电话
-     * 备用手机号1
-     */
     private String spareTel;
 
-    /**
+    // 备用电话2
-     * 备用手机号2
-     */
     private String spareTel2;
 
-    /**
+    // 电话号码
-     * 家庭固话
-     */
     private String telNumber;
 
-    /**
+    // 办公电话
-     * 办公室电话
-     */
     private String officeTel;
 
-    /**
+    // 备用地址
-     * 备用地址1
-     */
     private String spareAddress;
 
-    /**
+    // 备用地址2
-     * 备用地址2
-     */
     private String spareAddress2;
 
-    /**
+    // 标志
-     * 说明
-     */
     private String flag;
 
-    /**
+    // 会员类型
-     * 1-潜在客户，2-普通客户，3-优质客户
-     */
     private Integer memberType;
 
-    /**
+    // 邮箱
-     * 邮箱
-     */
     private String email;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdMemberCouponRelation.java

@@ -11,19 +11,14 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_member_coupon_relation")
 public class CdMemberCouponRelation extends BaseMybatisModel {
-    /**
+
-     * 主键
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+    // 会员ID
-     * 客户代码
-     */
     private Integer cdMemberId;
 
-    /**
+    // 优惠券编号
-     * 卡号
-     */
     private String couponNumber;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdMemberCouponRelationExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 会员优惠券关系实体类
 public class CdMemberCouponRelationExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数
     public CdMemberCouponRelationExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     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,17 +66,20 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
         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;
 
@@ -72,18 +88,22 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         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 +111,7 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
             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 +119,7 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
             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,197 +127,236 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
             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(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否为空
         public Criteria andCdMemberIdIsNull() {
             addCriterion("CD_MEMBER_ID is null");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否不为空
         public Criteria andCdMemberIdIsNotNull() {
             addCriterion("CD_MEMBER_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否等于某个值
         public Criteria andCdMemberIdEqualTo(Integer value) {
             addCriterion("CD_MEMBER_ID =", value, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否不等于某个值
         public Criteria andCdMemberIdNotEqualTo(Integer value) {
             addCriterion("CD_MEMBER_ID <>", value, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否大于某个值
         public Criteria andCdMemberIdGreaterThan(Integer value) {
             addCriterion("CD_MEMBER_ID >", value, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否大于等于某个值
         public Criteria andCdMemberIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_MEMBER_ID >=", value, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否小于某个值
         public Criteria andCdMemberIdLessThan(Integer value) {
             addCriterion("CD_MEMBER_ID <", value, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否小于等于某个值
         public Criteria andCdMemberIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_MEMBER_ID <=", value, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否在某个范围内
         public Criteria andCdMemberIdIn(List<Integer> values) {
             addCriterion("CD_MEMBER_ID in", values, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否不在某个范围内
         public Criteria andCdMemberIdNotIn(List<Integer> values) {
             addCriterion("CD_MEMBER_ID not in", values, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否在某个范围内
         public Criteria andCdMemberIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_MEMBER_ID between", value1, value2, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断会员ID是否不在某个范围内
         public Criteria andCdMemberIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_MEMBER_ID not between", value1, value2, "cdMemberId");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否为空
         public Criteria andCouponNumberIsNull() {
             addCriterion("COUPON_NUMBER is null");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否不为空
         public Criteria andCouponNumberIsNotNull() {
             addCriterion("COUPON_NUMBER is not null");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否等于某个值
         public Criteria andCouponNumberEqualTo(String value) {
             addCriterion("COUPON_NUMBER =", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否不等于某个值
         public Criteria andCouponNumberNotEqualTo(String value) {
             addCriterion("COUPON_NUMBER <>", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否大于某个值
         public Criteria andCouponNumberGreaterThan(String value) {
             addCriterion("COUPON_NUMBER >", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否大于等于某个值
         public Criteria andCouponNumberGreaterThanOrEqualTo(String value) {
             addCriterion("COUPON_NUMBER >=", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否小于某个值
         public Criteria andCouponNumberLessThan(String value) {
             addCriterion("COUPON_NUMBER <", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否小于等于某个值
         public Criteria andCouponNumberLessThanOrEqualTo(String value) {
             addCriterion("COUPON_NUMBER <=", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否包含某个值
         public Criteria andCouponNumberLike(String value) {
             addCriterion("COUPON_NUMBER like", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否不包含某个值
         public Criteria andCouponNumberNotLike(String value) {
             addCriterion("COUPON_NUMBER not like", value, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否在某个范围内
         public Criteria andCouponNumberIn(List<String> values) {
             addCriterion("COUPON_NUMBER in", values, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否不在某个范围内
         public Criteria andCouponNumberNotIn(List<String> values) {
             addCriterion("COUPON_NUMBER not in", values, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否在某个范围内
         public Criteria andCouponNumberBetween(String value1, String value2) {
             addCriterion("COUPON_NUMBER between", value1, value2, "couponNumber");
             return (Criteria) this;
         }
 
+        // 判断优惠券编号是否不在某个范围内
         public Criteria andCouponNumberNotBetween(String value1, String value2) {
             addCriterion("COUPON_NUMBER not between", value1, value2, "couponNumber");
             return (Criteria) this;
         }
     }
 
+    // 生成查询条件
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -303,6 +364,7 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
         }
     }
 
+    // 生成查询条件
     public static class Criterion {
         private String condition;
 
@@ -320,38 +382,47 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
 
         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;
@@ -359,6 +430,7 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 构造函数
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -371,10 +443,12 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
             }
         }
 
+        // 构造函数
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -384,6 +458,7 @@ public class CdMemberCouponRelationExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 构造函数
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

src/main/java/com/xmomen/module/base/entity/CdPlan.java

@@ -13,64 +13,41 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_plan")
 public class CdPlan extends BaseMybatisModel {
-    /**
+
-     * 主键
+    // 计划ID
-     */
     private Integer id;
 
-    /**
+    // 计划名称
-     * 计划名称
-     */
     private String planName;
 
-    /**
+    // 创建人
-     * 计划创建人
-     */
     private String createUser;
 
-    /**
+    // 创建时间
-     * 计划创建时间
-     */
     private Date createTime;
 
-    /**
+    // 配送类型
-     * 配送频率（1-一天,2-一周，3-一月）
-     */
     private Integer deliveryType;
 
-    /**
+    // 配送时间
-     * 配送时间(一周的星期几，一月的几号等）
-     */
     private String deliveryTime;
 
-    /**
+    // 配送数量
-     * 配送的次数
-     */
     private Integer deliverCount;
 
-    /**
+    // 价格
-     * 价格
-     */
     private BigDecimal price;
 
-    /**
+    // 是否随机
-     * 是否随机
-     */
     private Integer isRandom;
 
-    /**
+    // CD分类ID
-     * 产品归属的类别
-     */
     private Integer cdCategoryId;
 
-    /**
+    // 随机数
-     * 随机数
-     */
     private Integer randomNum;
 
-    /**
+    // 开始时间
-     * 起效时间
-     */
     private Date beginTime;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdPlanItem.java

@@ -11,24 +11,17 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "cd_plan_item")
 public class CdPlanItem extends BaseMybatisModel {
-    /**
+
-     * 
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+    // 计划ID
-     * 计划ID
-     */
     private Integer cdPlanId;
 
-    /**
+    // 项目ID
-     * 搭配的产品
-     */
     private Integer cdItemId;
 
-    /**
+    // 数量值
-     * 份数
-     */
     private Integer countValue;
 
     @Column(name = "ID")

src/main/java/com/xmomen/module/base/entity/CdPlanItemExample.java

@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义CdPlanItemExample类，继承BaseMybatisExample类
 public class CdPlanItemExample extends BaseMybatisExample {
+    // 定义orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria变量
     public CdPlanItemExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause变量
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause变量
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct变量
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct变量
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria变量
     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 +66,46 @@ public class CdPlanItemExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义GeneratedCriteria内部类
     protected abstract static class GeneratedCriteria {
+        // 定义criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria变量
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         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 +113,7 @@ public class CdPlanItemExample extends BaseMybatisExample {
             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 +121,7 @@ public class CdPlanItemExample extends BaseMybatisExample {
             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,247 +129,296 @@ public class CdPlanItemExample extends BaseMybatisExample {
             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(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于指定值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于指定值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于指定值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于指定值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于指定值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在指定范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在指定范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在指定范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在指定范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否为空
         public Criteria andCdPlanIdIsNull() {
             addCriterion("CD_PLAN_ID is null");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否不为空
         public Criteria andCdPlanIdIsNotNull() {
             addCriterion("CD_PLAN_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否等于指定值
         public Criteria andCdPlanIdEqualTo(Integer value) {
             addCriterion("CD_PLAN_ID =", value, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否不等于指定值
         public Criteria andCdPlanIdNotEqualTo(Integer value) {
             addCriterion("CD_PLAN_ID <>", value, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否大于指定值
         public Criteria andCdPlanIdGreaterThan(Integer value) {
             addCriterion("CD_PLAN_ID >", value, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否大于等于指定值
         public Criteria andCdPlanIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_PLAN_ID >=", value, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否小于指定值
         public Criteria andCdPlanIdLessThan(Integer value) {
             addCriterion("CD_PLAN_ID <", value, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否小于等于指定值
         public Criteria andCdPlanIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_PLAN_ID <=", value, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否在指定范围内
         public Criteria andCdPlanIdIn(List<Integer> values) {
             addCriterion("CD_PLAN_ID in", values, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否不在指定范围内
         public Criteria andCdPlanIdNotIn(List<Integer> values) {
             addCriterion("CD_PLAN_ID not in", values, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否在指定范围内
         public Criteria andCdPlanIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_PLAN_ID between", value1, value2, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_PLAN_ID是否不在指定范围内
         public Criteria andCdPlanIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_PLAN_ID not between", value1, value2, "cdPlanId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否为空
         public Criteria andCdItemIdIsNull() {
             addCriterion("CD_ITEM_ID is null");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否不为空
         public Criteria andCdItemIdIsNotNull() {
             addCriterion("CD_ITEM_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否等于指定值
         public Criteria andCdItemIdEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID =", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否不等于指定值
         public Criteria andCdItemIdNotEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID <>", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否大于指定值
         public Criteria andCdItemIdGreaterThan(Integer value) {
             addCriterion("CD_ITEM_ID >", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否大于等于指定值
         public Criteria andCdItemIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID >=", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否小于指定值
         public Criteria andCdItemIdLessThan(Integer value) {
             addCriterion("CD_ITEM_ID <", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否小于等于指定值
         public Criteria andCdItemIdLessThanOrEqualTo(Integer value) {
             addCriterion("CD_ITEM_ID <=", value, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否在指定范围内
         public Criteria andCdItemIdIn(List<Integer> values) {
             addCriterion("CD_ITEM_ID in", values, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否不在指定范围内
         public Criteria andCdItemIdNotIn(List<Integer> values) {
             addCriterion("CD_ITEM_ID not in", values, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否在指定范围内
         public Criteria andCdItemIdBetween(Integer value1, Integer value2) {
             addCriterion("CD_ITEM_ID between", value1, value2, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断CD_ITEM_ID是否不在指定范围内
         public Criteria andCdItemIdNotBetween(Integer value1, Integer value2) {
             addCriterion("CD_ITEM_ID not between", value1, value2, "cdItemId");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否为空
         public Criteria andCountValueIsNull() {
             addCriterion("COUNT_VALUE is null");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否不为空
         public Criteria andCountValueIsNotNull() {
             addCriterion("COUNT_VALUE is not null");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否等于指定值
         public Criteria andCountValueEqualTo(Integer value) {
             addCriterion("COUNT_VALUE =", value, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否不等于指定值
         public Criteria andCountValueNotEqualTo(Integer value) {
             addCriterion("COUNT_VALUE <>", value, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否大于指定值
         public Criteria andCountValueGreaterThan(Integer value) {
             addCriterion("COUNT_VALUE >", value, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否大于等于指定值
         public Criteria andCountValueGreaterThanOrEqualTo(Integer value) {
             addCriterion("COUNT_VALUE >=", value, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否小于指定值
         public Criteria andCountValueLessThan(Integer value) {
             addCriterion("COUNT_VALUE <", value, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否小于等于指定值
         public Criteria andCountValueLessThanOrEqualTo(Integer value) {
             addCriterion("COUNT_VALUE <=", value, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否在指定范围内
         public Criteria andCountValueIn(List<Integer> values) {
             addCriterion("COUNT_VALUE in", values, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否不在指定范围内
         public Criteria andCountValueNotIn(List<Integer> values) {
             addCriterion("COUNT_VALUE not in", values, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否在指定范围内
         public Criteria andCountValueBetween(Integer value1, Integer value2) {
             addCriterion("COUNT_VALUE between", value1, value2, "countValue");
             return (Criteria) this;
         }
 
+        // 判断COUNT_VALUE是否不在指定范围内
         public Criteria andCountValueNotBetween(Integer value1, Integer value2) {
             addCriterion("COUNT_VALUE not between", value1, value2, "countValue");
             return (Criteria) this;
         }
     }
 
+    // 定义Criteria内部类
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -353,6 +426,7 @@ public class CdPlanItemExample extends BaseMybatisExample {
         }
     }
 
+    // 定义Criterion内部类
     public static class Criterion {
         private String condition;
 
@@ -370,38 +444,47 @@ public class CdPlanItemExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取condition变量
         public String getCondition() {
             return condition;
         }
 
+        // 获取value变量
         public Object getValue() {
             return value;
         }
 
+        // 获取secondValue变量
         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;
         }
 
+        // 获取typeHandler变量
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，初始化condition变量
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -409,6 +492,7 @@ public class CdPlanItemExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 构造函数，初始化condition、value和typeHandler变量
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -421,10 +505,12 @@ public class CdPlanItemExample extends BaseMybatisExample {
             }
         }
 
+        // 构造函数，初始化condition和value变量
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，初始化condition、value、secondValue和typeHandler变量
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -434,6 +520,7 @@ public class CdPlanItemExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 构造函数，初始化condition、value和secondValue变量
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }

src/main/java/com/xmomen/module/base/entity/ChildItemModel.java

@@ -2,32 +2,45 @@ package com.xmomen.module.base.entity;
 
 import java.io.Serializable;
 
+// 实现序列化接口
 public class ChildItemModel implements Serializable {
+	// 子项ID
 	private Integer childItemId;
+	// 子项名称
 	private String itemName;
+	// 子项编码
 	private String itemCode;
+	// 子项类别
 	private String itemCategory;
+	// 获取子项ID
 	public Integer getChildItemId() {
 		return childItemId;
 	}
+	// 设置子项ID
 	public void setChildItemId(Integer childItemId) {
 		this.childItemId = childItemId;
 	}
+	// 获取子项名称
 	public String getItemName() {
 		return itemName;
 	}
+	// 设置子项名称
 	public void setItemName(String itemName) {
 		this.itemName = itemName;
 	}
+	// 获取子项编码
 	public String getItemCode() {
 		return itemCode;
 	}
+	// 设置子项编码
 	public void setItemCode(String itemCode) {
 		this.itemCode = itemCode;
 	}
+	// 获取子项类别
 	public String getItemCategory() {
 		return itemCategory;
 	}
+	// 设置子项类别
 	public void setItemCategory(String itemCategory) {
 		this.itemCategory = itemCategory;
 	}