Compare commits

...

10 Commits
fl ... qwer

@ -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 {
//密码重试缓存

@ -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 {
// 用户名

@ -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

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

@ -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查询用户

@ -423,52 +423,61 @@ public class CdCouponRefExample extends BaseMybatisExample {
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) {
// 判断REF_TYPE是否在某个范围内
addCriterion("REF_TYPE between", value1, value2, "refType");
return (Criteria) this;
}
// 判断REF_TYPE是否不在某个范围内
public Criteria andRefTypeNotBetween(String value1, String value2) {
// 判断REF_TYPE是否不在某个范围内
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");
// 判断REF_NAME是否不为空
return (Criteria) this;
}
// 判断REF_NAME是否等于某个值
public Criteria andRefNameEqualTo(String value) {
addCriterion("REF_NAME =", value, "refName");
// 判断REF_NAME是否等于某个值
return (Criteria) this;
}
// 判断REF_NAME是否不等于某个值
public Criteria andRefNameNotEqualTo(String value) {
addCriterion("REF_NAME <>", value, "refName");
// 判断REF_NAME是否不等于某个值
return (Criteria) this;
}
// 判断REF_NAME是否大于某个值
public Criteria andRefNameGreaterThan(String value) {
addCriterion("REF_NAME >", value, "refName");
// 判断REF_NAME是否大于某个值
return (Criteria) this;
}
// 判断REF_NAME是否大于等于某个值
public Criteria andRefNameGreaterThanOrEqualTo(String value) {
// 添加条件REF_NAME大于等于value
addCriterion("REF_NAME >=", value, "refName");
@ -488,112 +497,132 @@ public class CdCouponRefExample extends BaseMybatisExample {
return (Criteria) this;
}
// 判断REF_NAME是否包含某个值
public Criteria andRefNameLike(String value) {
addCriterion("REF_NAME like", value, "refName");
return (Criteria) this;
// 判断REF_NAME是否包含某个值
}
// 判断REF_NAME是否不包含某个值
public Criteria andRefNameNotLike(String value) {
addCriterion("REF_NAME not like", value, "refName");
return (Criteria) this;
// 判断REF_NAME是否不包含某个值
}
// 判断REF_NAME是否在某个范围内
public Criteria andRefNameIn(List<String> values) {
addCriterion("REF_NAME in", values, "refName");
return (Criteria) this;
// 判断REF_NAME是否在某个范围内
}
// 判断REF_NAME是否不在某个范围内
public Criteria andRefNameNotIn(List<String> values) {
addCriterion("REF_NAME not in", values, "refName");
return (Criteria) this;
// 判断REF_NAME是否不在某个范围内
}
// 判断REF_NAME是否在某个范围内
public Criteria andRefNameBetween(String value1, String value2) {
addCriterion("REF_NAME between", value1, value2, "refName");
return (Criteria) this;
// 判断REF_NAME是否在某个范围内
}
// 判断REF_NAME是否不在某个范围内
public Criteria andRefNameNotBetween(String value1, String value2) {
addCriterion("REF_NAME not between", value1, value2, "refName");
return (Criteria) this;
// 判断REF_NAME是否不在某个范围内
}
// 判断REF_VALUE是否为空
public Criteria andRefValueIsNull() {
addCriterion("REF_VALUE is null");
return (Criteria) this;
// 判断REF_VALUE是否为空
}
// 判断REF_VALUE是否不为空
public Criteria andRefValueIsNotNull() {
addCriterion("REF_VALUE is not null");
return (Criteria) this;
// 判断REF_VALUE是否不为空
}
// 判断REF_VALUE是否等于某个值
public Criteria andRefValueEqualTo(String value) {
addCriterion("REF_VALUE =", value, "refValue");
return (Criteria) this;
// 判断REF_VALUE是否等于某个值
}
// 判断REF_VALUE是否不等于某个值
public Criteria andRefValueNotEqualTo(String value) {
addCriterion("REF_VALUE <>", value, "refValue");
return (Criteria) this;
// 判断REF_VALUE是否不等于某个值
}
// 判断REF_VALUE是否大于某个值
public Criteria andRefValueGreaterThan(String value) {
addCriterion("REF_VALUE >", value, "refValue");
return (Criteria) this;
// 判断REF_VALUE是否大于某个值
}
// 判断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;

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

@ -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")

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

@ -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")

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

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

@ -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")

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

@ -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")

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

@ -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")

@ -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")

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

@ -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")

@ -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")

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

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

@ -19,12 +19,10 @@ import com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper;
public class ReceivingCodeRequestController {
@Autowired
MybatisDao mybatisDao;
/**
*
* @param id
* @return
*/
/*
*/
@RequestMapping(value = "/receivingCodeRequest", method = RequestMethod.GET)
@Log(actionName = "查询收货码请求")
public Page<TbReceivingCodeRequest> getExpressList(@RequestParam(value = "limit") Integer limit,
@ -38,6 +36,7 @@ public class ReceivingCodeRequestController {
map.put("keyword", keyword);
map.put("requestTimeStart", requestTimeStart);
map.put("requestTimeEnd", requestTimeEnd);
// 调用mybatisDao的selectPage方法传入ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList"作为参数map作为参数limit和offset作为参数
return (Page<TbReceivingCodeRequest>) mybatisDao.selectPage(ReceivingCodeRequestMapper.ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList", map, limit, offset);
}

@ -22,9 +22,7 @@ import com.xmomen.module.receipt.model.ReturnOrderModel;
import com.xmomen.module.receipt.model.ReturnOrderQuery;
import com.xmomen.module.receipt.service.ReturnOrderService;
/**
* Created by Jeng on 2016/3/30.
*/
@RestController
public class ReturnOrderController {
@ -34,13 +32,8 @@ public class ReturnOrderController {
@Autowired
MybatisDao mybatisDao;
/**
* 退
* @param limit
* @param offset
* @param keyword
* @return
*/
// 查询退货订单列表
@RequestMapping(value = "/returnOrder", method = RequestMethod.GET)
@Log(actionName = "查询退货订单列表")
public Page<ReturnOrderModel> getUserList(@RequestParam(value = "limit") Integer limit,
@ -50,29 +43,22 @@ public class ReturnOrderController {
@RequestParam(value = "returnTimeStart",required = false) String returnTimeStart,
@RequestParam(value = "returnTimeEnd",required = false) String returnTimeEnd
){
// 创建退货订单查询对象
ReturnOrderQuery orderQuery = new ReturnOrderQuery();
orderQuery.setKeyword(keyword);
// 如果退货时间开始不为空,则设置退货时间开始
if(StringUtilsExt.isNotBlank(returnTimeStart)){
orderQuery.setReturnTimeStart(returnTimeStart);
}
// 如果退货时间结束不为空,则设置退货时间结束
if(StringUtilsExt.isNotBlank(returnTimeEnd)){
orderQuery.setReturnTimeEnd(returnTimeEnd);
}
//客服经理过滤 如果有客服组权限则不过滤
// if(SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_MANAGER_PERMISSION_CODE) && !SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_PERMISSION_CODE)){
// Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
// orderQuery.setCreateUserId(userId);
// }
}
// 调用退货订单服务,获取退货订单列表
return returnOrderService.getReturnOrderList(orderQuery, limit, offset);
}
/**
* 退
* @param limit
* @param offset
* @param orderNo
* @return
*/
@RequestMapping(value = "/returnOrder/{id}/item", method = RequestMethod.GET)
@Log(actionName = "查询退货订单商品列表")
public Page<TbReturnOrderItem> getUserList(@RequestParam(value = "limit") Integer limit,
@ -83,12 +69,7 @@ public class ReturnOrderController {
return mybatisDao.selectPageByModel(returnOrderItem, limit, offset);
}
/**
* 退
* @param orderNo
* @param statusCd
* @return
*/
@RequestMapping(value = "/returnOrder/{id}/audit", method = RequestMethod.POST)
@Log(actionName = "审核退货订单")
public void auditReturnOrder(@PathVariable(value = "id") Integer id,
@ -96,20 +77,16 @@ public class ReturnOrderController {
this.returnOrderService.auditReturnOrder(id,statusCd);
}
/**
* 退
* @param boxNo
*/
// 调用退货订单服务,审核退货订单
@RequestMapping(value ="/returnOrder/returnOrderShouhuo",method = RequestMethod.PUT)
@Log(actionName = "退货收货扫描操作")
public ReturnOrderModel returnOrderShouhuo(@RequestParam(value = "boxNo")String boxNo){
return this.returnOrderService.returnOrderShouhuo(boxNo);
}
/**
* 退
* @param boxNo
*/
// 调用退货订单服务,退货收货扫描操作
@RequestMapping(value ="/returnOrder/shouhuo",method = RequestMethod.PUT)
@Log(actionName = "退货收货操作")
public void orderNo(@RequestParam(value = "orderNo")String orderNo){

@ -12,34 +12,27 @@ import javax.persistence.Version;
@Entity
@Table(name = "tb_receiving_code_request")
public class TbReceivingCodeRequest extends BaseMybatisModel {
/**
*
*/
// 主键ID
private Integer id;
/**
*
*/
// 订单号
private String orderNo;
/**
*
*/
// 请求用户
private String requestUser;
/**
*
*/
// 请求时间
private Date requestTime;
/**
*
*/
// 请求电话
private String requestPhone;
/**
*
*/
// 请求快递ID
private Integer requestExpressId;
@Column(name = "id")

@ -5,47 +5,60 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
// 定义一个名为TbReceivingCodeRequestExample的类继承自BaseMybatisExample
public class TbReceivingCodeRequestExample extends BaseMybatisExample {
// 定义一个orderByClause变量用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria
public TbReceivingCodeRequestExample() {
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) {
@ -54,37 +67,46 @@ public class TbReceivingCodeRequestExample 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");
@ -92,6 +114,7 @@ public class TbReceivingCodeRequestExample 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");
@ -99,6 +122,7 @@ public class TbReceivingCodeRequestExample 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");
@ -106,366 +130,439 @@ public class TbReceivingCodeRequestExample 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;
}
// 判断orderNo是否为空
public Criteria andOrderNoIsNull() {
addCriterion("order_no is null");
return (Criteria) this;
}
// 判断orderNo是否不为空
public Criteria andOrderNoIsNotNull() {
addCriterion("order_no is not null");
return (Criteria) this;
}
// 判断orderNo是否等于某个值
public Criteria andOrderNoEqualTo(String value) {
addCriterion("order_no =", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不等于某个值
public Criteria andOrderNoNotEqualTo(String value) {
addCriterion("order_no <>", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否大于某个值
public Criteria andOrderNoGreaterThan(String value) {
addCriterion("order_no >", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否大于等于某个值
public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
addCriterion("order_no >=", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否小于某个值
public Criteria andOrderNoLessThan(String value) {
addCriterion("order_no <", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否小于等于某个值
public Criteria andOrderNoLessThanOrEqualTo(String value) {
addCriterion("order_no <=", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否包含某个值
public Criteria andOrderNoLike(String value) {
addCriterion("order_no like", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不包含某个值
public Criteria andOrderNoNotLike(String value) {
addCriterion("order_no not like", value, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否在某个范围内
public Criteria andOrderNoIn(List<String> values) {
addCriterion("order_no in", values, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不在某个范围内
public Criteria andOrderNoNotIn(List<String> values) {
addCriterion("order_no not in", values, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否在某个范围内
public Criteria andOrderNoBetween(String value1, String value2) {
addCriterion("order_no between", value1, value2, "orderNo");
return (Criteria) this;
}
// 判断orderNo是否不在某个范围内
public Criteria andOrderNoNotBetween(String value1, String value2) {
addCriterion("order_no not between", value1, value2, "orderNo");
return (Criteria) this;
}
// 判断requestUser是否为空
public Criteria andRequestUserIsNull() {
addCriterion("request_user is null");
return (Criteria) this;
}
// 判断requestUser是否不为空
public Criteria andRequestUserIsNotNull() {
addCriterion("request_user is not null");
return (Criteria) this;
}
// 判断requestUser是否等于某个值
public Criteria andRequestUserEqualTo(String value) {
addCriterion("request_user =", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不等于某个值
public Criteria andRequestUserNotEqualTo(String value) {
addCriterion("request_user <>", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否大于某个值
public Criteria andRequestUserGreaterThan(String value) {
addCriterion("request_user >", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否大于等于某个值
public Criteria andRequestUserGreaterThanOrEqualTo(String value) {
addCriterion("request_user >=", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否小于某个值
public Criteria andRequestUserLessThan(String value) {
addCriterion("request_user <", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否小于等于某个值
public Criteria andRequestUserLessThanOrEqualTo(String value) {
addCriterion("request_user <=", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否包含某个值
public Criteria andRequestUserLike(String value) {
addCriterion("request_user like", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不包含某个值
public Criteria andRequestUserNotLike(String value) {
addCriterion("request_user not like", value, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否在某个范围内
public Criteria andRequestUserIn(List<String> values) {
addCriterion("request_user in", values, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不在某个范围内
public Criteria andRequestUserNotIn(List<String> values) {
addCriterion("request_user not in", values, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否在某个范围内
public Criteria andRequestUserBetween(String value1, String value2) {
addCriterion("request_user between", value1, value2, "requestUser");
return (Criteria) this;
}
// 判断requestUser是否不在某个范围内
public Criteria andRequestUserNotBetween(String value1, String value2) {
addCriterion("request_user not between", value1, value2, "requestUser");
return (Criteria) this;
}
// 判断requestTime是否为空
public Criteria andRequestTimeIsNull() {
addCriterion("request_time is null");
return (Criteria) this;
}
// 判断requestTime是否不为空
public Criteria andRequestTimeIsNotNull() {
addCriterion("request_time is not null");
return (Criteria) this;
}
// 判断requestTime是否等于某个值
public Criteria andRequestTimeEqualTo(Date value) {
addCriterion("request_time =", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否不等于某个值
public Criteria andRequestTimeNotEqualTo(Date value) {
addCriterion("request_time <>", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否大于某个值
public Criteria andRequestTimeGreaterThan(Date value) {
addCriterion("request_time >", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否大于等于某个值
public Criteria andRequestTimeGreaterThanOrEqualTo(Date value) {
addCriterion("request_time >=", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否小于某个值
public Criteria andRequestTimeLessThan(Date value) {
addCriterion("request_time <", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否小于等于某个值
public Criteria andRequestTimeLessThanOrEqualTo(Date value) {
addCriterion("request_time <=", value, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否在某个范围内
public Criteria andRequestTimeIn(List<Date> values) {
addCriterion("request_time in", values, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否不在某个范围内
public Criteria andRequestTimeNotIn(List<Date> values) {
addCriterion("request_time not in", values, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否在某个范围内
public Criteria andRequestTimeBetween(Date value1, Date value2) {
addCriterion("request_time between", value1, value2, "requestTime");
return (Criteria) this;
}
// 判断requestTime是否不在某个范围内
public Criteria andRequestTimeNotBetween(Date value1, Date value2) {
addCriterion("request_time not between", value1, value2, "requestTime");
return (Criteria) this;
}
// 判断requestPhone是否为空
public Criteria andRequestPhoneIsNull() {
addCriterion("request_phone is null");
return (Criteria) this;
}
// 判断requestPhone是否不为空
public Criteria andRequestPhoneIsNotNull() {
addCriterion("request_phone is not null");
return (Criteria) this;
}
// 判断requestPhone是否等于某个值
public Criteria andRequestPhoneEqualTo(String value) {
addCriterion("request_phone =", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不等于某个值
public Criteria andRequestPhoneNotEqualTo(String value) {
addCriterion("request_phone <>", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否大于某个值
public Criteria andRequestPhoneGreaterThan(String value) {
addCriterion("request_phone >", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否大于等于某个值
public Criteria andRequestPhoneGreaterThanOrEqualTo(String value) {
addCriterion("request_phone >=", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否小于某个值
public Criteria andRequestPhoneLessThan(String value) {
addCriterion("request_phone <", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否小于等于某个值
public Criteria andRequestPhoneLessThanOrEqualTo(String value) {
addCriterion("request_phone <=", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否包含某个值
public Criteria andRequestPhoneLike(String value) {
addCriterion("request_phone like", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不包含某个值
public Criteria andRequestPhoneNotLike(String value) {
addCriterion("request_phone not like", value, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否在某个范围内
public Criteria andRequestPhoneIn(List<String> values) {
addCriterion("request_phone in", values, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不在某个范围内
public Criteria andRequestPhoneNotIn(List<String> values) {
addCriterion("request_phone not in", values, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否在某个范围内
public Criteria andRequestPhoneBetween(String value1, String value2) {
addCriterion("request_phone between", value1, value2, "requestPhone");
return (Criteria) this;
}
// 判断requestPhone是否不在某个范围内
public Criteria andRequestPhoneNotBetween(String value1, String value2) {
addCriterion("request_phone not between", value1, value2, "requestPhone");
return (Criteria) this;
}
// 判断requestExpressId是否为空
public Criteria andRequestExpressIdIsNull() {
addCriterion("request_express_id is null");
return (Criteria) this;
}
// 判断requestExpressId是否不为空
public Criteria andRequestExpressIdIsNotNull() {
addCriterion("request_express_id is not null");
return (Criteria) this;
}
// 判断requestExpressId是否等于某个值
public Criteria andRequestExpressIdEqualTo(Integer value) {
addCriterion("request_express_id =", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否不等于某个值
public Criteria andRequestExpressIdNotEqualTo(Integer value) {
addCriterion("request_express_id <>", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否大于某个值
public Criteria andRequestExpressIdGreaterThan(Integer value) {
addCriterion("request_express_id >", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否大于等于某个值
public Criteria andRequestExpressIdGreaterThanOrEqualTo(Integer value) {
addCriterion("request_express_id >=", value, "requestExpressId");
return (Criteria) this;
}
// 判断requestExpressId是否小于某个值
public Criteria andRequestExpressIdLessThan(Integer value) {
addCriterion("request_express_id <", value, "requestExpressId");
return (Criteria) this;

@ -5,12 +5,17 @@ import com.xmomen.module.receipt.entity.TbReceivingCodeRequest;
import com.xmomen.module.receipt.entity.TbReceivingCodeRequestExample;
import org.apache.ibatis.annotations.Param;
// TbReceivingCodeRequestMapper接口继承MybatisMapper
public interface TbReceivingCodeRequestMapper extends MybatisMapper {
// 根据example统计TbReceivingCodeRequest的数量
int countByExample(TbReceivingCodeRequestExample example);
// 根据example删除TbReceivingCodeRequest
int deleteByExample(TbReceivingCodeRequestExample example);
// 插入TbReceivingCodeRequest
int insertSelective(TbReceivingCodeRequest record);
// 根据example更新TbReceivingCodeRequest
int updateByExampleSelective(@Param("record") TbReceivingCodeRequest record, @Param("example") TbReceivingCodeRequestExample example);
}

@ -1,6 +1,8 @@
package com.xmomen.module.receipt.mapper;
// 定义一个接口ReceivingCodeRequestMapper
public interface ReceivingCodeRequestMapper {
// 定义一个常量ReceivingCodeRequestMapperNameSpace值为"com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper."
public static final String ReceivingCodeRequestMapperNameSpace = "com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper.";
}

@ -14,13 +14,16 @@
left join tb_order_ref receiving_code on receiving_code.order_no = main.order_no and receiving_code.ref_type = 'SHOU_HUO_NO'
left join tb_order tborder on tborder.order_no = main.order_no
<where>
<!-- 根据关键字查询 -->
<if test="keyword">
AND main.request_phone LIKE CONCAT('%', #{keyword}, '%')
or main.request_user LIKE CONCAT('%', #{keyword}, '%')
</if>
<!-- 根据订单号查询 -->
<if test="orderNo">
AND main.order_no LIKE CONCAT('%', #{orderNo}, '%')
</if>
<!-- 根据请求时间查询 -->
<if test="requestTimeStart">
<![CDATA[
AND DATE_FORMAT(main.request_time ,'%Y-%m-%d')>= #{requestTimeStart}

@ -1,9 +1,9 @@
package com.xmomen.module.receipt.mapper;
/**
* Created by Jeng on 16/4/13.
*/
// 定义一个接口,用于操作退货订单
public interface ReturnOrderMapper {
// 定义一个常量,用于命名空间
public static final String RETURN_ORDER_MAPPER_NAMESPACE = "com.xmomen.module.receipt.mapper.ReturnOrderMapper.";
}

@ -1,8 +1,7 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xmomen.module.receipt.mapper.ReturnOrderMapper" >
<!-- 查询订单 -->
<!-- 查询退货单列表 -->
<select id="getReturnOrderList" resultType="com.xmomen.module.receipt.model.ReturnOrderModel" parameterType="com.xmomen.module.receipt.model.ReturnOrderQuery">
select
main.return_time,

@ -6,43 +6,32 @@ import lombok.Data;
public @Data class ReceivingCodeRequestModel {
/**
*
*/
// 主键ID
private Integer id;
/**
*
*/
// 订单号
private String orderNo;
/**
*
*/
// 请求用户
private String requestUser;
/**
*
*/
// 请求时间
private Date requestTime;
/**
*
*/
// 请求电话
private String requestPhone;
/**
*
*/
// 快递公司名称
private String expressName;
/**
*
*/
// 收货码
private String receivingCode;
/**
*
*/
// 收货人姓名
private String consigneeName;
}

@ -4,9 +4,13 @@ import java.io.Serializable;
import lombok.Data;
// 返回项模型类
public @Data class ReturnItemModel implements Serializable {
// 项目代码
private String itemCode;
// 项目数量
private Integer itemNumber;
// 项目名称
private String itemName;
}

@ -15,173 +15,130 @@ import com.xmomen.module.order.model.PackingModel;
*/
public @Data class ReturnOrderModel implements Serializable {
/**
* ID
*/
// 返回订单ID
private Integer id;
/**
* 退id
*/
// 订单ID
private Integer returnOrderId;
/**
*
*/
// 订单类型
private Integer orderType;
/**
*
*/
// 订单类型描述
private String orderTypeDesc;
/**
* 1-2-3-4-
*/
// 订单来源
private Integer orderSource;
/**
*
*/
// 订单来源描述
private String orderSourceDesc;
/**
*
*/
// 支付方式
private Integer paymentMode;
/**
*
*/
// 支付方式描述
private String paymentModeDesc;
/**
*
*/
// 订单号
private String orderNo;
/**
*
*/
// 订单状态
private String orderStatus;
/**
*
*/
// 包装任务用户名
private String packingTaskUsername;
/**
* ID
*/
// 包装任务用户ID
private Integer packingTaskUserId;
/**
*
*/
// 包装任务状态
private Integer packingTaskStatus;
/**
*
*/
// 包装任务状态描述
private String packingTaskStatusDesc;
/**
*
*/
// 包装任务创建时间
private Date packingTaskCreateTime;
/**
*
*/
// 包装任务开始时间
private Date packingTaskStartTime;
/**
*
*/
// 包装任务结束时间
private Date packingTaskEndTime;
/**
*
*/
// 订单状态描述
private String orderStatusDesc;
/**
*
*/
// 收货人电话
private String consigneePhone;
/**
*
*/
// 收货人姓名
private String consigneeName;
/**
*
*/
// 收货人地址
private String consigneeAddress;
/**
* 1-2-
*/
// 运输方式
private Integer transportMode;
/**
*
*/
// 备注
private String remark;
/**
*
*/
// 折扣价格
private BigDecimal discountPrice;
/**
*
*/
// 总金额
private BigDecimal totalAmount;
/**
*
*/
// 创建时间
private Date createTime;
/**
* ID
*/
// 创建用户的ID
private Integer createUserId;
// 用户创建者
private String createUser;
/**
*
*/
private Date appointmentTime;
/**
*
*/
private String couponNumber;
/**
*
*/
private String expressName;
private Integer despatchExpressId;
/**
*
*/
private String managerName;
/**
*
*/
private String companyName;
private String batchNo;
/**
*
*/
private Integer otherPaymentMode;
private String otherPaymentModeDesc;
@ -190,44 +147,44 @@ public @Data class ReturnOrderModel implements Serializable {
private String receivingCode;
// 订单项列表
private List<TbReturnOrderItem> itemList;
// 返回时间
private Date returnTime;
// 返回状态
private String returnStatus;
// 返回状态描述
private String returnStatusDesc;
/**
* 0-1-
*/
// 审核状态
private Integer auditStatus;
/**
*
*/
// 审核日期
private Date auditDate;
/**
*
*/
// 审核用户ID
private Integer auditUserId;
// 审核用户名
private String auditUserName;
/**
*
*/
// 商品取货日期
private Date takeGoodsDate;
/**
*
*/
// 用户取货ID
private Integer takeGoodsUserId;
// 商品领取人姓名
private String takeGoodsUserName;
/**
*
*/
// 顾客取货电话
private String takeGoodsPhone;
}

@ -5,21 +5,32 @@ import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
*/
public @Data
class ReturnOrderQuery implements Serializable {
// 返回订单ID
private Integer id;
// 订单号
private String orderNo;
// 返回时间开始
private String returnTimeStart;
// 返回时间结束
private String returnTimeEnd;
// 关键字
private String keyword;
// 返回状态
private String returnStatus;
// 管理员ID
private String managerId;
// 收货人姓名
private String consigneeName;
// 是否无显示取消
private int hasNoShowCancel;
// 是否显示发货
private int showDespatch;
// 创建用户ID
private int createUserId;
// 发货快递ID
private int despatchExpressId;
}

@ -1,352 +1,364 @@
package com.xmomen.module.receipt.service;
// 声明该Java类所在的包路径com.xmomen.module.receipt.service表示该类位于名为service的包中
// 这个包是com.xmomen.module.receipt包的子包
import java.math.BigDecimal;
// 导入用于精确的十进制运算的类
import java.util.Date;
// 导入表示日期和时间的类
import java.util.HashMap;
// 导入一种键值对存储的数据结构类
import java.util.List;
// 导入用于表示有序的元素集合的接口
import java.util.Map;
// 导入用于表示键值对的映射关系的接口
import com.xmomen.framework.exception.BusinessException;
// 导入自定义的业务异常类
import com.xmomen.module.base.entity.CdItem;
// 导入基础模块中的商品实体类
import com.xmomen.module.order.entity.*;
// 导入订单模块的所有实体类
import com.xmomen.module.stock.service.StockService;
// 导入库存服务类
import org.apache.shiro.SecurityUtils;
// 导入Apache Shiro框架中用于处理安全相关操作的工具类
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架用于自动装配依赖的注解
import org.springframework.stereotype.Service;
// 导入Spring框架用于标记服务类的注解
import org.springframework.transaction.annotation.Transactional;
// 导入Spring框架用于声明事务的注解
import com.xmomen.framework.mybatis.dao.MybatisDao;
// 导入自定义的MyBatis数据访问对象类
import com.xmomen.framework.mybatis.page.Page;
// 导入用于分页操作的类
import com.xmomen.framework.utils.AssertExt;
// 导入自定义的断言工具类
import com.xmomen.framework.utils.StringUtilsExt;
// 导入自定义的字符串工具类
import com.xmomen.module.base.constant.AppConstants;
// 导入应用程序的常量类
import com.xmomen.module.base.entity.CdExpress;
// 导入基础模块中的快递实体类
import com.xmomen.module.base.service.ItemService;
// 导入商品服务类
import com.xmomen.module.order.mapper.OrderMapper;
// 导入订单模块的Mapper接口
import com.xmomen.module.order.model.ReturnOrder;
// 导入订单模块的退货订单模型类
import com.xmomen.module.receipt.mapper.ReturnOrderMapper;
// 导入退货订单模块的Mapper接口
import com.xmomen.module.receipt.model.ReturnOrderModel;
// 导入退货订单模块的模型类
import com.xmomen.module.receipt.model.ReturnOrderQuery;
// 导入退货订单模块的查询条件类
import com.xmomen.module.wx.model.AjaxResult;
// 导入微信模块的Ajax结果模型类
/**
* Created by Jeng on 16/4/5.
*/
@Service
// 使用@Service注解将ReturnOrderService类标记为一个Spring服务类
public class ReturnOrderService {
@Autowired
// 使用@Autowired注解自动装配MybatisDao类型的对象
MybatisDao mybatisDao;
@Autowired
// 使用@Autowired注解自动装配ItemService类型的对象
ItemService itemService;
@Autowired
// 使用@Autowired注解自动装配StockService类型的对象
StockService stockService;
/**
*
*
* @param orderQuery
* @param limit
* @param offset
* @return
*/
// 获取退货订单列表
public Page<ReturnOrderModel> getReturnOrderList(
ReturnOrderQuery orderQuery, Integer limit, Integer offset) {
// 该方法用于获取退货订单列表并进行分页接受查询条件对象orderQuery以及分页参数limit和offset
return (Page<ReturnOrderModel>) mybatisDao.selectPage(
ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
+ "getReturnOrderList", orderQuery, limit, offset);
// 调用mybatisDao的selectPage方法通过ReturnOrderMapper的命名空间和方法名执行查询返回分页结果
}
/**
*
*
* @param orderQuery
* @return
*/
// 获取退货订单列表
public List<ReturnOrderModel> getReturnOrderList(ReturnOrderQuery orderQuery) {
// 这是一个重载的方法用于获取退货订单列表不进行分页接受查询条件对象orderQuery
return mybatisDao.getSqlSessionTemplate().selectList(
ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
+ "getReturnOrderList", orderQuery);
// 调用mybatisDao的getSqlSessionTemplate方法获取SqlSessionTemplate
// 然后通过ReturnOrderMapper的命名空间和方法名执行查询返回结果列表
}
/**
*
*
* @param orderNo
* @param phone
* @return
*/
// 拒绝收货
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public AjaxResult noShouhuo(String orderNo, String phone, int expressId) {
// 该方法用于处理拒绝收货的业务逻辑接受订单号orderNo、联系电话phone和快递员ID expressId返回AjaxResult对象
AjaxResult ajaxResult = new AjaxResult();
// 创建一个新的AjaxResult对象用于封装返回给前端的结果信息
// 判断订单状态
TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
// 创建一个TbReturnOrderExample对象用于构建查询条件
tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbReturnOrder tbReturnOrder = mybatisDao
.selectOneByExample(tbOrderExample);
// 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象以判断订单状态
if (tbReturnOrder != null) {
ajaxResult.setMessage("订单不能拒绝,请联系客服人员。");
// 如果订单已存在某种状态设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
tbReturnOrder = new TbReturnOrder();
// 创建一个新的TbReturnOrder对象
tbReturnOrder.setOrderNo(orderNo);
// 设置订单号
// 退货运输中
tbReturnOrder.setReturnStatus(14);
// 设置退货状态为“退货运输中”状态码14
tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
// 设置取货日期为系统当前日期
tbReturnOrder.setTakeGoodsPhone(phone);
// 设置取货联系电话
tbReturnOrder.setTakeGoodsUserId(expressId);
// 设置取货的快递员用户ID
tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
// 设置退货时间为系统当前日期
tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
// 调用mybatisDao的insertByModel方法插入新的退货订单记录并返回插入后的对象
TbOrderItem orderItemDb = new TbOrderItem();
// 创建一个TbOrderItem对象
orderItemDb.setOrderNo(orderNo);
// 设置订单号
List<TbOrderItem> returnOrderItems = mybatisDao
.selectByModel(orderItemDb);
// 调用mybatisDao的selectByModel方法查询该订单下的所有订单商品项
BigDecimal returnTotalAmount = BigDecimal.ZERO;
// 创建一个BigDecimal对象用于记录退货总金额并初始化为0
for (TbOrderItem orderItem : returnOrderItems) {
// 遍历订单商品项列表
TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
// 创建一个新的TbReturnOrderItem对象
returnOrderItem.setItemCode(orderItem.getItemCode());
// 设置商品编码
returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
// 设置退货订单ID
returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
// 设置商品数量
returnOrderItem.setItemName(orderItem.getItemName());
// 设置商品名称
returnOrderItem.setIsNeed(1);
// 设置是否需要这里值为1表示需要
mybatisDao.insert(returnOrderItem);
// 插入退货订单商品项记录
//金额相加
returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
// 将当前商品项的金额(单价乘以数量)累加到退货总金额中
}
//退款金额
tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
// 设置退货订单的退款总金额
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
// 创建一个TbOrderExample对象用于构建查询条件
orderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbOrder order = new TbOrder();
// 创建一个新的TbOrder对象
//是拒绝收货
order.setIsReject(1);
// 设置订单为拒绝收货状态值为1表示拒绝
// 退货运输中
order.setOrderStatus("14");
// 设置订单状态为“退货运输中”状态码14
mybatisDao.updateOneByExampleSelective(order, orderExample);
// 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
ajaxResult.setMessage("订单已拒收,请及时送回仓库。");
// 设置ajaxResult的消息
ajaxResult.setResult(1);
// 设置ajaxResult的结果码为1
return ajaxResult;
// 返回ajaxResult对象
}
/**
* 退
*
* @param orderNo
* @param itemIds
* @return
*/
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public AjaxResult returnOrder(String orderNo, String itemIds) {
// 该方法用于处理退货申请的业务逻辑接受订单号orderNo和商品ID字符串itemIds返回AjaxResult对象
AjaxResult ajaxResult = new AjaxResult();
// 创建一个新的AjaxResult对象用于封装返回给前端的结果信息
// 判断订单状态
TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
// 创建一个TbReturnOrderExample对象用于构建查询条件
tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbReturnOrder tbReturnOrder = mybatisDao
.selectOneByExample(tbOrderExample);
// 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象以判断订单状态
if (tbReturnOrder != null) {
ajaxResult.setMessage("订单不能退货,请联系客服人员。");
// 如果订单已存在某种状态设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
tbReturnOrder = new TbReturnOrder();
// 创建一个新的TbReturnOrder对象
tbReturnOrder.setOrderNo(orderNo);
// 设置订单号
tbReturnOrder.setReturnStatus(10);// 申请退货
// 设置退货状态为“申请退货”状态码10
tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
// 设置退货时间为系统当前日期
tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
// 调用mybatisDao的insertByModel方法插入新的退货订单记录并返回插入后的对象
BigDecimal returnTotalAmount = BigDecimal.ZERO;
// 创建一个BigDecimal对象用于记录退货总金额并初始化为0
for (String itemId : itemIds.split(",")) {
// 遍历商品ID字符串以逗号分割
if (StringUtilsExt.isEmpty(itemId)) {
continue;
// 如果商品ID为空跳过本次循环
}
TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
// 创建一个新的TbReturnOrderItem对象
TbOrderItem orderItem = this.mybatisDao.selectByPrimaryKey(
TbOrderItem.class, Integer.parseInt(itemId));
// 根据商品ID查询对应的订单商品项
returnOrderItem.setItemCode(orderItem.getItemCode());
// 设置商品编码
returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
// 设置退货订单ID
returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
// 设置商品数量
returnOrderItem.setItemName(orderItem.getItemName());
// 设置商品名称
returnOrderItem.setIsNeed(1);
// 设置是否需要这里值为1表示需要
mybatisDao.insert(returnOrderItem);
// 插入退货订单商品项记录
//金额相加
returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
// 将当前商品项的金额(单价乘以数量)累加到退货总金额中
}
//退款金额
tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
// 设置退货订单的退款总金额
mybatisDao.update(tbReturnOrder);
// 调用mybatisDao的update方法更新退货订单记录
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
// 创建一个TbOrderExample对象用于构建查询条件
orderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbOrder order = new TbOrder();
// 创建一个新的TbOrder对象
order.setOrderStatus("10");// 申请退货
// 设置订单状态为“申请退货”状态码10
mybatisDao.updateOneByExampleSelective(order, orderExample);
// 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
ajaxResult.setMessage("退货申请提交成功,请等待客服审核。");
// 设置ajaxResult的消息
ajaxResult.setResult(1);
// 设置ajaxResult的结果码为1
return ajaxResult;
// 返回ajaxResult对象
}
/**
* 退
*
* @param orderNo
* @param phone
* @param expressId
* @return
*/
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public AjaxResult shouhuoReturn(String orderNo, String phone, int expressId) {
// 该方法用于处理退货收货的业务逻辑接受订单号orderNo、联系电话phone和快递员ID expressId返回AjaxResult对象
AjaxResult ajaxResult = new AjaxResult();
// 创建一个新的AjaxResult对象用于封装返回给前端的结果信息
// 判断订单状态
TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
// 创建一个TbReturnOrderExample对象用于构建查询条件
tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbReturnOrder tbReturnOrder = mybatisDao
.selectOneByExample(tbOrderExample);
// 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象以判断订单状态
if (tbReturnOrder.getReturnStatus() != 11) {
ajaxResult.setMessage("订单状态不为退货中,不能收货,请联系客服人员。");
// 如果订单的退货状态不是“退货中”状态码11设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
tbReturnOrder.setReturnStatus(14);// 退货运输中
// 设置退货订单的状态为“退货运输中”状态码14
tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
// 设置取货日期为系统当前日期
tbReturnOrder.setTakeGoodsPhone(phone);
// 设置取货联系电话
tbReturnOrder.setTakeGoodsUserId(expressId);
// 设置取货的快递员用户ID
mybatisDao.update(tbReturnOrder);
// 调用mybatisDao的update方法更新退货订单记录
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
// 创建一个TbOrderExample对象用于构建查询条件
orderExample.createCriteria().andOrderNoEqualTo(orderNo);
// 添加订单号等于orderNo的条件
TbOrder order = new TbOrder();
// 创建一个新的TbOrder对象
order.setOrderStatus("14");// 退货运输中
// 设置订单状态为“退货运输中”状态码14
mybatisDao.updateOneByExampleSelective(order, orderExample);
// 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
ajaxResult.setMessage("退货订单收货成功,请尽快送回仓库。");
// 设置ajaxResult的消息
ajaxResult.setResult(0);
// 设置ajaxResult的结果码为0
return ajaxResult;
// 返回ajaxResult对象
}
/**
* 退
*
* @param id
* @param statusCd
*/
@Transactional
// 使用@Transactional注解声明该方法在一个事务中执行
public void auditReturnOrder(int id, int statusCd) {
// 该方法用于审核退货订单接受退货订单ID id和审核状态码statusCd
TbReturnOrder returnOrder = this.mybatisDao.selectByPrimaryKey(
TbReturnOrder.class, id);
// 根据退货订单ID查询对应的TbReturnOrder对象
returnOrder.setAuditStatus(statusCd);
// 设置审核状态
returnOrder.setAuditDate(mybatisDao.getSysdate());
// 设置审核日期为系统当前日期
if (statusCd == 1) {
// 如果审核状态码为1表示通过审核
// 退货中
returnOrder.setReturnStatus(11);
Integer userId = (Integer) SecurityUtils.getSubject().getSession()
.getAttribute(AppConstants.SESSION_USER_ID_KEY);
returnOrder.setAuditUserId(userId);
this.mybatisDao.save(returnOrder);
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
orderExample.createCriteria().andOrderNoEqualTo(
returnOrder.getOrderNo());
TbOrder order = new TbOrder();
// 退货中
order.setOrderStatus("11");
mybatisDao.updateOneByExampleSelective(order, orderExample);
}
else {
// 拒绝退货
returnOrder.setReturnStatus(16);
Integer userId = (Integer) SecurityUtils.getSubject().getSession()
.getAttribute(AppConstants.SESSION_USER_ID_KEY);
returnOrder.setAuditUserId(userId);
this.mybatisDao.save(returnOrder);
// 更新原订单状态
TbOrderExample orderExample = new TbOrderExample();
orderExample.createCriteria().andOrderNoEqualTo(
returnOrder.getOrderNo());
TbOrder order = new TbOrder();
// 拒绝退货
order.setOrderStatus("16");
mybatisDao.updateOneByExampleSelective(order, orderExample);
}
}
/**
* 退
*
* @param boxNo
*/
@Transactional
public ReturnOrderModel returnOrderShouhuo(String boxNo) {
// 通过箱号查找订单号
TbOrderRelation tbOrderRelation = new TbOrderRelation();
tbOrderRelation.setRefType(OrderMapper.ORDER_PACKING_RELATION_CODE);
tbOrderRelation.setRefValue(boxNo);
tbOrderRelation = mybatisDao.selectOneByModel(tbOrderRelation);
AssertExt.notNull(tbOrderRelation, "扫描的箱号不存在!请确认。");
TbOrder order = new TbOrder();
order.setOrderNo(tbOrderRelation.getOrderNo());
order = mybatisDao.selectOneByModel(order);
AssertExt.notNull(order, "订单不存在!");
String orderStatus = order.getOrderStatus();
AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中,不能收货!");
TbReturnOrder returnOrder = new TbReturnOrder();
returnOrder.setOrderNo(order.getOrderNo());
returnOrder = mybatisDao.selectOneByModel(returnOrder);
ReturnOrderModel returnOrderModel = new ReturnOrderModel();
TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
returnOrderItem.setReturnOrderId(returnOrder.getId());
List<TbReturnOrderItem> returnOrderItemList = this.mybatisDao
.selectByModel(returnOrderItem);
returnOrderModel.setItemList(returnOrderItemList);
returnOrderModel.setOrderNo(order.getOrderNo());
return returnOrderModel;
}
/**
* 退
*
* @param orderNo
*/
@Transactional
public void shouhuo(String orderNo) throws BusinessException {
TbOrder order = new TbOrder();
order.setOrderNo(orderNo);
order = mybatisDao.selectOneByModel(order);
AssertExt.notNull(order, "订单不存在!");
String orderStatus = order.getOrderStatus();
AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中,不能收货!");
order.setOrderStatus("15");
mybatisDao.update(order);
TbReturnOrder returnOrder = new TbReturnOrder();
returnOrder.setOrderNo(order.getOrderNo());
returnOrder = mybatisDao.selectOneByModel(returnOrder);
returnOrder.setReturnStatus(15);
mybatisDao.update(returnOrder);
//查询订单的退货商品信息
TbReturnOrderItemExample tbReturnOrderItemExample = new TbReturnOrderItemExample();
tbReturnOrderItemExample.createCriteria().andReturnOrderIdEqualTo(returnOrder.getId());
List<TbReturnOrderItem> tbReturnOrderItems = mybatisDao.selectByExample(tbReturnOrderItemExample);
for (TbReturnOrderItem tbReturnOrderItem : tbReturnOrderItems) {
//需要的退回库存
if (tbReturnOrderItem.getIsNeed() == 1) {
CdItem cdItem = new CdItem();
cdItem.setItemCode(tbReturnOrderItem.getItemCode());
cdItem = mybatisDao.selectOneByModel(cdItem);
stockService.changeStockNum(cdItem.getId(), tbReturnOrderItem.getItemNumber().intValue(), returnOrder.getId(), "订单退货退回商品", 3);
}
}
// 卡类订单进行退款
if (order.getOrderType() == 1) {
}
}
}
// 设置退货订单的状态为“退货中”状态码1

@ -17,22 +17,44 @@ public
@Data
class ExpressReport implements Serializable {
// 物流公司
// 物流公司
@Excel(name = "物流公司")
// 订单号
private String expressName;
// 订单号
// 总箱数
@Excel(name = "订单号", width = 20)
private String orderNo;
// 出库时间
// 总箱数
@Excel(name = "总箱数")
// 收货时间
private int totalBoxNum;
// 出库时间
// 二次配送
@Excel(name = "出库时间", width = 20, exportFormat = "yyyy-MM-dd HH:mm:ss")
// 收货时间
// 正常配送
private Date outDate;
@Excel(name = "收货时间", width = 20, exportFormat = "yyyy-MM-dd HH:mm:ss")
// 异常配送
// 二次配送
// 正常配送
// 物流代收款
private Date shouHuoDate;
@Excel(name = "二次配送", type = 10)
// 损失承担
// 异常配送
private int isTwoSend;
// 物流代收款
// 是否拒收
@Excel(name = "正常配送", type = 10)
// 损失承担
private int isNormal;
@Excel(name = "异常配送", type = 10)
private int isNoNormal;
// 是否拒收
@Excel(name = "物流代收款", width = 15, type = 10)
private double expressAmount;
@Excel(name = "损失承担", type = 10)

@ -11,53 +11,57 @@ import java.io.Serializable;
public
@Data
class FinanceReport implements Serializable {
//公司ID
private int cdCompanyId;
//客户经理
@Excel(name = "客户经理")
private String managerName;
//单位/个人
@Excel(name = "单位/个人")
private String companyName;
//用户ID
private int cdUserId;
//总张数
//总张数(预付款)
@Excel(name = "总张数(预付款)", type = 10)
private int beforeCouponCount;
//总金额
//总金额(预付款)
@Excel(name = "总金额(预付款)", type = 10)
private double beforeTotalValue;
//充值金额
//充值金额(预付款)
@Excel(name = "充值金额(预付款)", type = 10)
private double beforeTotalRechargeValue;
//已付
//已付(预付款)
@Excel(name = "已付(预付款)", type = 10)
private double beforeTotalYesValue;
// 未付
// 未付(预付款)
@Excel(name = "未付(预付款)", type = 10)
private double beforeTotalNoValue;
// 余额
// 余额(预付款)
@Excel(name = "余额(预付款)", type = 10)
private double beforeUserTotalValue;
// 回馈总金额
// 回馈总金额(预付款)
@Excel(name = "回馈总金额(预付款)", type = 10)
private double beforeGiftTotalValue;
// 回馈剩余金额
// 回馈剩余金额(预付款)
@Excel(name = "回馈剩余金额(预付款)", type = 10)
private double beforeGiftUserTotalValue;
// 总张数
// 总张数(后付款)
@Excel(name = "总张数(后付款)", type = 10)
private int afterCouponCount;
// 总金额
// 总金额(后付款)
@Excel(name = "总金额(后付款)", type = 10)
private double afterTotalValue;
// 充值金额
// 充值金额(后付款)
@Excel(name = "充值金额(后付款)", type = 10)
private double afterTotalRechargeValue;
// 已付
// 已付(后付款)
@Excel(name = "已付(后付款)", type = 10)
private double afterTotalYesValue;
// 未付
// 未付(后付款)
@Excel(name = "未付(后付款)", type = 10)
private double afterTotalNoValue;
// 余额
// 余额(后付款)
@Excel(name = "余额(后付款)", type = 10)
private double afterUserTotalValue;
// 回馈总金额(后付款)
@ -78,12 +82,16 @@ class FinanceReport implements Serializable {
//回馈总金额
@Excel(name = "回馈总金额", type = 10)
private double giftOrderTotal;
//客户经理代收
@Excel(name = "客户经理代收", type = 10)
private double managerAmount;
//POS
@Excel(name = "POS", type = 10)
private double posAmount;
//转账
@Excel(name = "转账", type = 10)
private double zhuanAmount;
//物流代收
@Excel(name = "物流代收", type = 10)
private double expressAmount;
}

@ -16,33 +16,49 @@ import java.util.Date;
public @Data
class OrderDeliveryReport implements Serializable {
// 下单日期
@Excel(name = "下单日期" , exportFormat="yyyy-MM-dd", importFormat = "yyyy-MM-dd")
private Date createTime;
// 订单号
@Excel(name = "订单号",width = 20)
private String orderNo;
// 快递商
@Excel(name="快递商")
private String expressName;
// 收货人姓名
@Excel(name = "收货人姓名",width = 15)
private String consigneeName;
// 收货人电话
@Excel(name = "收货人电话",width = 15)
private String consigneePhone;
// 收货人地址
@Excel(name = "收货人地址",width = 30)
private String consigneeAddress;
// 金额
@Excel(name = "金额")
private double totalAmount;
// 付款方式
@Excel(name = "付款方式")
private String paymentModeDesc;
// 付款金额
@Excel(name = "付款金额",type = 10)
private double payAmount;
// 附加付款方式
@Excel(name = "附加付款方式")
private String otherPaymentModeDesc;
// 附加付款金额
@Excel(name = "附加付款金额",type = 10)
private double otherPayAmount;
// 送货日期
@Excel(name = "送货日期" , exportFormat="yyyy-MM-dd", importFormat = "yyyy-MM-dd")
private Date appointmentTime;
// 备注
@Excel(name = "备注",width = 30)
private String remark;
// 订单状态描述
private String orderStatusDesc;
// 总箱数
private int totalBoxNum;
// 快递扫描箱数
private int expressScanBoxNum;
}

@ -17,45 +17,67 @@ public
@Data
class OrderReport implements Serializable {
// 支付方式
private String paymentMode;
// 支付金额
private double payAmount;
// 其他支付方式
private String otherPaymentMode;
// 其他支付金额
private double otherPayAmount;
// 订单类型
@Excel(name = "订单类型")
private String orderType;
// 订单号
@Excel(name = "订单号", width = 20)
private String orderNo;
// 客户姓名
@Excel(name = "客户姓名")
private String consigneeName;
// 电话
@Excel(name = "电话", width = 15)
private String consigneePhone;
// 单位/个人
@Excel(name = "单位/个人")
private String companyName;
// 客户经理
@Excel(name = "客户经理")
private String managerName;
// 物流公司
@Excel(name = "物流公司")
private String expressName;
// 总金额
@Excel(name = "总金额")
private double totalAmount;
// 折扣金额
@Excel(name = "折扣金额")
private double discountPrice;
// 客户经理代收
@Excel(name = "客户经理代收", width = 15, type = 10)
private double managerAmount;
// 物流代收
@Excel(name = "物流代收", type = 10)
private double expressAmount;
// 卡类扣款
@Excel(name = "卡类扣款", type = 10)
private double couponAmount;
// 券类扣款
@Excel(name = "券类扣款", type = 10)
private double quanAmount;
// 刷POS
@Excel(name = "刷POS", type = 10)
private double posAmount;
// 转账
@Excel(name = "转账", type = 10)
private double zhuanZhanAmount;
// 其它
@Excel(name = "其它", type = 10)
private double otherAmount;
// 回馈
@Excel(name = "回馈", type = 10)
private double huiKuiAmount;
// 退货金额
@Excel(name = "退货金额", type = 10)
private double returnTotalAmount;
}

@ -5,11 +5,16 @@ import lombok.Data;
import java.io.Serializable;
/**
*
*/
public @Data
class ReportQuery implements Serializable {
// 开始时间
private String beginTime;
// 结束时间
private String endTime;
// 管理员ID
private Integer managerId;
// 公司ID
private Integer companyId;
}

@ -5,14 +5,14 @@ import org.jeecgframework.poi.excel.annotation.Excel;
import java.io.Serializable;
/**
*
*/
public
@Data
class StockDailyReport implements Serializable {
// 商品名称
@Excel(name = "商品名称")
private String itemName;
// 商品编码
@Excel(name = "商品编码")
private String itemCode;
/**

@ -41,9 +41,13 @@ public class ReportOrderService {
* @return
*/
public List<OrderReport> getOrderReportList(ReportQuery reportQuery) {
//查询订单报表
List<OrderReport> orderReportList = mybatisDao.getSqlSessionTemplate().selectList(ReportOrderMapper.REPORT_ORDER_MAPPER_NAMESPACE + "getReportOrderList", reportQuery);
//遍历订单报表
for (OrderReport orderReport : orderReportList) {
//判断付款方式
if ("0".equals(orderReport.getPaymentMode())) {
//如果是汇款
orderReport.setHuiKuiAmount(orderReport.getPayAmount());
}
if ("1".equals(orderReport.getPaymentMode())) {

@ -1,38 +1,66 @@
package com.xmomen.module.resource.api;
/**
* DfsException RuntimeExceptionDFS
*/
public class DfsException extends RuntimeException {
// 序列化版本号,用于确保在反序列化时类的版本一致性
private static final long serialVersionUID = 1497374765949093902L;
/**
* IOException 100
* FileNotFoundException 200
* Exception from DFS (example: from FastDFS, MyException) 300
* OtherException 400
*
*
* - IOException 100
* - FileNotFoundException 200
* - DFS FastDFS MyException 300
* - 400
*/
private String code;
// 异常的详细描述信息
private String message;
/**
* DfsException
* @param code
* @param message
*/
public DfsException(String code, String message) {
this.code = code;
this.message = message;
}
/**
*
* @return
*/
public String getCode() {
return code;
}
/**
*
* @param code
*/
public void setCode(String code) {
this.code = code;
}
/**
*
* @return
*/
public String getMessage() {
return message;
}
/**
*
* @param message
*/
public void setMessage(String message) {
this.message = message;
}
}
}

@ -2,32 +2,45 @@ package com.xmomen.module.resource.api;
import java.util.Map;
/**
* DfsFile DFS
*
*/
public class DfsFile {
/**
* file data
*
*
*/
private byte[] data;
/**
* key,not used in FastDfs
*
* FastDFS 使
*/
private String key;
/**
* metadata for file
*
*
*
*/
private Map<String, String> metadata;
/**
*
* DfsFile null
*/
public DfsFile() {
}
/**
* constructor with data, key and metadata
* DfsFile
*
* @param key key,not used in FastDfs
* @param data file data
* @param metadata metadata for file
* @param key FastDFS 使
* @param data
* @param metadata
*/
public DfsFile(String key, byte[] data, Map<String, String> metadata) {
this.key = key;
@ -35,28 +48,58 @@ public class DfsFile {
this.metadata = metadata;
}
/**
*
*
* @return
*/
public byte[] getData() {
return data;
}
/**
*
*
* @param data
*/
public void setData(byte[] data) {
this.data = data;
}
/**
*
*
* @return
*/
public String getKey() {
return key;
}
/**
*
*
* @param key
*/
public void setKey(String key) {
this.key = key;
}
/**
*
*
* @return
*/
public Map<String, String> getMetadata() {
return metadata;
}
/**
*
*
* @param metadata
*/
public void setMetadata(Map<String, String> metadata) {
this.metadata = metadata;
}
}
}

@ -1,45 +1,74 @@
package com.xmomen.module.resource.api;
/**
* DfsPath DFS
* HTTP 访
*/
public class DfsPath {
/**
* whole url, just like http://.../bucketName/remotePath
* HTTP 访 http://.../bucketName/remotePath。
* 访
*/
private String httpPath;
/**
* file path on storage server
*
*
*/
private String remotePath;
/**
* DfsPath null
*/
public DfsPath() {
}
/**
* Constructor with httpPath and remotePath
* HTTP DfsPath
*
* @param httpPath
* @param remotePath
* @param httpPath HTTP 访
* @param remotePath
*/
public DfsPath(String httpPath, String remotePath) {
this.httpPath = httpPath;
this.remotePath = remotePath;
}
/**
* HTTP 访
*
* @return HTTP 访
*/
public String getHttpPath() {
return httpPath;
}
/**
* HTTP 访
*
* @param httpPath HTTP 访
*/
public void setHttpPath(String httpPath) {
this.httpPath = httpPath;
}
/**
*
*
* @return
*/
public String getRemotePath() {
return remotePath;
}
/**
*
*
* @param remotePath
*/
public void setRemotePath(String remotePath) {
this.remotePath = remotePath;
}
}
}

@ -4,7 +4,9 @@ import java.io.File;
public class DfsSdk {
// 根据dfsType和bucketName获取DfsService实例
public static DfsService getDfsInstance(String dfsType, String bucketName) {
// 如果dfsType为FastDFS则获取FastDfsService实例
if ("FastDFS".equalsIgnoreCase(dfsType)) {
DfsService dfsService = FastDfsService.getInstance(bucketName);
return dfsService;
@ -12,6 +14,7 @@ public class DfsSdk {
return null;
}
// 默认获取FastDFS的DfsService实例
public static DfsService getDfsInstance() {
return getDfsInstance("FastDFS", "group1");
}

@ -4,73 +4,91 @@ import java.io.File;
import java.util.List;
import java.util.Map;
/**
* DfsService DFS
*
*/
public interface DfsService {
/**
* Upload file to file system.
*
*
* @param filePath local file path
* @param key Key
* @param metadata metadata for the file
* @return DfsPath object or null if fail
* @param filePath
* @param key
* @param metadata
* @return DFS DfsPath null
*/
public DfsPath putObject(String filePath, String key, Map<String, String> metadata);
/**
* Upload file to file system
* File
*
* @param file file
* @param key Key
* @param metadata metadata for the file
* @return DfsPath object or null if fail
* @param file
* @param key
* @param metadata
* @return DFS DfsPath null
*/
public DfsPath putObject(File file, String key, Map<String, String> metadata);
/**
* Upload file to file system
*
*
* @param bytes file
* @param key Key
* @param metadata metadata for the file
* @param extName ext name of file
* @return DfsPath object or null if fail
* @param bytes
* @param key
* @param metadata
* @param extName
* @return DFS DfsPath null
*/
public DfsPath putObject(byte[] bytes, String key, Map<String, String> metadata, String extName);
/**
* Get file from file system with remotePath
*
*
* @param remotePath remote file path on file system
* @param key Key
* @return DfsPath object or null if fail
* @param remotePath
* @param key
* @return DfsFile null
*/
public DfsFile getObject(String remotePath, String key);
/**
* Delete the file on file system
*
*
* @param remotePath remote file path on file system
* @param key Key
* @return true||false
* @param remotePath
* @param key
* @return true false
*/
public boolean deleteObject(String remotePath, String key);
/**
* Get the list of the file on file system
*
*
* @return List<DfsFile>
* @return DfsFile
*/
public List<DfsFile> listObjects();
/**
* Get the whole url
* HTTP 访
*
* @param remotePath
* @return whole url
* @param remotePath
* @return HTTP 访访
*/
public String getHttpPath(String remotePath);
/**
* DMS HTTP 访
* DMS
*
* @param dmsFilePath DMS
* @return HTTP 访
*/
public String getDmsHttpPath(String dmsFilePath);
/**
*
*
*
* @param type
* @return
*/
public String getDefaultPath(String type);
}
}

@ -19,58 +19,77 @@ import org.csource.fastdfs.StorageServer;
import org.csource.fastdfs.TrackerClient;
import org.csource.fastdfs.TrackerServer;
/**
* FastDfsService DfsService FastDFS
* FastDFS
*/
public class FastDfsService implements DfsService {
// 单例实例
private static FastDfsService instance = null;
// 基础 URL用于构建文件的完整 HTTP 访问路径
private String baseUrl = "";
// DMS 基础 URL用于构建 DMS 文件的完整 HTTP 访问路径
private String dmsBaseUrl = "";
// 默认图片 URL
private String defaultPicUrl = "";
//private static Logger logger = Logger.getLogger(FastDfsService.class.getName());
// 配置文件中基础 URL 的键名
private static String BASE_URL = "httpBaseUrl";
// 配置文件中 DMS 基础 URL 的键名
private static String DMS_BASE_URL = "dmsBaseUrl";
// 配置文件中默认图片 URL 的键名
private static String DEFAULT_PIC_URL = "defaultPicUrl";
// FastDFS 键名,用于元数据中存储文件的唯一标识
private static String FAST_DFS_KEY = "FastDfsKey";
/**
* bucket name
*
*/
private final String bucketName;
/**
* constructor with bucketName
* FastDfsService
* FastDFS
*
* @param bucketName bucket name
* @param bucketName
*/
private FastDfsService(String bucketName) {
this.bucketName = bucketName;
String configFilePath = null;
try {
configFilePath = FastDfsService.class.getResource("/").toURI().getPath() + "fdfs_client.conf";
} catch (URISyntaxException e1) {
Exception e = new Exception("Cann't found fdfs_client.conf file under " + FastDfsService.class.getResource("/"));
handleException(e);
}
try {
// 获取 FastDFS 配置文件的路径
configFilePath = FastDfsService.class.getResource("/").toURI().getPath() + "fdfs_client.conf";
} catch (URISyntaxException e1) {
// 若无法找到配置文件,抛出异常并处理
Exception e = new Exception("Cann't found fdfs_client.conf file under " + FastDfsService.class.getResource("/"));
handleException(e);
}
try {
// 初始化 FastDFS 客户端全局配置
ClientGlobal.init(configFilePath);
// 读取配置文件
IniFileReader reader = new IniFileReader(configFilePath);
// 设置基础 URL
setBaseUrl(reader.getStrValue(BASE_URL));
// 设置 DMS 基础 URL
setDmsBaseUrl(reader.getStrValue(DMS_BASE_URL));
// 设置默认图片 URL
setDefaultPicUrl(reader.getStrValue(DEFAULT_PIC_URL));
} catch (Exception e) {
// 处理初始化过程中出现的异常
handleException(e);
}
}
/**
* Get instance of FastDfsService, for Singleton
* @param bucketName bucket name
* @return instance of FastDfsService
* FastDfsService
* 线
*
* @param bucketName
* @return FastDfsService
*/
public static synchronized FastDfsService getInstance(String bucketName) {
if (null == instance) {
@ -80,11 +99,11 @@ public class FastDfsService implements DfsService {
}
/**
* Delete file on file system.
*
*
* @param remotePath remote file path
* @param key Key, not used in FastDFS
* @return true|false
* @param remotePath
* @param key FastDFS 使
* @return true false
*/
@Override
public boolean deleteObject(String remotePath, String key) {
@ -92,21 +111,28 @@ public class FastDfsService implements DfsService {
TrackerClient trackerClient = new TrackerClient();
TrackerServer trackerServer = null;
try {
// 获取 Tracker 服务器连接
trackerServer = trackerClient.getConnection();
// 创建存储客户端
StorageClient storageClient = new StorageClient(trackerServer, null);
// 调用 FastDFS API 删除文件
result = storageClient.delete_file(bucketName, remotePath);
} catch(Exception e) {
} catch (Exception e) {
// 处理删除过程中出现的异常
handleException(e);
} finally {
if (null != trackerServer) {
try {
// 关闭 Tracker 服务器连接
trackerServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
}
if (0 != result) {
// 删除失败,记录日志并返回 false
//logger.info("delete faild, the faild code is: " + result);
return false;
}
@ -114,26 +140,33 @@ public class FastDfsService implements DfsService {
}
/**
* Find the whole url
* HTTP 访
*
* @param remotePath remote path
* @return the whole url
* @param remotePath
* @return HTTP 访
*/
@Override
public String getHttpPath(String remotePath) {
return baseUrl + "/" + bucketName + "/" + remotePath;
}
/**
* DMS HTTP 访
*
* @param dmsFilePath DMS
* @return DMS HTTP 访
*/
@Override
public String getDmsHttpPath(String dmsFilePath) {
return dmsBaseUrl + dmsFilePath;
return dmsBaseUrl + dmsFilePath;
}
/**
* Get the file, and return DfsFile object
*
*
* @param remotePath remote path
* @param key Key, not used in FastDFS, can be null
* @return DfsFile object or null if fail
* @param remotePath
* @param key FastDFS 使 null
* @return DfsFile null
*/
@Override
public DfsFile getObject(String remotePath, String key) {
@ -141,59 +174,75 @@ public class FastDfsService implements DfsService {
TrackerServer trackerServer = null;
StorageServer storageServer = null;
try {
// 获取 Tracker 服务器连接
trackerServer = trackerClient.getConnection();
// 获取存储服务器
storageServer = trackerClient.getFetchStorage(trackerServer, bucketName, remotePath);
// 创建存储客户端
StorageClient storageClient = new StorageClient(trackerServer, storageServer);
// 下载文件
byte[] bytes = storageClient.download_file(this.bucketName, remotePath);
if (null != bytes) {
// 获取文件的元数据
NameValuePair[] value_pairs = storageClient.get_metadata(bucketName, remotePath);
Map<String, String> metadata = new HashMap<String, String>();
for (int i = 0; i < value_pairs.length; i++) {
// 将元数据存储到 Map 中
metadata.put(value_pairs[i].getName(), value_pairs[i].getValue());
}
// 创建 DfsFile 对象
DfsFile dfsFile = new DfsFile(metadata.get(FAST_DFS_KEY), bytes, metadata);
return dfsFile;
}
} catch (Exception e){
} catch (Exception e) {
// 处理获取文件过程中出现的异常
handleException(e);
} finally {
if (null != storageServer) {
try {
// 关闭存储服务器连接
storageServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
if (null != trackerServer) {
try {
// 关闭 Tracker 服务器连接
trackerServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
}
// 获取文件失败,记录日志并返回 null
//logger.info("Get object failed, get null object");
return null;
}
/**
* Get the file list of file system.
* Not implement at the moment, because FastDFS API not support.
*
* FastDFS API
*
* @return null
*/
@Override
public List<DfsFile> listObjects() {
//to do
//Because fastDFS api do not support list object method.
// 待实现
// 因为 FastDFS API 不支持列出对象的方法
return null;
}
/**
* Upload the file to file system by file path
*
* File putObject(File file, String key, Map<String, String> metadata)
*
* @param filePath local file path.
* @param key Key, not used in FastDFS, can be null
* @param metadata metadata for file, can be null
* @return DfsFile object or null if fail
* @param filePath
* @param key FastDFS 使 null
* @param metadata null
* @return DfsPath null
*/
@Override
public DfsPath putObject(String filePath, String key, Map<String, String> metadata) {
@ -202,13 +251,13 @@ public class FastDfsService implements DfsService {
}
/**
* Upload the file to file system by bytes
*
*
* @param bytes bytes
* @param key Key, not used in FastDFS
* @param metadata metadata for file, can be null
* @param extName extName for file, can be null
* @return DfsPath object or null if fail
* @param bytes
* @param key FastDFS 使
* @param metadata null
* @param extName null
* @return DfsPath null
*/
@Override
public DfsPath putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) {
@ -216,147 +265,215 @@ public class FastDfsService implements DfsService {
TrackerServer trackerServer = null;
StorageServer storageServer = null;
try {
// 获取 Tracker 服务器连接
trackerServer = trackerClient.getConnection();
// 获取存储服务器列表
StorageServer[] storageServers = trackerClient.getStoreStorages(trackerServer, bucketName);
if (null != storageServers) {
// 选择第一个存储服务器
storageServer = storageServers[0];
// 创建存储客户端
StorageClient storageClient = new StorageClient(trackerServer, storageServer);
NameValuePair[] meta_list;
int i = 0;
if (null == metadata) {
// 若元数据为空,创建一个包含一个元素的元数据数组
meta_list = new NameValuePair[1];
} else {
// 若元数据不为空,创建一个包含元数据和 FastDFS 键的数组
meta_list = new NameValuePair[metadata.size() + 1];
for (Map.Entry<String, String> entry : metadata.entrySet()) {
meta_list[i++] = new NameValuePair(entry.getKey(), entry.getValue());
}
}
// 添加 FastDFS 键到元数据数组
meta_list[i] = new NameValuePair(FAST_DFS_KEY, key);
// 调用 FastDFS API 上传文件
String[] results = storageClient.upload_file(bytes, extName, meta_list);
if (null == results) {
// 上传失败,记录日志并返回 null
//logger.info("upload file fail, error codes: " + storageClient.getErrorCode());
return null;
} else {
// 获取远程文件名
String remote_fileName = results[1];
// 构建文件的完整 HTTP 访问路径
String httpPath = this.getHttpPath(remote_fileName);
// 创建 DfsPath 对象
DfsPath dfsPath = new DfsPath(httpPath, remote_fileName);
return dfsPath;
}
}
} catch (Exception e) {
// 处理上传过程中出现的异常
handleException(e);
} finally {
if (null != storageServer) {
try {
// 关闭存储服务器连接
storageServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
if (null != trackerServer) {
try {
// 关闭 Tracker 服务器连接
trackerServer.close();
} catch (Exception e) {
// 处理关闭连接时出现的异常
handleException(e);
}
}
}
// 上传失败,记录日志并返回 null
//logger.info("Upload file faild, because can not get storage servers!");
return null;
}
/**
* Upload the file to file system
*
* putObject(byte[] bytes, String key, Map<String, String> metadata, String extName)
*
* @param file file
* @param key Key, not used in FastDFS, can be null
* @param metadata metadata for file , can be null
* @return DfsPath object or null if fail
* @param file
* @param key FastDFS 使 null
* @param metadata null
* @return DfsPath null
*/
@Override
public DfsPath putObject(File file, String key, Map<String, String> metadata) {
FileInputStream in = null;
byte[] file_buff = null;
try {
// 打开文件输入流
in = new FileInputStream(file);
if (null != in) {
// 获取文件长度
int len = in.available();
// 创建字节数组
file_buff = new byte[len];
// 读取文件内容到字节数组
in.read(file_buff);
}
} catch (Exception e) {
// 处理读取文件过程中出现的异常
handleException(e);
} finally {
if (null != in) {
try {
// 关闭文件输入流
in.close();
} catch (Exception e) {
// 处理关闭流时出现的异常
handleException(e);
}
}
}
String file_ext_name = "";
if (file.getName().lastIndexOf(".") > 0) {
// 获取文件扩展名
file_ext_name = file.getName().substring(file.getName().lastIndexOf(".") + 1);
}
// 调用 putObject(byte[] bytes, String key, Map<String, String> metadata, String extName) 方法上传文件
return putObject(file_buff, key, metadata, file_ext_name);
}
/**
* URL
*
* @return URL
*/
public String getBaseUrl() {
return baseUrl;
}
/**
* URL
*
* @param baseUrl URL
*/
private void setBaseUrl(String baseUrl) {
this.baseUrl = baseUrl;
}
/**
* DMS URL
*
* @return DMS URL
*/
public String getDmsBaseUrl() {
return dmsBaseUrl;
return dmsBaseUrl;
}
/**
* DMS URL
*
* @param dmsBaseUrl DMS URL
*/
public void setDmsBaseUrl(String dmsBaseUrl) {
this.dmsBaseUrl = dmsBaseUrl;
this.dmsBaseUrl = dmsBaseUrl;
}
/**
* URL
*
* @return URL
*/
public String getDefaultPicUrl() {
return defaultPicUrl;
return defaultPicUrl;
}
/**
* URL
*
* @param defaultPicUrl URL
*/
public void setDefaultPicUrl(String defaultPicUrl) {
this.defaultPicUrl = defaultPicUrl;
this.defaultPicUrl = defaultPicUrl;
}
/**
* Handle Exception
* @param e exception
*
* DfsException
*
* @param e
*/
private void handleException(Exception e) {
if (e instanceof IOException) {
// 处理 IOException抛出 DfsException错误码为 100
//logger.error("Exception occured : DFSException code: 100," + " exception message :" + e.getMessage());
throw new DfsException("100", e.getMessage());
} else if (e instanceof FileNotFoundException) {
// 处理 FileNotFoundException抛出 DfsException错误码为 200
//logger.error("Exception occured : DFSException code: 200," + " exception message : file not found." + e.getMessage());
throw new DfsException("200", e.getMessage());
} else if (e instanceof MyException) {
// 处理 MyException抛出 DfsException错误码为 300
//logger.error("Exception occured : DFSException code: 300," + " exception message :" + e.getMessage());
throw new DfsException("300", e.getMessage());
} else if (e instanceof Exception) {
// 处理其他异常,抛出 DfsException错误码为 400
//logger.error("Exception occured : DFSException code: 400," + " exception message :" + e.getMessage());
throw new DfsException("400", e.getMessage());
}
}
@Override
public String getDefaultPath(String type) {
if("PICTURE".equalsIgnoreCase(type)) {
return defaultPicUrl;
}
return defaultPicUrl;
}
}
/**
*
* "PICTURE" URL URL
*
* @param type
* @return
*/
@Override
public String getDefaultPath(String type) {
if ("PICTURE".equalsIgnoreCase(type)) {
return defaultPicUrl;
}
return defaultPicUrl;
}
}

@ -1,130 +1,203 @@
// 声明该类所在的包,此包为资源控制器相关的包
package com.xmomen.module.resource.controller;
// 导入自定义框架中的业务异常类,用于处理业务逻辑中出现的异常
import com.xmomen.framework.exception.BusinessException;
// 导入自定义框架中 MyBatis 分页相关的 Page 类,用于处理分页查询结果
import com.xmomen.framework.mybatis.page.Page;
// 导入自定义模块中的日志注解,用于记录操作日志
import com.xmomen.module.logger.Log;
// 导入资源查询模型类,用于封装资源查询的条件
import com.xmomen.module.resource.model.ResourceQuery;
// 导入资源数据模型类,用于封装资源的相关数据
import com.xmomen.module.resource.model.ResourceModel;
// 导入资源服务类,该类包含资源相关的业务逻辑
import com.xmomen.module.resource.service.ResourceService;
// 导入 Apache Commons IO 工具类,用于处理输入输出流
import org.apache.commons.io.IOUtils;
// 导入 Jeecg 框架中 Excel 导入工具类,用于从 Excel 文件中导入数据
import org.jeecgframework.poi.excel.ExcelImportUtil;
// 导入 Jeecg 框架中 Excel 导出参数类,用于配置 Excel 导出的参数
import org.jeecgframework.poi.excel.entity.ExportParams;
// 导入 Jeecg 框架中 Excel 导入参数类,用于配置 Excel 导入的参数
import org.jeecgframework.poi.excel.entity.ImportParams;
// 导入 Jeecg 框架中 Excel 导入结果类,用于封装 Excel 导入的结果
import org.jeecgframework.poi.excel.entity.result.ExcelImportResult;
// 导入 Jeecg 框架中普通 Excel 常量类,包含一些 Excel 操作的常量
import org.jeecgframework.poi.excel.entity.vo.NormalExcelConstants;
// 导入 Jeecg 框架中 Excel 导入异常类,用于处理 Excel 导入过程中出现的异常
import org.jeecgframework.poi.exception.excel.ExcelImportException;
// 导入 Spring 框架中的自动装配注解,用于自动注入依赖的 Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 框架中的模型映射类,用于在控制器和视图之间传递数据
import org.springframework.ui.ModelMap;
// 导入 Spring 框架中的数据绑定结果类,用于处理数据绑定过程中的错误信息
import org.springframework.validation.BindingResult;
// 导入 Spring 框架中的请求映射相关注解,用于处理 HTTP 请求
import org.springframework.web.bind.annotation.*;
// 导入 Spring 框架中用于处理多部分文件上传的类
import org.springframework.web.multipart.MultipartFile;
// 导入 Spring 框架中的模型和视图类,用于返回包含模型数据和视图名称的对象
import org.springframework.web.servlet.ModelAndView;
// 导入 JSR-303 验证框架中的有效注解,用于对请求参数进行验证
import javax.validation.Valid;
// 导入 Java 序列化接口,用于支持对象的序列化和反序列化
import java.io.Serializable;
// 导入 Java 输入输出异常类,用于处理输入输出操作中出现的异常
import java.io.IOException;
// 导入 Java 输入流类,用于读取数据
import java.io.InputStream;
// 导入 Java 列表接口,用于存储多个元素
import java.util.List;
/**
* HTTP
*
* @author tanxinzheng
* @version 1.0.0
* @date 2017-4-10 23:26:20
*/
// 标记该类为 RESTful 风格的控制器,会自动将方法返回值转换为 JSON 格式
@RestController
// 定义该控制器处理的请求路径前缀为 /resource
@RequestMapping(value = "/resource")
public class ResourceController {
// 使用自动装配注解将 ResourceService 注入到当前类中,用于调用资源相关的业务逻辑
@Autowired
ResourceService resourceService;
/**
*
*
*
* @param limit
* @param offset
* @param id
* @param ids
* @param excludeIds
* @return Page<ResourceModel>
* @param limit
* @param offset
* @param id
* @param entityType
* @param entityId ID
* @param ids
* @param excludeIds
* @return
*/
// 映射 HTTP GET 请求到该方法
@RequestMapping(method = RequestMethod.GET)
// 使用日志注解记录该操作的名称为查询资源目录列表
@Log(actionName = "查询资源目录列表")
public Page<ResourceModel> getResourceList(@RequestParam(value = "limit") Integer limit,
@RequestParam(value = "offset") Integer offset,
@RequestParam(value = "id", required = false) String id,
@RequestParam(value = "entityType", required = false) String entityType,
@RequestParam(value = "entityId", required = false) String entityId,
@RequestParam(value = "ids", required = false) String[] ids,
@RequestParam(value = "excludeIds", required = false) String[] excludeIds) {
public Page<ResourceModel> getResourceList(
// 从请求参数中获取每页结果数
@RequestParam(value = "limit") Integer limit,
// 从请求参数中获取页码
@RequestParam(value = "offset") Integer offset,
// 从请求参数中获取资源主键,该参数可选
@RequestParam(value = "id", required = false) String id,
// 从请求参数中获取资源所属的实体类型,该参数可选
@RequestParam(value = "entityType", required = false) String entityType,
// 从请求参数中获取资源所属的实体 ID该参数可选
@RequestParam(value = "entityId", required = false) String entityId,
// 从请求参数中获取资源主键数组,该参数可选
@RequestParam(value = "ids", required = false) String[] ids,
// 从请求参数中获取不包含的资源主键数组,该参数可选
@RequestParam(value = "excludeIds", required = false) String[] excludeIds) {
// 创建资源查询对象
ResourceQuery resourceQuery = new ResourceQuery();
// 设置查询条件:资源主键
resourceQuery.setId(id);
// 设置查询条件:不包含的资源主键数组
resourceQuery.setExcludeIds(excludeIds);
// 设置查询条件:资源主键数组
resourceQuery.setIds(ids);
// 设置查询条件:资源所属的实体类型
resourceQuery.setEntityType(entityType);
// 设置查询条件:资源所属的实体 ID
resourceQuery.setEntityId(entityId);
// 调用资源服务的方法,根据分页信息和查询条件获取资源目录分页数据
return resourceService.getResourceModelPage(limit, offset, resourceQuery);
}
/**
*
*
*
* @param id
* @return ResourceModel
* @param id
* @return
*/
// 映射形如 /resource/{id} 的 HTTP GET 请求到该方法
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
// 使用日志注解记录该操作的名称为查询资源目录
@Log(actionName = "查询资源目录")
public ResourceModel getResourceById(@PathVariable(value = "id") String id) {
public ResourceModel getResourceById(
// 从路径中获取资源主键
@PathVariable(value = "id") String id) {
// 调用资源服务的方法,根据主键获取单个资源目录的数据
return resourceService.getOneResourceModel(id);
}
/**
*
*
*
* @param resourceModel
* @return ResourceModel
* @param resourceModel
* @return
*/
// 映射 HTTP POST 请求到该方法
@RequestMapping(method = RequestMethod.POST)
// 使用日志注解记录该操作的名称为新增资源目录
@Log(actionName = "新增资源目录")
public ResourceModel createResource(@RequestBody @Valid ResourceModel resourceModel) {
public ResourceModel createResource(
// 从请求体中获取新增资源目录的数据,并进行数据验证
@RequestBody @Valid ResourceModel resourceModel) {
// 调用资源服务的方法,创建新的资源目录
return resourceService.createResource(resourceModel);
}
/**
*
*
*
* @param id
* @param resourceModel
* @param id
* @param resourceModel
*/
// 映射形如 /resource/{id} 的 HTTP PUT 请求到该方法
@RequestMapping(value = "/{id}", method = RequestMethod.PUT)
// 使用日志注解记录该操作的名称为更新资源目录
@Log(actionName = "更新资源目录")
public void updateResource(@PathVariable(value = "id") String id,
@RequestBody @Valid ResourceModel resourceModel) {
public void updateResource(
// 从路径中获取要更新的资源主键
@PathVariable(value = "id") String id,
// 从请求体中获取更新后的资源目录数据,并进行数据验证
@RequestBody @Valid ResourceModel resourceModel) {
// 调用资源服务的方法,更新资源目录信息
resourceService.updateResource(resourceModel);
}
/**
*
*
*
* @param id
* @param id
*/
// 映射形如 /resource/{id} 的 HTTP DELETE 请求到该方法
@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
// 使用日志注解记录该操作的名称为删除单个资源目录
@Log(actionName = "删除单个资源目录")
public void deleteResource(@PathVariable(value = "id") String id) {
public void deleteResource(
// 从路径中获取要删除的资源主键
@PathVariable(value = "id") String id) {
// 调用资源服务的方法,删除指定主键的资源目录
resourceService.deleteResource(id);
}
/**
*
*
*
* @param ids
* @param ids
*/
// 映射 HTTP DELETE 请求到该方法
@RequestMapping(method = RequestMethod.DELETE)
// 使用日志注解记录该操作的名称为批量删除资源目录
@Log(actionName = "批量删除资源目录")
public void deleteResources(@RequestParam(value = "ids") String[] ids) {
public void deleteResources(
// 从请求参数中获取要删除的资源主键数组
@RequestParam(value = "ids") String[] ids) {
// 调用资源服务的方法,批量删除指定主键的资源目录
resourceService.deleteResource(ids);
}
}
}

@ -1,4 +1,4 @@
package com.xmomen.module.resource.entity;
Xpackage com.xmomen.module.resource.entity;
import com.xmomen.framework.mybatis.model.BaseMybatisModel;
import javax.persistence.Column;

@ -4,47 +4,58 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// ResourceExample类继承自BaseMybatisExample用于构建资源实体的查询条件
public class ResourceExample extends BaseMybatisExample {
// 用于存储排序子句,例如 "column_name ASC" 或 "column_name DESC"
protected String orderByClause;
// 表示是否去重查询结果true表示去重false表示不去重
protected boolean distinct;
// 存储多个查询条件组,每个条件组之间是 "或"or的关系
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria为一个空的ArrayList
public ResourceExample() {
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;
}
// 将一个查询条件组添加到oredCriteria中
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的查询条件组并添加到oredCriteria中然后返回该条件组
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个新的查询条件组如果oredCriteria为空则添加该条件组然后返回该条件组
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -53,37 +64,46 @@ public class ResourceExample extends BaseMybatisExample {
return criteria;
}
// 内部方法,用于创建一个新的查询条件组
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空所有查询条件和设置将oredCriteria清空orderByClause设为nulldistinct设为false
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 抽象的静态内部类用于生成具体的查询条件是Criteria类的基类
protected abstract static class GeneratedCriteria {
// 存储具体的查询条件列表
protected List<Criterion> criteria;
// 构造函数初始化criteria为一个空的ArrayList
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 +111,7 @@ public class ResourceExample 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 ResourceExample 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,410 +127,99 @@ public class ResourceExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 生成ID为null的查询条件
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 生成ID不为null的查询条件
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 生成ID等于指定值的查询条件
public Criteria andIdEqualTo(String value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 生成ID不等于指定值的查询条件
public Criteria andIdNotEqualTo(String value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 生成ID大于指定值的查询条件
public Criteria andIdGreaterThan(String value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 生成ID大于等于指定值的查询条件
public Criteria andIdGreaterThanOrEqualTo(String value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 生成ID小于指定值的查询条件
public Criteria andIdLessThan(String value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 生成ID小于等于指定值的查询条件
public Criteria andIdLessThanOrEqualTo(String value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 生成ID模糊匹配指定值的查询条件
public Criteria andIdLike(String value) {
addCriterion("ID like", value, "id");
return (Criteria) this;
}
// 生成ID不模糊匹配指定值的查询条件
public Criteria andIdNotLike(String value) {
addCriterion("ID not like", value, "id");
return (Criteria) this;
}
// 生成ID在指定列表中的查询条件
public Criteria andIdIn(List<String> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 生成ID不在指定列表中的查询条件
public Criteria andIdNotIn(List<String> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 生成ID在指定范围之间的查询条件
public Criteria andIdBetween(String value1, String value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 生成ID不在指定范围之间的查询条件
public Criteria andIdNotBetween(String value1, String value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 以下是类似的方法用于生成其他字段ENTITY_TYPE、ENTITY_ID、PATH、RESOURCE_TYPE、IS_DEFAULT的各种查询条件
// 省略重复注释逻辑与ID字段的条件生成类似
public Criteria andEntityTypeIsNull() {
addCriterion("ENTITY_TYPE is null");
return (Criteria) this;
}
public Criteria andEntityTypeIsNotNull() {
addCriterion("ENTITY_TYPE is not null");
return (Criteria) this;
}
public Criteria andEntityTypeEqualTo(String value) {
addCriterion("ENTITY_TYPE =", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeNotEqualTo(String value) {
addCriterion("ENTITY_TYPE <>", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeGreaterThan(String value) {
addCriterion("ENTITY_TYPE >", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeGreaterThanOrEqualTo(String value) {
addCriterion("ENTITY_TYPE >=", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeLessThan(String value) {
addCriterion("ENTITY_TYPE <", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeLessThanOrEqualTo(String value) {
addCriterion("ENTITY_TYPE <=", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeLike(String value) {
addCriterion("ENTITY_TYPE like", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeNotLike(String value) {
addCriterion("ENTITY_TYPE not like", value, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeIn(List<String> values) {
addCriterion("ENTITY_TYPE in", values, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeNotIn(List<String> values) {
addCriterion("ENTITY_TYPE not in", values, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeBetween(String value1, String value2) {
addCriterion("ENTITY_TYPE between", value1, value2, "entityType");
return (Criteria) this;
}
public Criteria andEntityTypeNotBetween(String value1, String value2) {
addCriterion("ENTITY_TYPE not between", value1, value2, "entityType");
return (Criteria) this;
}
public Criteria andEntityIdIsNull() {
addCriterion("ENTITY_ID is null");
return (Criteria) this;
}
public Criteria andEntityIdIsNotNull() {
addCriterion("ENTITY_ID is not null");
return (Criteria) this;
}
public Criteria andEntityIdEqualTo(String value) {
addCriterion("ENTITY_ID =", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdNotEqualTo(String value) {
addCriterion("ENTITY_ID <>", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdGreaterThan(String value) {
addCriterion("ENTITY_ID >", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdGreaterThanOrEqualTo(String value) {
addCriterion("ENTITY_ID >=", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdLessThan(String value) {
addCriterion("ENTITY_ID <", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdLessThanOrEqualTo(String value) {
addCriterion("ENTITY_ID <=", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdLike(String value) {
addCriterion("ENTITY_ID like", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdNotLike(String value) {
addCriterion("ENTITY_ID not like", value, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdIn(List<String> values) {
addCriterion("ENTITY_ID in", values, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdNotIn(List<String> values) {
addCriterion("ENTITY_ID not in", values, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdBetween(String value1, String value2) {
addCriterion("ENTITY_ID between", value1, value2, "entityId");
return (Criteria) this;
}
public Criteria andEntityIdNotBetween(String value1, String value2) {
addCriterion("ENTITY_ID not between", value1, value2, "entityId");
return (Criteria) this;
}
public Criteria andPathIsNull() {
addCriterion("PATH is null");
return (Criteria) this;
}
public Criteria andPathIsNotNull() {
addCriterion("PATH is not null");
return (Criteria) this;
}
public Criteria andPathEqualTo(String value) {
addCriterion("PATH =", value, "path");
return (Criteria) this;
}
public Criteria andPathNotEqualTo(String value) {
addCriterion("PATH <>", value, "path");
return (Criteria) this;
}
public Criteria andPathGreaterThan(String value) {
addCriterion("PATH >", value, "path");
return (Criteria) this;
}
public Criteria andPathGreaterThanOrEqualTo(String value) {
addCriterion("PATH >=", value, "path");
return (Criteria) this;
}
public Criteria andPathLessThan(String value) {
addCriterion("PATH <", value, "path");
return (Criteria) this;
}
public Criteria andPathLessThanOrEqualTo(String value) {
addCriterion("PATH <=", value, "path");
return (Criteria) this;
}
public Criteria andPathLike(String value) {
addCriterion("PATH like", value, "path");
return (Criteria) this;
}
public Criteria andPathNotLike(String value) {
addCriterion("PATH not like", value, "path");
return (Criteria) this;
}
public Criteria andPathIn(List<String> values) {
addCriterion("PATH in", values, "path");
return (Criteria) this;
}
public Criteria andPathNotIn(List<String> values) {
addCriterion("PATH not in", values, "path");
return (Criteria) this;
}
public Criteria andPathBetween(String value1, String value2) {
addCriterion("PATH between", value1, value2, "path");
return (Criteria) this;
}
public Criteria andPathNotBetween(String value1, String value2) {
addCriterion("PATH not between", value1, value2, "path");
return (Criteria) this;
}
public Criteria andResourceTypeIsNull() {
addCriterion("RESOURCE_TYPE is null");
return (Criteria) this;
}
public Criteria andResourceTypeIsNotNull() {
addCriterion("RESOURCE_TYPE is not null");
return (Criteria) this;
}
public Criteria andResourceTypeEqualTo(String value) {
addCriterion("RESOURCE_TYPE =", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeNotEqualTo(String value) {
addCriterion("RESOURCE_TYPE <>", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeGreaterThan(String value) {
addCriterion("RESOURCE_TYPE >", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeGreaterThanOrEqualTo(String value) {
addCriterion("RESOURCE_TYPE >=", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeLessThan(String value) {
addCriterion("RESOURCE_TYPE <", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeLessThanOrEqualTo(String value) {
addCriterion("RESOURCE_TYPE <=", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeLike(String value) {
addCriterion("RESOURCE_TYPE like", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeNotLike(String value) {
addCriterion("RESOURCE_TYPE not like", value, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeIn(List<String> values) {
addCriterion("RESOURCE_TYPE in", values, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeNotIn(List<String> values) {
addCriterion("RESOURCE_TYPE not in", values, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeBetween(String value1, String value2) {
addCriterion("RESOURCE_TYPE between", value1, value2, "resourceType");
return (Criteria) this;
}
public Criteria andResourceTypeNotBetween(String value1, String value2) {
addCriterion("RESOURCE_TYPE not between", value1, value2, "resourceType");
return (Criteria) this;
}
public Criteria andIsDefaultIsNull() {
addCriterion("IS_DEFAULT is null");
return (Criteria) this;
}
public Criteria andIsDefaultIsNotNull() {
addCriterion("IS_DEFAULT is not null");
return (Criteria) this;
}
public Criteria andIsDefaultEqualTo(Integer value) {
addCriterion("IS_DEFAULT =", value, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultNotEqualTo(Integer value) {
addCriterion("IS_DEFAULT <>", value, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultGreaterThan(Integer value) {
addCriterion("IS_DEFAULT >", value, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultGreaterThanOrEqualTo(Integer value) {
addCriterion("IS_DEFAULT >=", value, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultLessThan(Integer value) {
addCriterion("IS_DEFAULT <", value, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultLessThanOrEqualTo(Integer value) {
addCriterion("IS_DEFAULT <=", value, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultIn(List<Integer> values) {
addCriterion("IS_DEFAULT in", values, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultNotIn(List<Integer> values) {
addCriterion("IS_DEFAULT not in", values, "isDefault");
return (Criteria) this;
}
public Criteria andIsDefaultBetween(Integer value1, Integer value2) {
addCriterion("IS_DEFAULT between", value1, value2, "isDefault");
return (Criteria) this;
}
//...
public Criteria andIsDefaultNotBetween(Integer value1, Integer value2) {
addCriterion("IS_DEFAULT not between", value1, value2, "isDefault");
@ -516,62 +227,74 @@ public class ResourceExample extends BaseMybatisExample {
}
}
// 具体的查询条件类继承自GeneratedCriteria
public static class Criteria extends GeneratedCriteria {
// 构造函数,调用父类构造函数
protected Criteria() {
super();
}
}
// 表示单个查询条件的类
public static class Criterion {
// 存储查询条件的SQL片段例如 "ID ="
private String condition;
// 存储单个值条件的值
private Object value;
// 存储范围值条件的第二个值
private Object secondValue;
// 表示该条件是否不带值,例如 "ID is null"
private boolean noValue;
// 表示该条件是否带单个值
private boolean singleValue;
// 表示该条件是否带范围值
private boolean betweenValue;
// 表示该条件是否带值列表
private boolean listValue;
// 存储类型处理器,用于处理值的类型转换
private String typeHandler;
// 获取查询条件的SQL片段
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;
@ -579,6 +302,7 @@ public class ResourceExample extends BaseMybatisExample {
this.noValue = true;
}
// 构造函数,创建一个带单个值的查询条件
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
@ -591,10 +315,12 @@ public class ResourceExample extends BaseMybatisExample {
}
}
// 构造函数创建一个带单个值的查询条件类型处理器为null
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
// 构造函数,创建一个带范围值的查询条件
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
@ -604,6 +330,7 @@ public class ResourceExample extends BaseMybatisExample {
this.betweenValue = true;
}
// 构造函数创建一个带范围值的查询条件类型处理器为null
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

@ -1,7 +1,15 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xmomen.module.resource.entity.mapper.ResourceMapper" >
<resultMap id="BaseResultMap" type="com.xmomen.module.resource.entity.Resource" >
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xmomen.module.resource.entity.mapper.ResourceMapper">
<!--
定义结果映射,将数据库查询结果映射到 Java 对象。
id: 结果映射的唯一标识。
type: 要映射的 Java 实体类的全限定名。
-->
<resultMap id="BaseResultMap" type="com.xmomen.module.resource.entity.Resource">
<!-- 映射数据库表中的主键列到实体类的属性 -->
<id column="ID" property="id" jdbcType="VARCHAR" />
<result column="ENTITY_TYPE" property="entityType" jdbcType="VARCHAR" />
<result column="ENTITY_ID" property="entityId" jdbcType="VARCHAR" />
@ -9,25 +17,37 @@
<result column="RESOURCE_TYPE" property="resourceType" jdbcType="VARCHAR" />
<result column="IS_DEFAULT" property="isDefault" jdbcType="INTEGER" />
</resultMap>
<sql id="Example_Where_Clause" >
<where >
<foreach collection="oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
<!--
定义 SQL 片段,用于生成 WHERE 子句。
此片段根据传入的查询条件动态生成 WHERE 子句,支持多种条件类型(无值、单值、范围值、列表值)。
-->
<sql id="Example_Where_Clause">
<where>
<!-- 遍历所有的查询条件组 -->
<foreach collection="oredCriteria" item="criteria" separator="or">
<if test="criteria.valid">
<!-- 去除开头多余的 "and" -->
<trim prefix="(" suffix=")" prefixOverrides="and">
<!-- 遍历每个查询条件组中的具体条件 -->
<foreach collection="criteria.criteria" item="criterion">
<choose>
<!-- 处理无值条件 -->
<when test="criterion.noValue">
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
<!-- 处理单值条件 -->
<when test="criterion.singleValue">
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
<!-- 处理范围值条件 -->
<when test="criterion.betweenValue">
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
<!-- 处理列表值条件 -->
<when test="criterion.listValue">
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
#{listItem}
</foreach>
</when>
@ -38,25 +58,30 @@
</foreach>
</where>
</sql>
<sql id="Update_By_Example_Where_Clause" >
<where >
<foreach collection="example.oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
<!--
定义 SQL 片段,用于生成 UPDATE 语句的 WHERE 子句。
逻辑与 Example_Where_Clause 类似,用于根据条件更新数据。
-->
<sql id="Update_By_Example_Where_Clause">
<where>
<foreach collection="example.oredCriteria" item="criteria" separator="or">
<if test="criteria.valid">
<trim prefix="(" suffix=")" prefixOverrides="and">
<foreach collection="criteria.criteria" item="criterion">
<choose>
<when test="criterion.noValue">
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
<when test="criterion.singleValue">
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
<when test="criterion.betweenValue">
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
<when test="criterion.listValue">
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
#{listItem}
</foreach>
</when>
@ -67,100 +92,148 @@
</foreach>
</where>
</sql>
<sql id="Base_Column_List" >
<!-- 定义 SQL 片段,列出表中的基本列名 -->
<sql id="Base_Column_List">
ID, ENTITY_TYPE, ENTITY_ID, PATH, RESOURCE_TYPE, IS_DEFAULT
</sql>
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.resource.entity.ResourceExample" >
<!--
定义查询语句,根据条件查询资源数据。
id: 语句的唯一标识。
resultMap: 引用前面定义的结果映射,用于将查询结果映射到实体类。
parameterType: 传入的参数类型,这里是查询条件对象。
-->
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.resource.entity.ResourceExample">
select
<if test="distinct" >
<!-- 如果需要去重,添加 distinct 关键字 -->
<if test="distinct">
distinct
</if>
<!-- 引入基本列名片段 -->
<include refid="Base_Column_List" />
from cd_resource
<if test="_parameter != null" >
<!-- 如果传入了查询参数,引入 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
<if test="orderByClause != null" >
<!-- 如果有排序条件,添加排序子句 -->
<if test="orderByClause != null">
order by ${orderByClause}
</if>
</select>
<delete id="deleteByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" >
<!--
定义删除语句,根据条件删除资源数据。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是查询条件对象。
-->
<delete id="deleteByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample">
delete from cd_resource
<if test="_parameter != null" >
<!-- 如果传入了查询参数,引入 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</delete>
<insert id="insertSelective" parameterType="com.xmomen.module.resource.entity.Resource" useGeneratedKeys="true" keyProperty="id" keyColumn="ID" >
<selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE" >
<!--
定义插入语句,选择性插入资源数据(只插入非空字段)。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是要插入的实体类对象。
useGeneratedKeys: 是否使用数据库生成的主键。
keyProperty: 实体类中表示主键的属性名。
keyColumn: 数据库表中主键列的名称。
-->
<insert id="insertSelective" parameterType="com.xmomen.module.resource.entity.Resource" useGeneratedKeys="true" keyProperty="id" keyColumn="ID">
<!-- 在插入前生成主键值,这里使用 UUID 并去除连字符 -->
<selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE">
SELECT replace(UUID(),'-','')
</selectKey>
insert into cd_resource
<trim prefix="(" suffix=")" suffixOverrides="," >
<!-- 动态生成插入的列名,只包含非空字段 -->
<trim prefix="(" suffix=")" suffixOverrides=",">
ID,
<if test="entityType != null" >
<if test="entityType != null">
ENTITY_TYPE,
</if>
<if test="entityId != null" >
<if test="entityId != null">
ENTITY_ID,
</if>
<if test="path != null" >
<if test="path != null">
PATH,
</if>
<if test="resourceType != null" >
<if test="resourceType != null">
RESOURCE_TYPE,
</if>
<if test="isDefault != null" >
<if test="isDefault != null">
IS_DEFAULT,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<!-- 动态生成插入的值,只包含非空字段 -->
<trim prefix="values (" suffix=")" suffixOverrides=",">
#{id,jdbcType=VARCHAR},
<if test="entityType != null" >
<if test="entityType != null">
#{entityType,jdbcType=VARCHAR},
</if>
<if test="entityId != null" >
<if test="entityId != null">
#{entityId,jdbcType=VARCHAR},
</if>
<if test="path != null" >
<if test="path != null">
#{path,jdbcType=VARCHAR},
</if>
<if test="resourceType != null" >
<if test="resourceType != null">
#{resourceType,jdbcType=VARCHAR},
</if>
<if test="isDefault != null" >
<if test="isDefault != null">
#{isDefault,jdbcType=INTEGER},
</if>
</trim>
</insert>
<select id="countByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" resultType="java.lang.Integer" >
<!--
定义统计语句,根据条件统计资源数据的数量。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是查询条件对象。
resultType: 返回的结果类型,这里是整数类型。
-->
<select id="countByExample" parameterType="com.xmomen.module.resource.entity.ResourceExample" resultType="java.lang.Integer">
select count(*) from cd_resource
<if test="_parameter != null" >
<!-- 如果传入了查询参数,引入 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</select>
<update id="updateByExampleSelective" parameterType="map" >
<!--
定义更新语句,根据条件选择性更新资源数据(只更新非空字段)。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是一个包含实体类对象和查询条件的 Map。
-->
<update id="updateByExampleSelective" parameterType="map">
update cd_resource
<set >
<if test="record.id != null" >
<!-- 动态生成 SET 子句,只包含非空字段 -->
<set>
<if test="record.id != null">
ID = #{record.id,jdbcType=VARCHAR},
</if>
<if test="record.entityType != null" >
<if test="record.entityType != null">
ENTITY_TYPE = #{record.entityType,jdbcType=VARCHAR},
</if>
<if test="record.entityId != null" >
<if test="record.entityId != null">
ENTITY_ID = #{record.entityId,jdbcType=VARCHAR},
</if>
<if test="record.path != null" >
<if test="record.path != null">
PATH = #{record.path,jdbcType=VARCHAR},
</if>
<if test="record.resourceType != null" >
<if test="record.resourceType != null">
RESOURCE_TYPE = #{record.resourceType,jdbcType=VARCHAR},
</if>
<if test="record.isDefault != null" >
<if test="record.isDefault != null">
IS_DEFAULT = #{record.isDefault,jdbcType=INTEGER},
</if>
</set>
<if test="_parameter != null" >
<!-- 如果传入了查询参数,引入 UPDATE 的 WHERE 子句片段 -->
<if test="_parameter != null">
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>

@ -7,6 +7,7 @@ package com.xmomen.module.resource.mapper;
*/
public interface ResourceMapperExt {
// 定义资源映射命名空间
public static final String ResourceMapperNameSpace = "com.xmomen.module.resource.mapper.ResourceMapperExt.";
}

@ -1,13 +1,27 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xmomen.module.resource.mapper.ResourceMapperExt">
<!-- 查询消息 -->
<!--
定义一个查询语句,用于获取资源模型数据。
id: 该查询语句的唯一标识,在代码中通过此标识调用该查询。
resultType: 指定查询结果映射到的 Java 类,这里是 com.xmomen.module.resource.model.ResourceModel。
parameterType: 指定传入的参数类型,这里是查询条件对象 com.xmomen.module.resource.model.ResourceQuery。
-->
<select id="getResourceModel"
resultType="com.xmomen.module.resource.model.ResourceModel"
parameterType="com.xmomen.module.resource.model.ResourceQuery">
SELECT * FROM cd_resource t
<!--
<where> 标签用于动态生成 SQL 的 WHERE 子句。
它会自动处理子句开头多余的 AND 关键字。
-->
<where>
<!--
如果查询条件中的 id 不为空,添加条件 t.ID = #{id} 到 WHERE 子句中。
#{id} 是 MyBatis 的占位符,会在执行时被实际的参数值替换。
-->
<if test="id">
AND t.ID = #{id}
</if>
@ -17,6 +31,14 @@
<if test="entityType">
AND t.ENTITY_TYPE = #{entityType}
</if>
<!--
如果查询条件中的 ids 不为空,动态生成 IN 子句。
collection: 表示参数中集合的名称,这里是 ids。
item: 迭代时当前元素的别名,这里是 item。
separator: 元素之间的分隔符,这里是逗号。
open: IN 子句的开始符号,这里是左括号。
close: IN 子句的结束符号,这里是右括号。
-->
<if test="ids">
AND t.ID IN
<foreach collection="ids" item="item" separator="," open="(" close=")">
@ -30,17 +52,25 @@
</foreach>
</if>
</where>
<!-- 按照 t.id 对查询结果进行排序 -->
ORDER BY t.id
</select>
<!--更新默认资源-->
<!--
定义一个更新语句,用于更新默认资源。
id: 该更新语句的唯一标识,在代码中通过此标识调用该更新操作。
parameterType: 指定传入的参数类型,这里是字符串类型 java.lang.String。
-->
<update id="updateDefaultByEntityId" parameterType="java.lang.String">
update
cd_resource
set
is_default = 0
is_default = 0
where
entity_id=#{entityId}
<!--
上述 SQL 语句的作用是将 cd_resource 表中 entity_id 等于传入参数 entityId 的记录的 is_default 字段值设置为 0。
#{entityId} 是 MyBatis 的占位符,会在执行时被实际的参数值替换。
-->
</update>
</mapper>

@ -28,6 +28,10 @@ public @Data class ResourceCreate implements Serializable {
/** */
private Integer isDefault;
/**
* ResourceCreateResource
* @return Resource
*/
public Resource getEntity(){
Resource resource = new Resource();
BeanUtils.copyProperties(this, resource);

@ -5,18 +5,17 @@ import com.xmomen.module.resource.entity.Resource;
import com.xmomen.module.resource.service.ResourceUtilsService;
import lombok.Data;
import org.hibernate.validator.constraints.*;
import javax.validation.constraints.*;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.jeecgframework.poi.excel.annotation.ExcelTarget;
import org.springframework.beans.BeanUtils;
import java.lang.Integer;
import java.lang.String;
import java.io.Serializable;
/**
* Serializable 便
*
* @author tanxinzheng
* @version 1.0.0
* @date 2017-4-10 23:26:20
@ -24,35 +23,66 @@ import java.io.Serializable;
@ExcelTarget(value = "ResourceModel")
public class ResourceModel implements Serializable {
/** */
/**
*
* 使 @NotBlank "为必填项"
* 使 @Length 32 "字符长度限制[0,32]"
*/
@NotBlank(message = "为必填项")
@Length(max = 32, message = "字符长度限制[0,32]")
private String id;
/** */
/**
*
* 使 @Excel name Excel
* 使 @Length 50 "字符长度限制[0,50]"
*/
@Excel(name = "")
@Length(max = 50, message = "字符长度限制[0,50]")
private String entityType;
/** */
/**
* ID
* 使 @Excel name Excel
* 使 @Length 100 "字符长度限制[0,100]"
*/
@Excel(name = "")
@Length(max = 100, message = "字符长度限制[0,100]")
private String entityId;
/** */
/**
*
* 使 @Excel name Excel
* 使 @Length 255 "字符长度限制[0,255]"
*/
@Excel(name = "")
@Length(max = 255, message = "字符长度限制[0,255]")
private String path;
/** */
/**
*
* 使 @Excel name Excel
* 使 @Length 30 "字符长度限制[0,30]"
*/
@Excel(name = "")
@Length(max = 30, message = "字符长度限制[0,30]")
private String resourceType;
/** */
/**
*
* 使 @Excel name Excel
* 使 @Range -999999999 999999999 "数值范围[999999999,-999999999]"
*/
@Excel(name = "")
@Range(max = 999999999, min = -999999999, message = "数值范围[999999999,-999999999]")
private Integer isDefault;
/**
* Get Resource Entity Object
* Resource
* 使 @JsonIgnore JSON
* BeanUtils.copyProperties ResourceModel Resource
*
* @return
* @return Resource
*/
@JsonIgnore
public Resource getEntity() {
@ -61,51 +91,112 @@ public class ResourceModel implements Serializable {
return resource;
}
/**
*
*
* @return
*/
public String getId() {
return id;
}
/**
*
*
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
*
*
* @return
*/
public String getEntityType() {
return entityType;
}
/**
*
*
* @param entityType
*/
public void setEntityType(String entityType) {
this.entityType = entityType;
}
/**
* ID
*
* @return ID
*/
public String getEntityId() {
return entityId;
}
/**
* ID
*
* @param entityId ID
*/
public void setEntityId(String entityId) {
this.entityId = entityId;
}
/**
* HTTP
* ResourceUtilsService getWholeHttpPath HTTP
*
* @return HTTP
*/
public String getPath() {
return ResourceUtilsService.getWholeHttpPath(this.path);
}
/**
*
*
* @param path
*/
public void setPath(String path) {
this.path = path;
}
/**
*
*
* @return
*/
public String getResourceType() {
return resourceType;
}
/**
*
*
* @param resourceType
*/
public void setResourceType(String resourceType) {
this.resourceType = resourceType;
}
/**
*
*
* @return
*/
public Integer getIsDefault() {
return isDefault;
}
/**
*
*
* @param isDefault
*/
public void setIsDefault(Integer isDefault) {
this.isDefault = isDefault;
}
}
}

@ -25,8 +25,14 @@ class ResourceQuery implements Serializable {
*/
private String[] excludeIds;
/**
*
*/
private String entityType;
/**
* ID
*/
private String entityId;
}

@ -15,20 +15,29 @@ import java.io.Serializable;
*/
public @Data class ResourceUpdate implements Serializable {
/** */
// 资源ID
private String id;
/** */
// 实体类型
private String entityType;
/** */
// 实体ID
private String entityId;
/** */
// 资源路径
private String path;
/** */
// 资源类型
private String resourceType;
/** */
// 是否默认
private Integer isDefault;
/**
* ResourceUpdateResource
* @return Resource
*/
public Resource getEntity(){
Resource resource = new Resource();
BeanUtils.copyProperties(this, resource);

@ -14,6 +14,11 @@ import java.io.File;
*/
public class ResourceUtilsService {
/**
* http
* @param resourcePath
* @return http
*/
public static String getWholeHttpPath(String resourcePath) {
if (StringUtils.isEmpty(resourcePath)) {
return "";
@ -28,6 +33,11 @@ public class ResourceUtilsService {
}
}
/**
*
* @param file
* @return
*/
public static String uploadFile(File file) {
DfsService dfsServcie = DfsSdk.getDfsInstance();
DfsPath path = dfsServcie.putObject(file, null, null);
@ -35,6 +45,10 @@ public class ResourceUtilsService {
return path.getRemotePath();
}
/**
*
* @return
*/
public static String getDefaultPicPath() {
DfsService dfsServcie = DfsSdk.getDfsInstance();
return dfsServcie.getDefaultPath("PICTURE");

@ -26,6 +26,8 @@ import java.util.Arrays;
import java.util.List;
/**
*
*
* @author tanxinzheng
* @version 1.0.0
* @date 2017-4-10 23:26:20
@ -33,53 +35,59 @@ import java.util.List;
@Service
public class ResourceServiceImpl implements ResourceService {
// 注入 Mybatis 数据访问对象,用于执行数据库操作
@Autowired
MybatisDao mybatisDao;
/**
*
* 使
*
* @param resourceModel
* @return ResourceModel
* @return ResourceModel null
*/
@Override
@Transactional
public ResourceModel createResource(ResourceModel resourceModel) {
// 调用 createResource 方法创建资源实体
Resource resource = createResource(resourceModel.getEntity());
if (resource != null) {
// 根据创建的资源实体的 ID 获取对应的资源模型对象
return getOneResourceModel(resource.getId());
}
return null;
}
/**
*
* 使
*
* @param resource
* @return Resource
* @return
*/
@Override
@Transactional
public Resource createResource(Resource resource) {
// 使用 MybatisDao 插入资源实体到数据库
return mybatisDao.insertByModel(resource);
}
/**
*
* 使
*
* @param resourceModels
* @return List<ResourceModel>
* @return
*/
@Override
@Transactional
public List<ResourceModel> createResources(List<ResourceModel> resourceModels) {
List<ResourceModel> resourceModelList = null;
for (ResourceModel resourceModel : resourceModels) {
// 逐个创建资源模型对象
resourceModel = createResource(resourceModel);
if (resourceModel != null) {
if (resourceModelList == null) {
resourceModelList = new ArrayList<>();
}
// 将创建成功的资源模型对象添加到集合中
resourceModelList.add(resourceModel);
}
}
@ -87,30 +95,31 @@ public class ResourceServiceImpl implements ResourceService {
}
/**
*
* 使
*
* @param resourceModel
*/
@Override
@Transactional
public void updateResource(ResourceModel resourceModel) {
// 将资源模型对象转换为实体对象并使用 MybatisDao 更新到数据库
mybatisDao.update(resourceModel.getEntity());
}
/**
*
* 使
*
* @param resource
* @return Resource
*/
@Override
@Transactional
public void updateResource(Resource resource) {
// 使用 MybatisDao 更新资源实体到数据库
mybatisDao.update(resource);
}
/**
*
* 使
*
* @param ids
*/
@ -118,99 +127,111 @@ public class ResourceServiceImpl implements ResourceService {
@Transactional
public void deleteResource(String[] ids) {
ResourceExample resourceExample = new ResourceExample();
// 创建查询条件,设置 ID 在指定数组中
resourceExample.createCriteria().andIdIn(Arrays.<String>asList((String[]) ids));
// 使用 MybatisDao 根据查询条件删除资源
mybatisDao.deleteByExample(resourceExample);
}
/**
*
* 使
*
* @param id
*/
@Override
@Transactional
public void deleteResource(String id) {
// 使用 MybatisDao 根据主键删除资源
mybatisDao.deleteByPrimaryKey(Resource.class, id);
}
/**
*
*
*
* @param limit
* @param offset
* @param resourceQuery
* @return Page<ResourceModel>
* @return
*/
@Override
public Page<ResourceModel> getResourceModelPage(int limit, int offset, ResourceQuery resourceQuery) {
// 使用 MybatisDao 进行分页查询,指定查询语句的命名空间和参数
return (Page<ResourceModel>) mybatisDao.selectPage(ResourceMapperExt.ResourceMapperNameSpace + "getResourceModel", resourceQuery, limit, offset);
}
/**
*
*
*
* @param limit
* @param offset
* @return Page<ResourceModel>
* @return
*/
@Override
public Page<ResourceModel> getResourceModelPage(int limit, int offset) {
// 使用 MybatisDao 进行分页查询,不传递查询参数
return (Page<ResourceModel>) mybatisDao.selectPage(ResourceMapperExt.ResourceMapperNameSpace + "getResourceModel", null, limit, offset);
}
/**
*
*
*
* @param resourceQuery
* @return List<ResourceModel>
* @return
*/
@Override
public List<ResourceModel> getResourceModelList(ResourceQuery resourceQuery) {
// 使用 MyBatis 的 SqlSessionTemplate 进行查询,指定查询语句的命名空间和参数
return mybatisDao.getSqlSessionTemplate().selectList(ResourceMapperExt.ResourceMapperNameSpace + "getResourceModel", resourceQuery);
}
/**
*
*
*
* @return List<ResourceModel>
* @return
*/
@Override
public List<ResourceModel> getResourceModelList() {
// 使用 MyBatis 的 SqlSessionTemplate 进行查询,不传递查询参数
return mybatisDao.getSqlSessionTemplate().selectList(ResourceMapperExt.ResourceMapperNameSpace + "getResourceModel");
}
/**
*
*
*
* @param id
* @return Resource
* @return
*/
@Override
public Resource getOneResource(String id) {
// 使用 MybatisDao 根据主键查询资源实体
return mybatisDao.selectByPrimaryKey(Resource.class, id);
}
/**
*
*
*
* @param id
* @return ResourceModel
* @return
*/
@Override
public ResourceModel getOneResourceModel(String id) {
ResourceQuery resourceQuery = new ResourceQuery();
// 设置查询条件为主键
resourceQuery.setId(id);
// 使用 MyBatis 的 SqlSessionTemplate 进行查询,指定查询语句的命名空间和参数
return mybatisDao.getSqlSessionTemplate().selectOne(ResourceMapperExt.ResourceMapperNameSpace + "getResourceModel", resourceQuery);
}
/**
* 1
* 1
*
* @param resourceQuery
* @return ResourceModel
* @return
* @throws TooManyResultsException
*/
@Override
public ResourceModel getOneResourceModel(ResourceQuery resourceQuery) throws TooManyResultsException {
// 使用 MyBatis 的 SqlSessionTemplate 进行查询,指定查询语句的命名空间和参数
return mybatisDao.getSqlSessionTemplate().selectOne(ResourceMapperExt.ResourceMapperNameSpace + "getResourceModel", resourceQuery);
}
}
}

@ -19,15 +19,20 @@ import java.util.Date;
@Component(value = "itemPurchaseJob")
public class ItemPurchaseJob implements Job {
// 注入PurchaseService
@Autowired
PurchaseService purchaseService;
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
// 如果purchaseService为空则从Spring上下文中获取
if(purchaseService == null){
purchaseService = (PurchaseService) SpringContextUtil.getApplicationContext().getBean(PurchaseService.class);
// 创建一个CreatePurchase对象
CreatePurchase createPurchase = new CreatePurchase();
// 设置订单日期为当前日期
createPurchase.setOrderDate(new Date());
// 调用PurchaseService的createPurchase方法创建采购订单
purchaseService.createPurchase(createPurchase);
}
}

@ -16,17 +16,21 @@ import java.text.SimpleDateFormat;
import java.util.Date;
/**
*
*/
@Component(value = "planJob")
public class PlanJob implements Job {
// 注入TablePlanSercvice
@Autowired
TablePlanSercvice tablePlanSercvice;
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
// 如果tablePlanSercvice为空则从Spring上下文中获取
if(tablePlanSercvice == null){
tablePlanSercvice = (TablePlanSercvice) SpringContextUtil.getApplicationContext().getBean(TablePlanSercvice.class);
// 调用createTablePlanOrder方法
tablePlanSercvice.createTablePlanOrder();
}
}

@ -10,52 +10,66 @@ import java.text.ParseException;
* Created by Jeng on 2016/2/23.
*/
public class QuartzManager {
// 静态的调度器工厂对象,用于创建调度器实例
private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
/**
*
* @param jobName
* @param jobGroup
* @param cls
* @param time
* @throws SchedulerException
* @throws ParseException
*
*
* @param jobName
* @param jobGroup
* @param cls Class
* @param time cron
* @throws SchedulerException
* @throws ParseException cron
*/
public static void addJob(String jobName, String jobGroup, Class cls, String time) throws SchedulerException, ParseException {
// 获取调度器实例
Scheduler scheduler = gSchedulerFactory.getScheduler();
// 根据任务名和任务组获取任务详情
JobDetail jobDetail = scheduler.getJobDetail(jobName, jobGroup);
if(jobDetail != null){
throw new SchedulerException("exist this jobDetail, jobName: " + jobName +", jobGroup: " + jobGroup +"");
// 如果任务详情已存在,则抛出异常
if (jobDetail != null) {
throw new SchedulerException("exist this jobDetail, jobName: " + jobName + ", jobGroup: " + jobGroup + "");
}
jobDetail = new JobDetail(jobName, jobGroup, cls);// 任务名,任务组,任务执行类
// 触发器
CronTrigger trigger = new CronTrigger(jobName, jobGroup);// 触发器名,触发器组
trigger.setCronExpression(time);// 触发器时间设定
// 创建新的任务详情对象,指定任务名、任务组和任务执行类
jobDetail = new JobDetail(jobName, jobGroup, cls);
// 创建新的 Cron 触发器对象,指定触发器名和触发器组
CronTrigger trigger = new CronTrigger(jobName, jobGroup);
// 设置触发器的 cron 表达式
trigger.setCronExpression(time);
// 将任务详情和触发器绑定并添加到调度器中
scheduler.scheduleJob(jobDetail, trigger);
// 启动
// 如果调度器未关闭,则启动调度器
if (!scheduler.isShutdown()) {
scheduler.start();
}
}
/**
*
* @param triggerName
* @param triggerGroupName
* @param time
* @throws SchedulerException
* @throws ParseException
*
*
* @param triggerName
* @param triggerGroupName
* @param time cron
* @throws SchedulerException
* @throws ParseException cron
*/
public static void modifyJobTime(String triggerName, String triggerGroupName, String time) throws SchedulerException, ParseException {
// 获取调度器实例
Scheduler scheduler = gSchedulerFactory.getScheduler();
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerName,triggerGroupName);
// 根据触发器名和触发器组获取触发器对象
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerName, triggerGroupName);
// 如果触发器不存在,则直接返回
if (trigger == null) {
return;
}
// 获取触发器原来的 cron 表达式
String oldTime = trigger.getCronExpression();
// 如果新的 cron 表达式与原来的不同,则进行修改
if (!oldTime.equalsIgnoreCase(time)) {
CronTrigger ct = (CronTrigger) trigger;
// 修改时间
// 设置新的 cron 表达式
ct.setCronExpression(time);
// 重启触发器
scheduler.resumeTrigger(triggerName, triggerGroupName);
@ -63,134 +77,162 @@ public class QuartzManager {
}
/**
* (使)
* @param jobName
* @throws SchedulerException
* 使
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*/
public static void removeJob(String jobName, String jobGroup) throws SchedulerException {
// 获取调度器实例
Scheduler scheduler = gSchedulerFactory.getScheduler();
if(scheduler.getJobDetail(jobName, jobGroup) == null){
// 如果任务详情不存在,则直接返回
if (scheduler.getJobDetail(jobName, jobGroup) == null) {
return;
}
if(Trigger.STATE_PAUSED != scheduler.getTriggerState(jobName, jobGroup)){
scheduler.pauseTrigger(jobName, jobGroup);// 停止触发器
// 如果触发器状态不是暂停状态,则暂停触发器
if (Trigger.STATE_PAUSED != scheduler.getTriggerState(jobName, jobGroup)) {
scheduler.pauseTrigger(jobName, jobGroup);
}
scheduler.unscheduleJob(jobName, jobGroup);// 移除触发器
scheduler.deleteJob(jobName, jobGroup);// 删除任务
// 移除触发器
scheduler.unscheduleJob(jobName, jobGroup);
// 删除任务
scheduler.deleteJob(jobName, jobGroup);
}
/**
*
* @throws SchedulerException
*
*
* @throws SchedulerException
*/
public static void startJobs() throws SchedulerException {
// 获取调度器实例并启动
Scheduler scheduler = gSchedulerFactory.getScheduler();
scheduler.start();
}
/**
*
* @throws SchedulerException
*
*
* @throws SchedulerException
*/
public static void shutdownJobs() throws SchedulerException {
// 获取调度器实例
Scheduler scheduler = gSchedulerFactory.getScheduler();
// 如果调度器未关闭,则关闭调度器
if (!scheduler.isShutdown()) {
scheduler.shutdown();
}
}
/**
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*/
public static void pauseJob(String jobName, String jobGroup) throws SchedulerException {
// 获取调度器实例
Scheduler scheduler = gSchedulerFactory.getScheduler();
if(Trigger.STATE_PAUSED != scheduler.getTriggerState(jobName, jobGroup)){
// 如果触发器状态不是暂停状态,则暂停任务
if (Trigger.STATE_PAUSED != scheduler.getTriggerState(jobName, jobGroup)) {
scheduler.pauseJob(jobName, jobGroup);
}
}
/**
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*/
public static void unscheduleJob(String jobName, String jobGroup) throws SchedulerException {
// 获取调度器实例并停止触发器
Scheduler scheduler = gSchedulerFactory.getScheduler();
scheduler.unscheduleJob(jobName, jobGroup);// 停止触发器
scheduler.unscheduleJob(jobName, jobGroup);
}
/**
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*/
public static void resumeJob(String jobName, String jobGroup) throws SchedulerException {
// 获取调度器实例并恢复任务
Scheduler scheduler = gSchedulerFactory.getScheduler();
scheduler.resumeJob(jobName, jobGroup);
}
/**
*
* @param jobName
* @param jobGroup
* @return
* @throws SchedulerException
*
*
* @param jobName
* @param jobGroup
* @return
* @throws SchedulerException
*/
public static int getJobTriggerState(String jobName,String jobGroup) throws SchedulerException {
public static int getJobTriggerState(String jobName, String jobGroup) throws SchedulerException {
// 获取调度器实例并返回触发器状态
Scheduler scheduler = gSchedulerFactory.getScheduler();
return scheduler.getTriggerState(jobName, jobGroup);
}
/**
* scheduler
* @return
* @throws SchedulerException
* scheduler
*
* @return
* @throws SchedulerException
*/
public static Scheduler getScheduler() throws SchedulerException {
// 从调度器工厂获取调度器实例
return gSchedulerFactory.getScheduler();
}
/**
*
* @param jobName
* @param jobGroup
* @return
* @throws SchedulerException
*
*
* @param jobName
* @param jobGroup
* @return
* @throws SchedulerException
*/
public static JobDetail getJobDetail(String jobName, String jobGroup) throws SchedulerException {
// 获取调度器实例并返回任务明细对象
Scheduler scheduler = gSchedulerFactory.getScheduler();
return scheduler.getJobDetail(jobName, jobGroup);
}
/**
*
* @param jobName
* @param jobGroup
* @return
* @throws SchedulerException
*
*
* @param jobName
* @param jobGroup
* @return
* @throws SchedulerException
*/
public static Trigger getTrigger(String jobName, String jobGroup) throws SchedulerException {
// 获取调度器实例并返回触发器对象
Scheduler scheduler = gSchedulerFactory.getScheduler();
return scheduler.getTrigger(jobName, jobGroup);
}
/**
*
* @param jobName
* @param jobGroup
* @return
* @throws SchedulerException
*
*
* @param jobName
* @param jobGroup
* @return true false
* @throws SchedulerException
*/
public static boolean isRunning(String jobName, String jobGroup) throws SchedulerException {
if(Trigger.STATE_NORMAL == getJobTriggerState(jobName, jobGroup)){
// 如果触发器状态为正常(运行中),则返回 true
if (Trigger.STATE_NORMAL == getJobTriggerState(jobName, jobGroup)) {
return true;
}
return false;
}
}
}

@ -19,12 +19,15 @@ import java.util.Date;
@Component(value = "stockDailyJob")
public class StockDailyJob implements Job {
// 注入StockDailyService
StockDailyService stockDailyService;
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
// 如果stockDailyService为空则从Spring上下文中获取
if (stockDailyService == null) {
stockDailyService = (StockDailyService) SpringContextUtil.getApplicationContext().getBean(StockDailyService.class);
// 调用createStockDaily方法
stockDailyService.createStockDaily();
}
}

@ -24,46 +24,63 @@ import java.util.List;
import java.util.Map;
/**
* HTTP
* Created by Jeng on 2016/2/23.
*/
@RestController
public class ScheduleController {
// 定义一个静态的List用于存储AddQuartzJob对象。
// 这里使用静态List可能存在线程安全问题在多线程环境下需要注意数据的一致性。
public static List<AddQuartzJob> data = new ArrayList<AddQuartzJob>();
// 自动注入定时任务服务类,用于处理定时任务的业务逻辑
@Autowired
ScheduleJobService scheduleJobService;
/**
*
* @param addQuartzJob
*
*
* @param addQuartzJob
* @param bindingResult
* @throws ArgumentValidException
*/
@RequestMapping(value = "/schedule", method = RequestMethod.POST)
public void addQuartzJob(@RequestBody @Valid AddQuartzJob addQuartzJob, BindingResult bindingResult) throws ArgumentValidException {
if(bindingResult != null && bindingResult.hasErrors()){
// 验证参数是否合法,如果有错误则抛出参数验证异常
if (bindingResult != null && bindingResult.hasErrors()) {
throw new ArgumentValidException(bindingResult);
}
// 获取触发器ID
String triggerId = addQuartzJob.getJobTriggerId();
if(!SpringContextUtil.getApplicationContext().containsBean(triggerId)){
// 判断Spring容器中是否存在该触发器如果不存在则抛出非法参数异常
if (!SpringContextUtil.getApplicationContext().containsBean(triggerId)) {
throw new IllegalArgumentException("所选模板文件错误此模板不属于Job接口实现类");
}
// 从Spring容器中获取触发器对象
Object obj = SpringContextUtil.getApplicationContext().getBean(triggerId);
if(obj == null){
if (obj == null) {
throw new IllegalArgumentException("所选模板文件错误此模板不属于Job接口实现类");
}
if(obj instanceof Job){
// 判断触发器对象是否为Job接口的实现类如果不是则抛出非法参数异常
if (obj instanceof Job) {
Job job = (Job) obj;
try {
// 创建ScheduleJob对象并设置相关属性
ScheduleJob scheduleJob = new ScheduleJob();
scheduleJob.setJobName(addQuartzJob.getJobName());
scheduleJob.setJobGroup(addQuartzJob.getJobGroup());
scheduleJob.setCronExpression(addQuartzJob.getCronExpression());
scheduleJob.setJobDescription(addQuartzJob.getDescription());
scheduleJob.setTriggerId(addQuartzJob.getJobTriggerId());
scheduleJob.setJobStatus(addQuartzJob.getStarted() ? Trigger.STATE_NORMAL : Trigger.STATE_PAUSED);
// 根据任务是否启动设置任务状态
scheduleJob.setJobStatus(addQuartzJob.getStarted()? Trigger.STATE_NORMAL : Trigger.STATE_PAUSED);
// 调用定时任务服务类的方法添加定时任务到数据库
scheduleJobService.addScheduleJob(scheduleJob);
// 调用QuartzManager的方法添加Quartz任务
QuartzManager.addJob(addQuartzJob.getJobName(), addQuartzJob.getJobGroup(), job.getClass(), addQuartzJob.getCronExpression());
if(Trigger.STATE_PAUSED == scheduleJob.getJobStatus()){
// 如果任务状态为暂停则调用QuartzManager的方法暂停任务
if (Trigger.STATE_PAUSED == scheduleJob.getJobStatus()) {
QuartzManager.pauseJob(addQuartzJob.getJobName(), addQuartzJob.getJobGroup());
}
} catch (SchedulerException e) {
@ -71,43 +88,57 @@ public class ScheduleController {
} catch (ParseException e) {
throw new IllegalArgumentException("错误的cron表达式");
}
}else{
} else {
throw new IllegalArgumentException("所选模板文件错误此模板不属于Job接口实现类");
}
}
/**
*
* @return
*
*
* @param keyword
* @param limit
* @param offset
* @return
*/
@RequestMapping(value = "/schedule", method = RequestMethod.GET)
public Page<ScheduleJobVo> getQuartzJob(@RequestParam(value = "keyword", required = false) String keyword,
@RequestParam(value = "limit") Integer limit,
@RequestParam(value = "offset") Integer offset){
@RequestParam(value = "limit") Integer limit,
@RequestParam(value = "offset") Integer offset) {
// 调用定时任务服务类的方法查询定时任务列表
return scheduleJobService.queryScheduleJobs(keyword, limit, offset);
}
/**
*
* @return
*
*
* @param id ID
* @param updateQuartzJob
* @param bindingResult
* @throws ArgumentValidException
*/
@RequestMapping(value = "/schedule/{id}", method = RequestMethod.PUT)
public void updateQuartzJob(@PathVariable(value = "id") Integer id,
@RequestBody @Valid UpdateQuartzJob updateQuartzJob, BindingResult bindingResult) throws ArgumentValidException {
if(bindingResult != null && bindingResult.hasErrors()){
// 验证参数是否合法,如果有错误则抛出参数验证异常
if (bindingResult != null && bindingResult.hasErrors()) {
throw new ArgumentValidException(bindingResult);
}
// 调用定时任务服务类的方法更新定时任务
scheduleJobService.updateScheduleJob(id, updateQuartzJob);
}
/**
*
* @return
*
*
* @return
*/
@RequestMapping(value = "/schedule/template", method = RequestMethod.GET)
public List<Map<String, String>> getQuartzTemplate(){
public List<Map<String, String>> getQuartzTemplate() {
// 从Spring容器中获取所有Job类型的Bean
Map<String, Job> jobs = SpringContextUtil.getApplicationContext().getBeansOfType(Job.class);
List<Map<String, String>> strings = new ArrayList<Map<String, String>>();
// 遍历所有Job类型的Bean构建包含触发器名称和键的Map并添加到列表中
for (Map.Entry<String, Job> stringJobEntry : jobs.entrySet()) {
Map<String, String> stringMap = new HashMap<String, String>();
stringMap.put("triggerName", stringJobEntry.getValue().getClass().getName());
@ -118,12 +149,13 @@ public class ScheduleController {
}
/**
*
* @return
*
*
* @param id ID
*/
@RequestMapping(value = "/schedule/{id}", method = RequestMethod.DELETE)
public void deleteQuartzJob(@PathVariable(value = "id") Integer id){
public void deleteQuartzJob(@PathVariable(value = "id") Integer id) {
// 调用定时任务服务类的方法删除定时任务
scheduleJobService.deleteScheduleJob(id);
}
}
}

@ -5,13 +5,21 @@ package com.xmomen.module.schedule.controller.vo;
*/
public class ScheduleJobVo {
// 任务ID
private Integer id;
// 任务名称
private String jobName;
// 任务组
private String jobGroup;
// 触发器ID
private String triggerId;
// 任务状态
private Integer jobStatus;
// 任务状态描述
private String jobStatusDesc;
// cron表达式
private String cronExpression;
// 任务描述
private String jobDescription;
public Integer getId() {

@ -5,9 +5,13 @@ package com.xmomen.module.schedule.controller.vo;
*/
public class UpdateQuartzJob {
// 暂停任务
public static String ACTION_PAUSE = "pause";
// 启动任务
public static String ACTION_START = "start";
// 重启任务
public static String ACTION_RESTART = "restart";
// 停止任务
public static String ACTION_STOP = "stop";
// 动作

@ -5,47 +5,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 定义一个名为ScheduleJobExample的类继承自BaseMybatisExample
public class ScheduleJobExample extends BaseMybatisExample {
// 定义一个orderByClause变量用于存储排序的子句
protected String orderByClause;
// 定义一个distinct变量用于存储是否去重的标志
protected boolean distinct;
// 定义一个oredCriteria变量用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria
public ScheduleJobExample() {
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) {
@ -54,37 +67,46 @@ public class ScheduleJobExample 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");
@ -92,6 +114,7 @@ public class ScheduleJobExample 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");
@ -99,6 +122,7 @@ public class ScheduleJobExample 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");
@ -106,373 +130,449 @@ public class ScheduleJobExample 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;
}
// 判断JOB_NAME是否为空
public Criteria andJobNameIsNull() {
addCriterion("JOB_NAME is null");
return (Criteria) this;
}
// 判断JOB_NAME是否不为空
public Criteria andJobNameIsNotNull() {
addCriterion("JOB_NAME is not null");
return (Criteria) this;
}
// 判断JOB_NAME是否等于某个值
public Criteria andJobNameEqualTo(String value) {
addCriterion("JOB_NAME =", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否不等于某个值
public Criteria andJobNameNotEqualTo(String value) {
addCriterion("JOB_NAME <>", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否大于某个值
public Criteria andJobNameGreaterThan(String value) {
addCriterion("JOB_NAME >", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否大于等于某个值
public Criteria andJobNameGreaterThanOrEqualTo(String value) {
addCriterion("JOB_NAME >=", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否小于某个值
public Criteria andJobNameLessThan(String value) {
addCriterion("JOB_NAME <", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否小于等于某个值
public Criteria andJobNameLessThanOrEqualTo(String value) {
addCriterion("JOB_NAME <=", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否包含某个值
public Criteria andJobNameLike(String value) {
addCriterion("JOB_NAME like", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否不包含某个值
public Criteria andJobNameNotLike(String value) {
addCriterion("JOB_NAME not like", value, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否在某个范围内
public Criteria andJobNameIn(List<String> values) {
addCriterion("JOB_NAME in", values, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否不在某个范围内
public Criteria andJobNameNotIn(List<String> values) {
addCriterion("JOB_NAME not in", values, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否在某个范围内
public Criteria andJobNameBetween(String value1, String value2) {
addCriterion("JOB_NAME between", value1, value2, "jobName");
return (Criteria) this;
}
// 判断JOB_NAME是否不在某个范围内
public Criteria andJobNameNotBetween(String value1, String value2) {
addCriterion("JOB_NAME not between", value1, value2, "jobName");
return (Criteria) this;
}
// 判断JOB_GROUP是否为空
public Criteria andJobGroupIsNull() {
addCriterion("JOB_GROUP is null");
return (Criteria) this;
}
// 判断JOB_GROUP是否不为空
public Criteria andJobGroupIsNotNull() {
addCriterion("JOB_GROUP is not null");
return (Criteria) this;
}
// 判断JOB_GROUP是否等于某个值
public Criteria andJobGroupEqualTo(String value) {
addCriterion("JOB_GROUP =", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否不等于某个值
public Criteria andJobGroupNotEqualTo(String value) {
addCriterion("JOB_GROUP <>", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否大于某个值
public Criteria andJobGroupGreaterThan(String value) {
addCriterion("JOB_GROUP >", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否大于等于某个值
public Criteria andJobGroupGreaterThanOrEqualTo(String value) {
addCriterion("JOB_GROUP >=", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否小于某个值
public Criteria andJobGroupLessThan(String value) {
addCriterion("JOB_GROUP <", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否小于等于某个值
public Criteria andJobGroupLessThanOrEqualTo(String value) {
addCriterion("JOB_GROUP <=", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否包含某个值
public Criteria andJobGroupLike(String value) {
addCriterion("JOB_GROUP like", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否不包含某个值
public Criteria andJobGroupNotLike(String value) {
addCriterion("JOB_GROUP not like", value, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否在某个范围内
public Criteria andJobGroupIn(List<String> values) {
addCriterion("JOB_GROUP in", values, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否不在某个范围内
public Criteria andJobGroupNotIn(List<String> values) {
addCriterion("JOB_GROUP not in", values, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否在某个范围内
public Criteria andJobGroupBetween(String value1, String value2) {
addCriterion("JOB_GROUP between", value1, value2, "jobGroup");
return (Criteria) this;
}
// 判断JOB_GROUP是否不在某个范围内
public Criteria andJobGroupNotBetween(String value1, String value2) {
addCriterion("JOB_GROUP not between", value1, value2, "jobGroup");
return (Criteria) this;
}
// 判断JOB_STATUS是否为空
public Criteria andJobStatusIsNull() {
addCriterion("JOB_STATUS is null");
return (Criteria) this;
}
// 判断JOB_STATUS是否不为空
public Criteria andJobStatusIsNotNull() {
addCriterion("JOB_STATUS is not null");
return (Criteria) this;
}
// 判断JOB_STATUS是否等于某个值
public Criteria andJobStatusEqualTo(Integer value) {
addCriterion("JOB_STATUS =", value, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否不等于某个值
public Criteria andJobStatusNotEqualTo(Integer value) {
addCriterion("JOB_STATUS <>", value, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否大于某个值
public Criteria andJobStatusGreaterThan(Integer value) {
addCriterion("JOB_STATUS >", value, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否大于等于某个值
public Criteria andJobStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("JOB_STATUS >=", value, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否小于某个值
public Criteria andJobStatusLessThan(Integer value) {
addCriterion("JOB_STATUS <", value, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否小于等于某个值
public Criteria andJobStatusLessThanOrEqualTo(Integer value) {
addCriterion("JOB_STATUS <=", value, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否在某个范围内
public Criteria andJobStatusIn(List<Integer> values) {
addCriterion("JOB_STATUS in", values, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否不在某个范围内
public Criteria andJobStatusNotIn(List<Integer> values) {
addCriterion("JOB_STATUS not in", values, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否在某个范围内
public Criteria andJobStatusBetween(Integer value1, Integer value2) {
addCriterion("JOB_STATUS between", value1, value2, "jobStatus");
return (Criteria) this;
}
// 判断JOB_STATUS是否不在某个范围内
public Criteria andJobStatusNotBetween(Integer value1, Integer value2) {
addCriterion("JOB_STATUS not between", value1, value2, "jobStatus");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否为空
public Criteria andJobDescriptionIsNull() {
addCriterion("JOB_DESCRIPTION is null");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否不为空
public Criteria andJobDescriptionIsNotNull() {
addCriterion("JOB_DESCRIPTION is not null");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否等于某个值
public Criteria andJobDescriptionEqualTo(String value) {
addCriterion("JOB_DESCRIPTION =", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否不等于某个值
public Criteria andJobDescriptionNotEqualTo(String value) {
addCriterion("JOB_DESCRIPTION <>", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否大于某个值
public Criteria andJobDescriptionGreaterThan(String value) {
addCriterion("JOB_DESCRIPTION >", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否大于等于某个值
public Criteria andJobDescriptionGreaterThanOrEqualTo(String value) {
addCriterion("JOB_DESCRIPTION >=", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否小于某个值
public Criteria andJobDescriptionLessThan(String value) {
addCriterion("JOB_DESCRIPTION <", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否小于等于某个值
public Criteria andJobDescriptionLessThanOrEqualTo(String value) {
addCriterion("JOB_DESCRIPTION <=", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否包含某个值
public Criteria andJobDescriptionLike(String value) {
addCriterion("JOB_DESCRIPTION like", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否不包含某个值
public Criteria andJobDescriptionNotLike(String value) {
addCriterion("JOB_DESCRIPTION not like", value, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否在某个范围内
public Criteria andJobDescriptionIn(List<String> values) {
addCriterion("JOB_DESCRIPTION in", values, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否不在某个范围内
public Criteria andJobDescriptionNotIn(List<String> values) {
addCriterion("JOB_DESCRIPTION not in", values, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否在某个范围内
public Criteria andJobDescriptionBetween(String value1, String value2) {
addCriterion("JOB_DESCRIPTION between", value1, value2, "jobDescription");
return (Criteria) this;
}
// 判断JOB_DESCRIPTION是否不在某个范围内
public Criteria andJobDescriptionNotBetween(String value1, String value2) {
addCriterion("JOB_DESCRIPTION not between", value1, value2, "jobDescription");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否为空
public Criteria andCronExpressionIsNull() {
addCriterion("CRON_EXPRESSION is null");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否不为空
public Criteria andCronExpressionIsNotNull() {
addCriterion("CRON_EXPRESSION is not null");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否等于某个值
public Criteria andCronExpressionEqualTo(String value) {
addCriterion("CRON_EXPRESSION =", value, "cronExpression");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否不等于某个值
public Criteria andCronExpressionNotEqualTo(String value) {
addCriterion("CRON_EXPRESSION <>", value, "cronExpression");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否大于某个值
public Criteria andCronExpressionGreaterThan(String value) {
addCriterion("CRON_EXPRESSION >", value, "cronExpression");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否大于等于某个值
public Criteria andCronExpressionGreaterThanOrEqualTo(String value) {
addCriterion("CRON_EXPRESSION >=", value, "cronExpression");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否小于某个值
public Criteria andCronExpressionLessThan(String value) {
addCriterion("CRON_EXPRESSION <", value, "cronExpression");
return (Criteria) this;
}
// 判断CRON_EXPRESSION是否小于等于某个值
public Criteria andCronExpressionLessThanOrEqualTo(String value) {
addCriterion("CRON_EXPRESSION <=", value, "cronExpression");
return (Criteria) this
```java
return (Criteria) this;
}

@ -5,12 +5,17 @@ import com.xmomen.module.schedule.entity.ScheduleJobExample;
import com.xmomen.framework.mybatis.mapper.MybatisMapper;
import org.apache.ibatis.annotations.Param;
// ScheduleJobMapper接口继承MybatisMapper
public interface ScheduleJobMapper extends MybatisMapper {
// 根据example统计ScheduleJob数量
int countByExample(ScheduleJobExample example);
// 根据example删除ScheduleJob
int deleteByExample(ScheduleJobExample example);
// 插入ScheduleJob
int insertSelective(ScheduleJob record);
// 根据example更新ScheduleJob
int updateByExampleSelective(@Param("record") ScheduleJob record, @Param("example") ScheduleJobExample example);
}

@ -5,5 +5,6 @@ package com.xmomen.module.schedule.mapper;
*/
public interface ScheduleMapper {
// 定义ScheduleMapper的命名空间
public static final String ScheduleMapperNameSpace = "com.xmomen.module.schedule.mapper.ScheduleMapper.";
}

@ -1,14 +1,33 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xmomen.module.schedule.mapper.ScheduleMapper" >
<!-- 查询计划任务 -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xmomen.module.schedule.mapper.ScheduleMapper">
<!--
该 SQL 语句用于查询计划任务。
id: 此查询语句在 MyBatis 中的唯一标识,在代码中通过这个标识来调用该查询。
resultType: 指定查询结果映射到的 Java 类,这里是 com.xmomen.module.schedule.controller.vo.ScheduleJobVo
意味着查询结果将被映射到这个类的实例中。
parameterType: 指定传入的参数类型,这里是 java.lang.String表示传入的参数是一个字符串类型。
-->
<select id="queryScheduleJobs" resultType="com.xmomen.module.schedule.controller.vo.ScheduleJobVo" parameterType="java.lang.String">
SELECT
<!-- 选择计划任务表中的 ID 字段 -->
ID,
<!-- 选择计划任务表中的 JOB_NAME 字段 -->
JOB_NAME,
<!-- 选择计划任务表中的 JOB_GROUP 字段 -->
JOB_GROUP,
<!-- 选择计划任务表中的 JOB_STATUS 字段 -->
JOB_STATUS,
<!-- 使用 CASE 语句根据 JOB_STATUS 的值进行转换,生成一个新的字段 jobStatusDesc
用于表示任务状态的描述信息。
当 JOB_STATUS 为 0 时jobStatusDesc 为 '运行中'
当 JOB_STATUS 为 1 时jobStatusDesc 为 '暂停'
当 JOB_STATUS 为 2 时jobStatusDesc 为 '已完成'
当 JOB_STATUS 为 3 时jobStatusDesc 为 '异常'
当 JOB_STATUS 为 4 时jobStatusDesc 为 '阻塞'
当 JOB_STATUS 为 -1 时jobStatusDesc 为 '无'
否则jobStatusDesc 为 '错误状态码'。
-->
CASE
JOB_STATUS
WHEN 0
@ -25,10 +44,18 @@
THEN '无'
ELSE '错误状态码'
END AS jobStatusDesc,
<!-- 选择计划任务表中的 JOB_DESCRIPTION 字段 -->
JOB_DESCRIPTION,
<!-- 选择计划任务表中的 CRON_EXPRESSION 字段 -->
CRON_EXPRESSION,
<!-- 选择计划任务表中的 TRIGGER_ID 字段 -->
TRIGGER_ID
FROM
schedule_job where (JOB_NAME LIKE CONCAT('%', #{keyword} , '%')) OR (JOB_DESCRIPTION LIKE CONCAT('%', #{keyword} , '%')) OR (JOB_GROUP LIKE CONCAT('%', #{keyword} , '%'))
schedule_job
<!-- 使用 WHERE 子句进行条件查询,条件是 JOB_NAME、JOB_DESCRIPTION 或 JOB_GROUP 字段
模糊匹配传入的关键字 #{keyword}。
CONCAT('%', #{keyword}, '%') 用于构建模糊匹配的字符串,'%' 表示任意字符。
-->
where (JOB_NAME LIKE CONCAT('%', #{keyword} , '%')) OR (JOB_DESCRIPTION LIKE CONCAT('%', #{keyword} , '%')) OR (JOB_GROUP LIKE CONCAT('%', #{keyword} , '%'))
</select>
</mapper>

@ -34,14 +34,16 @@ public class Client {
public static Response execute(Request request) throws Exception {
switch (request.getMethod()) {
case GET:
return HttpUtil.httpGet(request.getHost(), request.getPath(),
// 发送GET请求
return HttpUtil.httpGet(request.getHost(), request.getPath(),
request.getTimeout(),
request.getHeaders(),
request.getQuerys(),
request.getSignHeaderPrefixList(),
request.getAppKey(), request.getAppSecret());
case POST_FORM:
return HttpUtil.httpPost(request.getHost(), request.getPath(),
// 发送POST表单请求
return HttpUtil.httpPost(request.getHost(), request.getPath(),
request.getTimeout(),
request.getHeaders(),
request.getQuerys(),
@ -49,7 +51,8 @@ public class Client {
request.getSignHeaderPrefixList(),
request.getAppKey(), request.getAppSecret());
case POST_STRING:
return HttpUtil.httpPost(request.getHost(), request.getPath(),
// 发送POST字符串请求
return HttpUtil.httpPost(request.getHost(), request.getPath(),
request.getTimeout(),
request.getHeaders(),
request.getQuerys(),
@ -57,7 +60,8 @@ public class Client {
request.getSignHeaderPrefixList(),
request.getAppKey(), request.getAppSecret());
case POST_BYTES:
return HttpUtil.httpPost(request.getHost(), request.getPath(),
// 发送POST字节数组请求
return HttpUtil.httpPost(request.getHost(), request.getPath(),
request.getTimeout(),
request.getHeaders(),
request.getQuerys(),
@ -65,7 +69,8 @@ public class Client {
request.getSignHeaderPrefixList(),
request.getAppKey(), request.getAppSecret());
case PUT_STRING:
return HttpUtil.httpPut(request.getHost(), request.getPath(),
// 发送PUT字符串请求
return HttpUtil.httpPut(request.getHost(), request.getPath(),
request.getTimeout(),
request.getHeaders(),
request.getQuerys(),
@ -73,7 +78,8 @@ public class Client {
request.getSignHeaderPrefixList(),
request.getAppKey(), request.getAppSecret());
case PUT_BYTES:
return HttpUtil.httpPut(request.getHost(), request.getPath(),
// 发送PUT字节数组请求
return HttpUtil.httpPut(request.getHost(), request.getPath(),
request.getTimeout(),
request.getHeaders(),
request.getQuerys(),
@ -81,13 +87,15 @@ public class Client {
request.getSignHeaderPrefixList(),
request.getAppKey(), request.getAppSecret());
case DELETE:
return HttpUtil.httpDelete(request.getHost(), request.getPath(),
// 发送DELETE请求
return HttpUtil.httpDelete(request.getHost(), request.getPath(),
request.getTimeout(),
request.getHeaders(),
request.getQuerys(),
request.getSignHeaderPrefixList(),
request.getAppKey(), request.getAppSecret());
default:
// 不支持的请求方法
throw new IllegalArgumentException(String.format("unsupported method:%s", request.getMethod()));
}
}

@ -3,54 +3,72 @@ package com.xmomen.module.sms.api;
import java.util.HashMap;
import java.util.Map;
// 定义一个名为Response的类用于封装HTTP响应
public class Response {
// 定义状态码
private int statusCode;
// 定义内容类型
private String contentType;
// 定义请求ID
private String requestId;
// 定义错误信息
private String errorMessage;
// 定义头部信息
private Map<String, String> headers;
// 定义响应体
private String body;
// 构造函数
public Response() {
}
// 获取状态码
public int getStatusCode() {
return statusCode;
}
// 设置状态码
public void setStatusCode(int statusCode) {
this.statusCode = statusCode;
}
// 获取内容类型
public String getContentType() {
return contentType;
}
// 设置内容类型
public void setContentType(String contentType) {
this.contentType = contentType;
}
// 获取请求ID
public String getRequestId() {
return requestId;
}
// 设置请求ID
public void setRequestId(String requestId) {
this.requestId = requestId;
}
// 获取错误信息
public String getErrorMessage() {
return errorMessage;
}
// 设置错误信息
public void setErrorMessage(String errorMessage) {
this.errorMessage = errorMessage;
}
// 获取头部信息
public Map<String, String> getHeaders() {
return headers;
}
// 根据键获取头部信息
public String getHeader(String key) {
if (null != headers) {
return headers.get(key);
@ -59,10 +77,12 @@ public class Response {
}
}
// 设置头部信息
public void setHeaders(Map<String, String> headers) {
this.headers = headers;
}
// 根据键值对设置头部信息
public void setHeader(String key, String value) {
if (null == this.headers) {
this.headers = new HashMap<String, String>();
@ -70,10 +90,12 @@ public class Response {
this.headers.put(key, value);
}
// 获取响应体
public String getBody() {
return body;
}
// 设置响应体
public void setBody(String body) {
this.body = body;
}

@ -25,12 +25,14 @@
//
// private MNSClient client;
//
// // 启动时创建连接
// public void startUp() {
// CloudAccount account = new CloudAccount("LTAI1klbIDX7r7cw",
// "YIy5b9LtvfRvboEXhJjztmJCY7eO2I",
// "http://1478678502173333.mns.cn-hangzhou.aliyuncs.com/");
// client = account.getMNSClient();
// }
// // 发送单个请求
// public SmsResponse sendSingleRequest(String phoneNumber) throws Exception {
// if(client == null || !client.isOpen()) {
// log.info("client已关闭重新创建连接");
@ -85,6 +87,7 @@
// }
// }
//
// // 发送密码信息
// public SmsResponse sendPasswordInfo(String phoneNumber, String plainPassword) {
// if(client == null || !client.isOpen()) {
// log.info("client已关闭重新创建连接");
@ -123,6 +126,7 @@
// }
// }
//
// // 在属性设置完成后调用
// @Override
// public void afterPropertiesSet() throws Exception {
// startUp();

@ -1,21 +1,29 @@
package com.xmomen.module.sms.api;
// 定义一个SmsResponse类用于封装短信发送的响应结果
public class SmsResponse {
// 定义一个布尔类型的success变量用于表示短信发送是否成功
private boolean success;
// 定义一个字符串类型的message变量用于表示短信发送的结果信息
private String message;
// 无参构造方法
public SmsResponse() {}
// 设置success变量的值
public void setSuccess(boolean success) {
this.success = success;
}
// 获取success变量的值
public boolean getSuccess() {
return success;
}
// 设置message变量的值
public void setMessage(String message) {
this.message = message;
}
// 获取message变量的值
public String getMessage() {
return message;
}

@ -7,12 +7,17 @@ import java.util.concurrent.TimeUnit;
import lombok.Data;
// 定义一个验证码模型类
public @Data class IdentifyCodeModel {
// 验证码
private String identifyCode;
// 创建时间
private Date createTime;
// 过期时间
private Date expiredTime;
// 构造函数,传入验证码、有效时间和时间单位
public IdentifyCodeModel(String identifyCode, Long validTime, TimeUnit timeUnit) {
this.identifyCode = identifyCode;
Calendar calendar = new GregorianCalendar();
@ -39,13 +44,16 @@ public @Data class IdentifyCodeModel {
}
}
// 构造函数,传入验证码和有效时间,默认时间单位为秒
public IdentifyCodeModel(String identifyCode, Long validTime) {
this(identifyCode, validTime, TimeUnit.SECONDS);
}
// 构造函数传入验证码默认有效时间为null
public IdentifyCodeModel(String identifyCode) {
this(identifyCode, null);
}
// 判断验证码是否过期
public boolean isExpired() {
Date now = new Date();
if(expiredTime == null) return false;

@ -8,13 +8,16 @@ import com.xmomen.module.sms.model.IdentifyCodeModel;
public class GlobalIdentifyCodeManager {
// 定义一个全局的验证码缓存使用ConcurrentHashMap实现线程安全
static Map<String, IdentifyCodeModel> identifyCodeCache = new ConcurrentHashMap<String, IdentifyCodeModel>();
//static Map<String, IdentifyCodeModel> operationCodeCache = new ConcurrentHashMap<String, IdentifyCodeModel>();
// 根据验证码key获取验证码
public static IdentifyCodeModel getIdentifyCode(String identifyCodeKey) {
return identifyCodeCache.get(identifyCodeKey);
}
// 更新验证码并设置过期时间为15分钟
public static IdentifyCodeModel updateIdenfifyCode(String identifyCodeKey, String identifyCode) {
IdentifyCodeModel identifyCodeModel = new IdentifyCodeModel(identifyCode, 15L, TimeUnit.MINUTES);
identifyCodeCache.put(identifyCodeKey, identifyCodeModel);

@ -87,17 +87,29 @@ public class HttpUtil {
*/
public static Response httpGet(String host, String path, int connectTimeout, Map<String, String> headers, Map<String, String> querys, List<String> signHeaderPrefixList, String appKey, String appSecret)
throws Exception {
// 初始化基础Header
// 初始化基础Header
headers = initialBasicHeader(HttpMethod.GET, path, headers, querys, null, signHeaderPrefixList, appKey, appSecret);
// 创建HttpClient对象
// 设置连接超时时间
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpGet对象
// 设置连接超时时间
httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, getTimeout(connectTimeout));
// 添加Header
// 创建HttpGet对象
HttpGet get = new HttpGet(initUrl(host, path, querys));
// 执行请求并返回Response
// 添加Header
for (Map.Entry<String, String> e : headers.entrySet()) {
get.addHeader(e.getKey(), MessageDigestUtil.utf8ToIso88591(e.getValue()));
}
// 执行请求并返回Response
return convert(httpClient.execute(get));
}
@ -115,80 +127,124 @@ public class HttpUtil {
* @return
* @throws Exception
*/
// 设置Content-Type为表单类型
public static Response httpPost(String host, String path, int connectTimeout, Map<String, String> headers, Map<String, String> querys, Map<String, String> bodys, List<String> signHeaderPrefixList, String appKey, String appSecret)
throws Exception {
// 初始化基础Header
if (headers == null) {
headers = new HashMap<String, String>();
// 创建HttpClient对象
}
// 设置连接超时时间
// 设置Content-Type为表单类型
// 创建HttpPost对象
headers.put(HttpHeader.HTTP_HEADER_CONTENT_TYPE, ContentType.CONTENT_TYPE_FORM);
// 添加Header
// 初始化基础Header
headers = initialBasicHeader(HttpMethod.POST, path, headers, querys, bodys, signHeaderPrefixList, appKey, appSecret);
// 构建表单实体
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 设置连接超时时间
httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, getTimeout(connectTimeout));
// 执行请求并返回Response
// 创建HttpPost对象
HttpPost post = new HttpPost(initUrl(host, path, querys));
// 添加Header
for (Map.Entry<String, String> e : headers.entrySet()) {
post.addHeader(e.getKey(), MessageDigestUtil.utf8ToIso88591(e.getValue()));
}
// 构建表单实体
UrlEncodedFormEntity formEntity = buildFormEntity(bodys);
if (formEntity != null) {
post.setEntity(formEntity);
}
// 执行请求并返回Response
return convert(httpClient.execute(post));
}
/**
* Http POST
// 初始化基础Header
* @param host
* @param path
// 创建HttpClient对象
* @param connectTimeout
// 设置连接超时时间
* @param headers
* @param querys
// 创建HttpPost对象
* @param body
// 添加Header
* @param signHeaderPrefixList
* @param appKey
// 初始化基础Header
* @param appSecret
// 设置请求体
* @return
// 创建HttpClient对象
* @throws Exception
// 设置连接超时时间
*/
// 执行请求并返回Response
public static Response httpPost(String host, String path, int connectTimeout, Map<String, String> headers, Map<String, String> querys, String body, List<String> signHeaderPrefixList, String appKey, String appSecret)
// 创建HttpPost对象
throws Exception {
// 添加Header
headers = initialBasicHeader(HttpMethod.POST, path, headers, querys, null, signHeaderPrefixList, appKey, appSecret);
HttpClient httpClient = wrapClient(host);
httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, getTimeout(connectTimeout));
// 设置请求体
HttpPost post = new HttpPost(initUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
post.addHeader(e.getKey(), MessageDigestUtil.utf8ToIso88591(e.getValue()));
// 执行请求并返回Response
}
if (StringUtils.isNotBlank(body)) {
post.setEntity(new StringEntity(body, Constants.ENCODING));
// 初始化基础Header
}
// 创建HttpClient对象
return convert(httpClient.execute(post));
// 设置连接超时时间
}
// 创建HttpPost对象
/**
// 添加Header
* HTTP POST
// 初始化基础Header
* @param host
* @param path
// 设置请求体
// 创建HttpClient对象
* @param connectTimeout
// 设置连接超时时间
* @param headers
// 执行请求并返回Response
* @param querys
// 创建HttpPost对象
* @param bodys
// 添加Header
* @param signHeaderPrefixList
* @param appKey
* @param appSecret
* @return
// 设置请求体
* @throws Exception
*/
// 执行请求并返回Response
public static Response httpPost(String host, String path, int connectTimeout, Map<String, String> headers, Map<String, String> querys, byte[] bodys, List<String> signHeaderPrefixList, String appKey, String appSecret)
throws Exception {
headers = initialBasicHeader(HttpMethod.POST, path, headers, querys, null, signHeaderPrefixList, appKey, appSecret);
@ -196,26 +252,40 @@ public class HttpUtil {
HttpClient httpClient = wrapClient(host);
httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, getTimeout(connectTimeout));
// 初始化基础Header
HttpPost post = new HttpPost(initUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
// 创建HttpClient对象
post.addHeader(e.getKey(), MessageDigestUtil.utf8ToIso88591(e.getValue()));
// 设置连接超时时间
}
// 创建HttpPut对象
if (bodys != null) {
// 添加Header
post.setEntity(new ByteArrayEntity(bodys));
// 初始化基础Header
}
// 设置请求体
// 创建HttpClient对象
return convert(httpClient.execute(post));
// 设置连接超时时间
}
// 执行请求并返回Response
// 创建HttpPut对象
/**
// 添加Header
* HTTP PUT
* @param host
* @param path
* @param connectTimeout
// 设置请求体
* @param headers
* @param querys
* @param body
// 执行请求并返回Response
* @param signHeaderPrefixList
* @param appKey
* @param appSecret
@ -223,24 +293,38 @@ public class HttpUtil {
* @throws Exception
*/
public static Response httpPut(String host, String path, int connectTimeout, Map<String, String> headers, Map<String, String> querys, String body, List<String> signHeaderPrefixList, String appKey, String appSecret)
// 初始化基础Header
throws Exception {
headers = initialBasicHeader(HttpMethod.PUT, path, headers, querys, null, signHeaderPrefixList, appKey, appSecret);
// 创建HttpClient对象
// 设置连接超时时间
HttpClient httpClient = wrapClient(host);
httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, getTimeout(connectTimeout));
// 创建HttpPut对象
// 添加Header
HttpPut put = new HttpPut(initUrl(host, path, querys));
// 初始化基础Header
for (Map.Entry<String, String> e : headers.entrySet()) {
put.addHeader(e.getKey(), MessageDigestUtil.utf8ToIso88591(e.getValue()));
// 设置请求体
// 创建HttpClient对象
}
// 设置连接超时时间
// 执行请求并返回Response
if (StringUtils.isNotBlank(body)) {
// 创建HttpPut对象
put.setEntity(new StringEntity(body, Constants.ENCODING));
// 添加Header
}
// 设置请求体
return convert(httpClient.execute(put));
}
// 执行请求并返回Response
/**
* HTTP PUT
@ -248,25 +332,38 @@ public class HttpUtil {
* @param path
* @param connectTimeout
* @param headers
// 初始化基础Header
* @param querys
* @param bodys
// 创建HttpClient对象
* @param signHeaderPrefixList
// 设置连接超时时间
* @param appKey
* @param appSecret
// 创建HttpDelete对象
* @return
// 添加Header
* @throws Exception
// 初始化基础Header
*/
public static Response httpPut(String host, String path, int connectTimeout, Map<String, String> headers, Map<String, String> querys, byte[] bodys, List<String> signHeaderPrefixList, String appKey, String appSecret)
// 执行请求并返回Response
// 创建HttpClient对象
throws Exception {
// 设置连接超时时间
headers = initialBasicHeader(HttpMethod.PUT, path, headers, querys, null, signHeaderPrefixList, appKey, appSecret);
// 创建HttpDelete对象
HttpClient httpClient = wrapClient(host);
// 添加Header
httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, getTimeout(connectTimeout));
HttpPut put = new HttpPut(initUrl(host, path, querys));
// 执行请求并返回Response
for (Map.Entry<String, String> e : headers.entrySet()) {
put.addHeader(e.getKey(), MessageDigestUtil.utf8ToIso88591(e.getValue()));
}
// 构建表单参数
if (bodys != null) {
put.setEntity(new ByteArrayEntity(bodys));
@ -275,6 +372,7 @@ public class HttpUtil {
return convert(httpClient.execute(put));
}
// 构建表单参数
/**
* HTTP DELETE
* @param host
@ -333,9 +431,17 @@ public class HttpUtil {
sbUrl.append(path);
}
if (null != querys) {
// 添加时间戳
// 添加时间戳
// 添加随机数
StringBuilder sbQuery = new StringBuilder();
// 添加AppKey
// 添加随机数
// 添加签名
for (Map.Entry<String, String> query : querys.entrySet()) {
// 添加AppKey
if (0 < sbQuery.length()) {
// 添加签名
sbQuery.append(Constants.SPE3);
}
if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
@ -356,18 +462,30 @@ public class HttpUtil {
return sbUrl.toString();
}
// 设置状态码
// 设置Header
/**
* Header
// 设置状态码
// 设置Content-Type
* @param method
// 设置RequestId
// 设置Header
// 设置ErrorMessage
* @param path
// 设置Body
* @param headers
* @param querys
* @param bodys
// 设置Content-Type
* @param signHeaderPrefixList
// 设置RequestId
* @param appKey
// 设置ErrorMessage
* @param appSecret
// 设置Body
* @return
* @throws MalformedURLException
*/
@ -383,6 +501,7 @@ public class HttpUtil {
}
headers.put(SystemHeader.X_CA_TIMESTAMP, String.valueOf(new Date().getTime()));
// 读取流并转换为字符串
//headers.put(SystemHeader.X_CA_NONCE, UUID.randomUUID().toString());
headers.put(SystemHeader.X_CA_KEY, appKey);
headers.put(SystemHeader.X_CA_SIGNATURE,
@ -390,6 +509,7 @@ public class HttpUtil {
return headers;
}
// 读取流并转换为字符串
/**
*
@ -404,14 +524,18 @@ public class HttpUtil {
return timeout;
}
// 创建SSLContext对象
// 创建X509TrustManager对象
private static Response convert(HttpResponse response) throws IOException {
Response res = new Response();
if (null != response) {
res.setStatusCode(response.getStatusLine().getStatusCode());
for (Header header : response.getAllHeaders()) {
// 创建SSLContext对象
res.setHeader(header.getName(), MessageDigestUtil.iso88591ToUtf8(header.getValue()));
// 创建X509TrustManager对象
}
res.setContentType(res.getHeader("Content-Type"));

@ -48,13 +48,17 @@ public class HttpUtils {
Map<String, String> headers,
Map<String, String> querys)
throws Exception {
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpGet对象
HttpGet request = new HttpGet(buildUrl(host, path, querys));
// 添加请求头
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
// 执行请求
return httpClient.execute(request);
}
@ -75,13 +79,17 @@ public class HttpUtils {
Map<String, String> querys,
Map<String, String> bodys)
throws Exception {
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpPost对象
HttpPost request = new HttpPost(buildUrl(host, path, querys));
// 添加请求头
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
// 添加请求体
if (bodys != null) {
List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
@ -93,6 +101,7 @@ public class HttpUtils {
request.setEntity(formEntity);
}
// 执行请求
return httpClient.execute(request);
}
@ -113,17 +122,22 @@ public class HttpUtils {
Map<String, String> querys,
String body)
throws Exception {
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpPost对象
HttpPost request = new HttpPost(buildUrl(host, path, querys));
// 添加请求头
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
// 添加请求体
if (StringUtils.isNotBlank(body)) {
request.setEntity(new StringEntity(body, "utf-8"));
}
// 执行请求
return httpClient.execute(request);
}
@ -144,17 +158,22 @@ public class HttpUtils {
Map<String, String> querys,
byte[] body)
throws Exception {
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpPost对象
HttpPost request = new HttpPost(buildUrl(host, path, querys));
// 添加请求头
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
// 添加请求体
if (body != null) {
request.setEntity(new ByteArrayEntity(body));
}
// 执行请求
return httpClient.execute(request);
}
@ -174,17 +193,22 @@ public class HttpUtils {
Map<String, String> querys,
String body)
throws Exception {
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpPut对象
HttpPut request = new HttpPut(buildUrl(host, path, querys));
// 添加请求头
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
// 添加请求体
if (StringUtils.isNotBlank(body)) {
request.setEntity(new StringEntity(body, "utf-8"));
}
// 执行请求
return httpClient.execute(request);
}
@ -204,17 +228,22 @@ public class HttpUtils {
Map<String, String> querys,
byte[] body)
throws Exception {
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpPut对象
HttpPut request = new HttpPut(buildUrl(host, path, querys));
// 添加请求头
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
// 添加请求体
if (body != null) {
request.setEntity(new ByteArrayEntity(body));
}
// 执行请求
return httpClient.execute(request);
}
@ -233,13 +262,17 @@ public class HttpUtils {
Map<String, String> headers,
Map<String, String> querys)
throws Exception {
// 创建HttpClient对象
HttpClient httpClient = wrapClient(host);
// 创建HttpDelete对象
HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
// 添加请求头
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
// 执行请求
return httpClient.execute(request);
}
@ -285,7 +318,9 @@ public class HttpUtils {
private static void sslClient(HttpClient httpClient) {
try {
// 创建SSLContext对象
SSLContext ctx = SSLContext.getInstance("TLS");
// 创建X509TrustManager对象
X509TrustManager tm = new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
@ -297,11 +332,17 @@ public class HttpUtils {
}
};
// 初始化SSLContext对象
ctx.init(null, new TrustManager[] { tm }, null);
// 创建SSLSocketFactory对象
SSLSocketFactory ssf = new SSLSocketFactory(ctx);
// 设置主机名验证器
ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
// 获取HttpClient的连接管理器
ClientConnectionManager ccm = httpClient.getConnectionManager();
// 获取SchemeRegistry对象
SchemeRegistry registry = ccm.getSchemeRegistry();
// 注册Scheme对象
registry.register(new Scheme("https", 443, ssf));
} catch (KeyManagementException ex) {
throw new RuntimeException(ex);

@ -5,47 +5,60 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
// 定义一个StockExample类继承自BaseMybatisExample类
public class StockExample extends BaseMybatisExample {
// 定义一个orderByClause变量用于存储排序的SQL语句
protected String orderByClause;
// 定义一个distinct变量用于存储是否去重的SQL语句
protected boolean distinct;
// 定义一个oredCriteria变量用于存储查询条件的列表
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria变量
public StockExample() {
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) {
@ -54,37 +67,46 @@ public class StockExample 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");
@ -92,6 +114,7 @@ public class StockExample 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");
@ -99,6 +122,7 @@ public class StockExample 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");
@ -106,371 +130,445 @@ public class StockExample 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(String value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
// 判断id是否不等于某个值
public Criteria andIdNotEqualTo(String value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
// 判断id是否大于某个值
public Criteria andIdGreaterThan(String value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
// 判断id是否大于等于某个值
public Criteria andIdGreaterThanOrEqualTo(String value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
// 判断id是否小于某个值
public Criteria andIdLessThan(String value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
// 判断id是否小于等于某个值
public Criteria andIdLessThanOrEqualTo(String value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
// 判断id是否包含某个值
public Criteria andIdLike(String value) {
addCriterion("id like", value, "id");
return (Criteria) this;
}
// 判断id是否不包含某个值
public Criteria andIdNotLike(String value) {
addCriterion("id not like", value, "id");
return (Criteria) this;
}
// 判断id是否在某个值列表中
public Criteria andIdIn(List<String> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
// 判断id是否不在某个值列表中
public Criteria andIdNotIn(List<String> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
// 判断id是否在某个值范围内
public Criteria andIdBetween(String value1, String value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
// 判断id是否不在某个值范围内
public Criteria andIdNotBetween(String value1, String value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 判断itemId是否为空
public Criteria andItemIdIsNull() {
addCriterion("item_id is null");
return (Criteria) this;
}
// 判断itemId是否不为空
public Criteria andItemIdIsNotNull() {
addCriterion("item_id is not null");
return (Criteria) this;
}
// 判断itemId是否等于某个值
public Criteria andItemIdEqualTo(Integer value) {
addCriterion("item_id =", value, "itemId");
return (Criteria) this;
}
// 判断itemId是否不等于某个值
public Criteria andItemIdNotEqualTo(Integer value) {
addCriterion("item_id <>", value, "itemId");
return (Criteria) this;
}
// 判断itemId是否大于某个值
public Criteria andItemIdGreaterThan(Integer value) {
addCriterion("item_id >", value, "itemId");
return (Criteria) this;
}
// 判断itemId是否大于等于某个值
public Criteria andItemIdGreaterThanOrEqualTo(Integer value) {
addCriterion("item_id >=", value, "itemId");
return (Criteria) this;
}
// 判断itemId是否小于某个值
public Criteria andItemIdLessThan(Integer value) {
addCriterion("item_id <", value, "itemId");
return (Criteria) this;
}
// 判断itemId是否小于等于某个值
public Criteria andItemIdLessThanOrEqualTo(Integer value) {
addCriterion("item_id <=", value, "itemId");
return (Criteria) this;
}
// 判断itemId是否在某个值列表中
public Criteria andItemIdIn(List<Integer> values) {
addCriterion("item_id in", values, "itemId");
return (Criteria) this;
}
// 判断itemId是否不在某个值列表中
public Criteria andItemIdNotIn(List<Integer> values) {
addCriterion("item_id not in", values, "itemId");
return (Criteria) this;
}
// 判断itemId是否在某个值范围内
public Criteria andItemIdBetween(Integer value1, Integer value2) {
addCriterion("item_id between", value1, value2, "itemId");
return (Criteria) this;
}
// 判断itemId是否不在某个值范围内
public Criteria andItemIdNotBetween(Integer value1, Integer value2) {
addCriterion("item_id not between", value1, value2, "itemId");
return (Criteria) this;
}
// 判断stockNum是否为空
public Criteria andStockNumIsNull() {
addCriterion("stock_num is null");
return (Criteria) this;
}
// 判断stockNum是否不为空
public Criteria andStockNumIsNotNull() {
addCriterion("stock_num is not null");
return (Criteria) this;
}
// 判断stockNum是否等于某个值
public Criteria andStockNumEqualTo(Integer value) {
addCriterion("stock_num =", value, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否不等于某个值
public Criteria andStockNumNotEqualTo(Integer value) {
addCriterion("stock_num <>", value, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否大于某个值
public Criteria andStockNumGreaterThan(Integer value) {
addCriterion("stock_num >", value, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否大于等于某个值
public Criteria andStockNumGreaterThanOrEqualTo(Integer value) {
addCriterion("stock_num >=", value, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否小于某个值
public Criteria andStockNumLessThan(Integer value) {
addCriterion("stock_num <", value, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否小于等于某个值
public Criteria andStockNumLessThanOrEqualTo(Integer value) {
addCriterion("stock_num <=", value, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否在某个值列表中
public Criteria andStockNumIn(List<Integer> values) {
addCriterion("stock_num in", values, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否不在某个值列表中
public Criteria andStockNumNotIn(List<Integer> values) {
addCriterion("stock_num not in", values, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否在某个值范围内
public Criteria andStockNumBetween(Integer value1, Integer value2) {
addCriterion("stock_num between", value1, value2, "stockNum");
return (Criteria) this;
}
// 判断stockNum是否不在某个值范围内
public Criteria andStockNumNotBetween(Integer value1, Integer value2) {
addCriterion("stock_num not between", value1, value2, "stockNum");
return (Criteria) this;
}
// 判断warningNum是否为空
public Criteria andWarningNumIsNull() {
addCriterion("warning_num is null");
return (Criteria) this;
}
// 判断warningNum是否不为空
public Criteria andWarningNumIsNotNull() {
addCriterion("warning_num is not null");
return (Criteria) this;
}
// 判断warningNum是否等于某个值
public Criteria andWarningNumEqualTo(Integer value) {
addCriterion("warning_num =", value, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否不等于某个值
public Criteria andWarningNumNotEqualTo(Integer value) {
addCriterion("warning_num <>", value, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否大于某个值
public Criteria andWarningNumGreaterThan(Integer value) {
addCriterion("warning_num >", value, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否大于等于某个值
public Criteria andWarningNumGreaterThanOrEqualTo(Integer value) {
addCriterion("warning_num >=", value, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否小于某个值
public Criteria andWarningNumLessThan(Integer value) {
addCriterion("warning_num <", value, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否小于等于某个值
public Criteria andWarningNumLessThanOrEqualTo(Integer value) {
addCriterion("warning_num <=", value, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否在某个值列表中
public Criteria andWarningNumIn(List<Integer> values) {
addCriterion("warning_num in", values, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否不在某个值列表中
public Criteria andWarningNumNotIn(List<Integer> values) {
addCriterion("warning_num not in", values, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否在某个值范围内
public Criteria andWarningNumBetween(Integer value1, Integer value2) {
addCriterion("warning_num between", value1, value2, "warningNum");
return (Criteria) this;
}
// 判断warningNum是否不在某个值范围内
public Criteria andWarningNumNotBetween(Integer value1, Integer value2) {
addCriterion("warning_num not between", value1, value2, "warningNum");
return (Criteria) this;
}
// 判断insertDate是否为空
public Criteria andInsertDateIsNull() {
addCriterion("insert_date is null");
return (Criteria) this;
}
// 判断insertDate是否不为空
public Criteria andInsertDateIsNotNull() {
addCriterion("insert_date is not null");
return (Criteria) this;
}
// 判断insertDate是否等于某个值
public Criteria andInsertDateEqualTo(Date value) {
addCriterion("insert_date =", value, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否不等于某个值
public Criteria andInsertDateNotEqualTo(Date value) {
addCriterion("insert_date <>", value, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否大于某个值
public Criteria andInsertDateGreaterThan(Date value) {
addCriterion("insert_date >", value, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否大于等于某个值
public Criteria andInsertDateGreaterThanOrEqualTo(Date value) {
addCriterion("insert_date >=", value, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否小于某个值
public Criteria andInsertDateLessThan(Date value) {
addCriterion("insert_date <", value, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否小于等于某个值
public Criteria andInsertDateLessThanOrEqualTo(Date value) {
addCriterion("insert_date <=", value, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否在某个值列表中
public Criteria andInsertDateIn(List<Date> values) {
addCriterion("insert_date in", values, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否不在某个值列表中
public Criteria andInsertDateNotIn(List<Date> values) {
addCriterion("insert_date not in", values, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否在某个值范围内
public Criteria andInsertDateBetween(Date value1, Date value2) {
addCriterion("insert_date between", value1, value2, "insertDate");
return (Criteria) this;
}
// 判断insertDate是否不在某个值范围内
public Criteria andInsertDateNotBetween(Date value1, Date value2) {
addCriterion("insert_date not between", value1, value2, "insertDate");
return (Criteria) this;
}
// 判断insertUserId是否为空
public Criteria andInsertUserIdIsNull() {
addCriterion("insert_user_id is null");
return (Criteria) this;
}
// 判断insertUserId是否不为空
public Criteria andInsertUserIdIsNotNull() {
addCriterion("insert_user_id is not null");
return (Criteria) this;
}
// 判断insertUserId是否等于某个值
public Criteria andInsertUserIdEqualTo(Integer value) {
addCriterion("insert_user_id =", value, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否不等于某个值
public Criteria andInsertUserIdNotEqualTo(Integer value) {
addCriterion("insert_user_id <>", value, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否大于某个值
public Criteria andInsertUserIdGreaterThan(Integer value) {
addCriterion("insert_user_id >", value, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否大于等于某个值
public Criteria andInsertUserIdGreaterThanOrEqualTo(Integer value) {
addCriterion("insert_user_id >=", value, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否小于某个值
public Criteria andInsertUserIdLessThan(Integer value) {
addCriterion("insert_user_id <", value, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否小于等于某个值
public Criteria andInsertUserIdLessThanOrEqualTo(Integer value) {
addCriterion("insert_user_id <=", value, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否在某个值列表中
public Criteria andInsertUserIdIn(List<Integer> values) {
addCriterion("insert_user_id in", values, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否不在某个值列表中
public Criteria andInsertUserIdNotIn(List<Integer> values) {
addCriterion("insert_user_id not in", values, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否在某个值范围内
public Criteria andInsertUserIdBetween(Integer value1, Integer value2) {
addCriterion("insert_user_id between", value1, value2, "insertUserId");
return (Criteria) this;
}
// 判断insertUserId是否不在某个值范围内
public Criteria andInsertUserIdNotBetween(Integer value1, Integer value2) {
addCriterion("insert_user_id not between", value1, value2, "insertUserId");
return (Criteria) this;

@ -5,47 +5,60 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
// 定义一个StockRecordExample类继承自BaseMybatisExample类
public class StockRecordExample extends BaseMybatisExample {
// 定义一个orderByClause变量用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria变量
public StockRecordExample() {
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) {
@ -54,37 +67,46 @@ public class StockRecordExample 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");
@ -92,6 +114,7 @@ public class StockRecordExample 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");
@ -99,6 +122,7 @@ public class StockRecordExample 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");
@ -106,336 +130,403 @@ public class StockRecordExample 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(String value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否不等于某个值
public Criteria andIdNotEqualTo(String value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否大于某个值
public Criteria andIdGreaterThan(String value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否大于等于某个值
public Criteria andIdGreaterThanOrEqualTo(String value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否小于某个值
public Criteria andIdLessThan(String value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否小于等于某个值
public Criteria andIdLessThanOrEqualTo(String value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否包含某个值
public Criteria andIdLike(String value) {
addCriterion("id like", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否不包含某个值
public Criteria andIdNotLike(String value) {
addCriterion("id not like", value, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否在某个范围内
public Criteria andIdIn(List<String> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否不在某个范围内
public Criteria andIdNotIn(List<String> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否在某个范围内
public Criteria andIdBetween(String value1, String value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
// 添加一个查询条件判断id是否不在某个范围内
public Criteria andIdNotBetween(String value1, String value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否为空
public Criteria andStockIdIsNull() {
addCriterion("stock_id is null");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否不为空
public Criteria andStockIdIsNotNull() {
addCriterion("stock_id is not null");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否等于某个值
public Criteria andStockIdEqualTo(String value) {
addCriterion("stock_id =", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否不等于某个值
public Criteria andStockIdNotEqualTo(String value) {
addCriterion("stock_id <>", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否大于某个值
public Criteria andStockIdGreaterThan(String value) {
addCriterion("stock_id >", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否大于等于某个值
public Criteria andStockIdGreaterThanOrEqualTo(String value) {
addCriterion("stock_id >=", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否小于某个值
public Criteria andStockIdLessThan(String value) {
addCriterion("stock_id <", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否小于等于某个值
public Criteria andStockIdLessThanOrEqualTo(String value) {
addCriterion("stock_id <=", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否包含某个值
public Criteria andStockIdLike(String value) {
addCriterion("stock_id like", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否不包含某个值
public Criteria andStockIdNotLike(String value) {
addCriterion("stock_id not like", value, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否在某个范围内
public Criteria andStockIdIn(List<String> values) {
addCriterion("stock_id in", values, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否不在某个范围内
public Criteria andStockIdNotIn(List<String> values) {
addCriterion("stock_id not in", values, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否在某个范围内
public Criteria andStockIdBetween(String value1, String value2) {
addCriterion("stock_id between", value1, value2, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断stockId是否不在某个范围内
public Criteria andStockIdNotBetween(String value1, String value2) {
addCriterion("stock_id not between", value1, value2, "stockId");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否为空
public Criteria andChangeNumIsNull() {
addCriterion("change_num is null");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否不为空
public Criteria andChangeNumIsNotNull() {
addCriterion("change_num is not null");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否等于某个值
public Criteria andChangeNumEqualTo(Integer value) {
addCriterion("change_num =", value, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否不等于某个值
public Criteria andChangeNumNotEqualTo(Integer value) {
addCriterion("change_num <>", value, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否大于某个值
public Criteria andChangeNumGreaterThan(Integer value) {
addCriterion("change_num >", value, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否大于等于某个值
public Criteria andChangeNumGreaterThanOrEqualTo(Integer value) {
addCriterion("change_num >=", value, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否小于某个值
public Criteria andChangeNumLessThan(Integer value) {
addCriterion("change_num <", value, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否小于等于某个值
public Criteria andChangeNumLessThanOrEqualTo(Integer value) {
addCriterion("change_num <=", value, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否在某个范围内
public Criteria andChangeNumIn(List<Integer> values) {
addCriterion("change_num in", values, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否不在某个范围内
public Criteria andChangeNumNotIn(List<Integer> values) {
addCriterion("change_num not in", values, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否在某个范围内
public Criteria andChangeNumBetween(Integer value1, Integer value2) {
addCriterion("change_num between", value1, value2, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changeNum是否不在某个范围内
public Criteria andChangeNumNotBetween(Integer value1, Integer value2) {
addCriterion("change_num not between", value1, value2, "changeNum");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否为空
public Criteria andChangTypeIsNull() {
addCriterion("chang_type is null");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否不为空
public Criteria andChangTypeIsNotNull() {
addCriterion("chang_type is not null");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否等于某个值
public Criteria andChangTypeEqualTo(Integer value) {
addCriterion("chang_type =", value, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否不等于某个值
public Criteria andChangTypeNotEqualTo(Integer value) {
addCriterion("chang_type <>", value, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否大于某个值
public Criteria andChangTypeGreaterThan(Integer value) {
addCriterion("chang_type >", value, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否大于等于某个值
public Criteria andChangTypeGreaterThanOrEqualTo(Integer value) {
addCriterion("chang_type >=", value, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否小于某个值
public Criteria andChangTypeLessThan(Integer value) {
addCriterion("chang_type <", value, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否小于等于某个值
public Criteria andChangTypeLessThanOrEqualTo(Integer value) {
addCriterion("chang_type <=", value, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否在某个范围内
public Criteria andChangTypeIn(List<Integer> values) {
addCriterion("chang_type in", values, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否不在某个范围内
public Criteria andChangTypeNotIn(List<Integer> values) {
addCriterion("chang_type not in", values, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否在某个范围内
public Criteria andChangTypeBetween(Integer value1, Integer value2) {
addCriterion("chang_type between", value1, value2, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断changType是否不在某个范围内
public Criteria andChangTypeNotBetween(Integer value1, Integer value2) {
addCriterion("chang_type not between", value1, value2, "changType");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否为空
public Criteria andRefOrderIdIsNull() {
addCriterion("ref_order_id is null");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否不为空
public Criteria andRefOrderIdIsNotNull() {
addCriterion("ref_order_id is not null");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否等于某个值
public Criteria andRefOrderIdEqualTo(Integer value) {
addCriterion("ref_order_id =", value, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否不等于某个值
public Criteria andRefOrderIdNotEqualTo(Integer value) {
addCriterion("ref_order_id <>", value, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否大于某个值
public Criteria andRefOrderIdGreaterThan(Integer value) {
addCriterion("ref_order_id >", value, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否大于等于某个值
public Criteria andRefOrderIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ref_order_id >=", value, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否小于某个值
public Criteria andRefOrderIdLessThan(Integer value) {
addCriterion("ref_order_id <", value, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否小于等于某个值
public Criteria andRefOrderIdLessThanOrEqualTo(Integer value) {
addCriterion("ref_order_id <=", value, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否在某个范围内
public Criteria andRefOrderIdIn(List<Integer> values) {
addCriterion("ref_order_id in", values, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否不在某个范围内
public Criteria andRefOrderIdNotIn(List<Integer> values) {
addCriterion("ref_order_id not in", values, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否在某个范围内
public Criteria andRefOrderIdBetween(Integer value1, Integer value2) {
addCriterion("ref_order_id between", value1, value2, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断refOrderId是否不在某个范围内
public Criteria andRefOrderIdNotBetween(Integer value1, Integer value2) {
addCriterion("ref_order_id not between", value1, value2, "refOrderId");
return (Criteria) this;
}
// 添加一个查询条件判断remark是否为空
public Criteria andRemarkIsNull() {
addCriterion("remark is null");
return (Criteria) this;
}
// 添加一个查询条件判断remark是否不为空
public Criteria andRemarkIsNotNull() {
addCriterion("remark is not null");
return (Criteria) this;
}
// 添加一个查询条件判断remark是否等于某个值
public Criteria andRemarkEqualTo(String value) {
addCriterion("remark =", value, "remark");
return (Criteria) this;

@ -5,12 +5,17 @@ import com.xmomen.module.stock.entity.Stock;
import com.xmomen.module.stock.entity.StockExample;
import org.apache.ibatis.annotations.Param;
// 定义一个StockMapper接口继承MybatisMapper
public interface StockMapper extends MybatisMapper {
// 根据条件统计Stock数量
int countByExample(StockExample example);
// 根据条件删除Stock
int deleteByExample(StockExample example);
// 插入Stock
int insertSelective(Stock record);
// 根据条件更新Stock
int updateByExampleSelective(@Param("record") Stock record, @Param("example") StockExample example);
}

@ -1,8 +1,15 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xmomen.module.stock.entity.mapper.StockMapper" >
<resultMap id="BaseResultMap" type="com.xmomen.module.stock.entity.Stock" >
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xmomen.module.stock.entity.mapper.StockMapper">
<!--
定义结果映射,将数据库查询结果映射到 Java 实体类 com.xmomen.module.stock.entity.Stock。
id: 结果映射的唯一标识。
type: 要映射到的 Java 实体类。
-->
<resultMap id="BaseResultMap" type="com.xmomen.module.stock.entity.Stock">
<!-- 定义主键映射,将数据库列 id 映射到实体类的 id 属性 -->
<id column="id" property="id" jdbcType="VARCHAR" />
<!-- 定义其他字段的映射,将数据库列映射到实体类的对应属性 -->
<result column="item_id" property="itemId" jdbcType="INTEGER" />
<result column="stock_num" property="stockNum" jdbcType="INTEGER" />
<result column="warning_num" property="warningNum" jdbcType="INTEGER" />
@ -11,25 +18,34 @@
<result column="update_date" property="updateDate" jdbcType="TIMESTAMP" />
<result column="update_user_id" property="updateUserId" jdbcType="INTEGER" />
</resultMap>
<sql id="Example_Where_Clause" >
<where >
<foreach collection="oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
<!--
定义查询条件 SQL 片段,用于生成动态的 WHERE 子句。
这里根据 StockExample 中的查询条件集合 oredCriteria 来生成条件。
-->
<sql id="Example_Where_Clause">
<where>
<foreach collection="oredCriteria" item="criteria" separator="or">
<if test="criteria.valid">
<trim prefix="(" suffix=")" prefixOverrides="and">
<foreach collection="criteria.criteria" item="criterion">
<choose>
<!-- 当条件不带值时(如 IS NULL 等) -->
<when test="criterion.noValue">
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
<!-- 当条件带单个值时 -->
<when test="criterion.singleValue">
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
<!-- 当条件带范围值时(如 BETWEEN 条件) -->
<when test="criterion.betweenValue">
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
<!-- 当条件带值列表时(如 IN 条件) -->
<when test="criterion.listValue">
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
#{listItem}
</foreach>
</when>
@ -40,25 +56,30 @@
</foreach>
</where>
</sql>
<sql id="Update_By_Example_Where_Clause" >
<where >
<foreach collection="example.oredCriteria" item="criteria" separator="or" >
<if test="criteria.valid" >
<trim prefix="(" suffix=")" prefixOverrides="and" >
<foreach collection="criteria.criteria" item="criterion" >
<choose >
<when test="criterion.noValue" >
<!--
定义更新操作的 WHERE 子句 SQL 片段,逻辑与 Example_Where_Clause 类似,
用于根据 Example 中的条件生成更新的 WHERE 子句。
-->
<sql id="Update_By_Example_Where_Clause">
<where>
<foreach collection="example.oredCriteria" item="criteria" separator="or">
<if test="criteria.valid">
<trim prefix="(" suffix=")" prefixOverrides="and">
<foreach collection="criteria.criteria" item="criterion">
<choose>
<when test="criterion.noValue">
and ${criterion.condition}
</when>
<when test="criterion.singleValue" >
<when test="criterion.singleValue">
and ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue" >
<when test="criterion.betweenValue">
and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
</when>
<when test="criterion.listValue" >
<when test="criterion.listValue">
and ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator="," >
<foreach collection="criterion.value" item="listItem" open="(" close=")" separator=",">
#{listItem}
</foreach>
</when>
@ -69,118 +90,158 @@
</foreach>
</where>
</sql>
<sql id="Base_Column_List" >
<!-- 定义基础列列表,列出要查询的数据库列 -->
<sql id="Base_Column_List">
id, item_id, stock_num, warning_num, insert_date, insert_user_id, update_date, update_user_id
</sql>
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.stock.entity.StockExample" >
<!--
定义根据示例条件查询的 SQL 语句。
id: 语句的唯一标识。
resultMap: 使用的结果映射,这里是 BaseResultMap。
parameterType: 传入的参数类型,这里是 StockExample。
-->
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.stock.entity.StockExample">
select
<if test="distinct" >
<if test="distinct">
distinct
</if>
<!-- 引入基础列列表 -->
<include refid="Base_Column_List" />
from cd_stock
<if test="_parameter != null" >
<if test="_parameter != null">
<!-- 引入查询条件 SQL 片段 -->
<include refid="Example_Where_Clause" />
</if>
<if test="orderByClause != null" >
<if test="orderByClause != null">
order by ${orderByClause}
</if>
</select>
<delete id="deleteByExample" parameterType="com.xmomen.module.stock.entity.StockExample" >
<!--
定义根据示例条件删除的 SQL 语句。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是 StockExample。
-->
<delete id="deleteByExample" parameterType="com.xmomen.module.stock.entity.StockExample">
delete from cd_stock
<if test="_parameter != null" >
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</delete>
<insert id="insertSelective" parameterType="com.xmomen.module.stock.entity.Stock" useGeneratedKeys="true" keyProperty="id" keyColumn="id" >
<selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE" >
<!--
定义插入操作的 SQL 语句,使用选择性插入(只插入非空字段)。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是 Stock 实体类。
useGeneratedKeys: 是否使用数据库生成的主键,这里设为 true。
keyProperty: 主键对应的实体类属性。
keyColumn: 主键对应的数据库列。
-->
<insert id="insertSelective" parameterType="com.xmomen.module.stock.entity.Stock" useGeneratedKeys="true" keyProperty="id" keyColumn="id">
<!-- 生成 UUID 作为主键,在插入前执行 -->
<selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE">
SELECT replace(UUID(),'-','')
</selectKey>
insert into cd_stock
<trim prefix="(" suffix=")" suffixOverrides="," >
<trim prefix="(" suffix=")" suffixOverrides=",">
id,
<if test="itemId != null" >
<if test="itemId != null">
item_id,
</if>
<if test="stockNum != null" >
<if test="stockNum != null">
stock_num,
</if>
<if test="warningNum != null" >
<if test="warningNum != null">
warning_num,
</if>
<if test="insertDate != null" >
<if test="insertDate != null">
insert_date,
</if>
<if test="insertUserId != null" >
<if test="insertUserId != null">
insert_user_id,
</if>
<if test="updateDate != null" >
<if test="updateDate != null">
update_date,
</if>
<if test="updateUserId != null" >
<if test="updateUserId != null">
update_user_id,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<trim prefix="values (" suffix=")" suffixOverrides=",">
#{id,jdbcType=VARCHAR},
<if test="itemId != null" >
<if test="itemId != null">
#{itemId,jdbcType=INTEGER},
</if>
<if test="stockNum != null" >
<if test="stockNum != null">
#{stockNum,jdbcType=INTEGER},
</if>
<if test="warningNum != null" >
<if test="warningNum != null">
#{warningNum,jdbcType=INTEGER},
</if>
<if test="insertDate != null" >
<if test="insertDate != null">
#{insertDate,jdbcType=TIMESTAMP},
</if>
<if test="insertUserId != null" >
<if test="insertUserId != null">
#{insertUserId,jdbcType=INTEGER},
</if>
<if test="updateDate != null" >
<if test="updateDate != null">
#{updateDate,jdbcType=TIMESTAMP},
</if>
<if test="updateUserId != null" >
<if test="updateUserId != null">
#{updateUserId,jdbcType=INTEGER},
</if>
</trim>
</insert>
<select id="countByExample" parameterType="com.xmomen.module.stock.entity.StockExample" resultType="java.lang.Integer" >
<!--
定义根据示例条件统计数量的 SQL 语句。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是 StockExample。
resultType: 返回的结果类型,这里是整数类型。
-->
<select id="countByExample" parameterType="com.xmomen.module.stock.entity.StockExample" resultType="java.lang.Integer">
select count(*) from cd_stock
<if test="_parameter != null" >
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</select>
<update id="updateByExampleSelective" parameterType="map" >
<!--
定义根据示例条件选择性更新的 SQL 语句。
id: 语句的唯一标识。
parameterType: 传入的参数类型,这里是一个 Map包含 record 和 example 等信息。
-->
<update id="updateByExampleSelective" parameterType="map">
update cd_stock
<set >
<if test="record.id != null" >
<set>
<if test="record.id != null">
id = #{record.id,jdbcType=VARCHAR},
</if>
<if test="record.itemId != null" >
<if test="record.itemId != null">
item_id = #{record.itemId,jdbcType=INTEGER},
</if>
<if test="record.stockNum != null" >
<if test="record.stockNum != null">
stock_num = #{record.stockNum,jdbcType=INTEGER},
</if>
<if test="record.warningNum != null" >
<if test="record.warningNum != null">
warning_num = #{record.warningNum,jdbcType=INTEGER},
</if>
<if test="record.insertDate != null" >
<if test="record.insertDate != null">
insert_date = #{record.insertDate,jdbcType=TIMESTAMP},
</if>
<if test="record.insertUserId != null" >
<if test="record.insertUserId != null">
insert_user_id = #{record.insertUserId,jdbcType=INTEGER},
</if>
<if test="record.updateDate != null" >
<if test="record.updateDate != null">
update_date = #{record.updateDate,jdbcType=TIMESTAMP},
</if>
<if test="record.updateUserId != null" >
<if test="record.updateUserId != null">
update_user_id = #{record.updateUserId,jdbcType=INTEGER},
</if>
</set>
<if test="_parameter != null" >
<if test="_parameter != null">
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>

@ -5,12 +5,17 @@ import com.xmomen.module.stock.entity.StockRecord;
import com.xmomen.module.stock.entity.StockRecordExample;
import org.apache.ibatis.annotations.Param;
// 定义StockRecordMapper接口继承MybatisMapper
public interface StockRecordMapper extends MybatisMapper {
// 根据条件统计StockRecord数量
int countByExample(StockRecordExample example);
// 根据条件删除StockRecord
int deleteByExample(StockRecordExample example);
// 插入StockRecord
int insertSelective(StockRecord record);
// 根据条件更新StockRecord
int updateByExampleSelective(@Param("record") StockRecord record, @Param("example") StockRecordExample example);
}

@ -1,6 +1,8 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 命名空间用于区分不同的mapper -->
<mapper namespace="com.xmomen.module.stock.entity.mapper.StockRecordMapper" >
<!-- 结果映射,将数据库中的字段映射到实体类的属性 -->
<resultMap id="BaseResultMap" type="com.xmomen.module.stock.entity.StockRecord" >
<id column="id" property="id" jdbcType="VARCHAR" />
<result column="stock_id" property="stockId" jdbcType="VARCHAR" />
@ -13,6 +15,7 @@
<result column="update_user_id" property="updateUserId" jdbcType="INTEGER" />
<result column="update_date" property="updateDate" jdbcType="TIMESTAMP" />
</resultMap>
<!-- SQL片段用于条件查询 -->
<sql id="Example_Where_Clause" >
<where >
<foreach collection="oredCriteria" item="criteria" separator="or" >
@ -72,7 +75,7 @@
</where>
</sql>
<sql id="Base_Column_List" >
id, stock_id, change_num, chang_type, ref_order_id, remark, insert_user_id, insert_date,
id, stock_id, change_num, chang_type, ref_order_id, remark, insert_user_id, insert_date,
update_user_id, update_date
</sql>
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.stock.entity.StockRecordExample" >

@ -7,6 +7,7 @@ package com.xmomen.module.stock.mapper;
*/
public interface StockMapperExt {
// 定义StockMapperExt命名空间
public static final String StockMapperNameSpace = "com.xmomen.module.stock.mapper.StockMapperExt.";
}

@ -14,24 +14,30 @@
cd_stock t
LEFT JOIN cd_item item ON t.item_id = item.id
<where>
<!-- 如果id不为空则添加条件 -->
<if test="id">
AND t.ID = #{id}
</if>
<!-- 如果keyword不为空则添加条件 -->
<if test="keyword">
AND (item.item_code LIKE CONCAT('%', #{keyword}, '%') OR item.item_name LIKE CONCAT('%', #{keyword}, '%') )
</if>
<!-- 如果itemCode不为空则添加条件 -->
<if test="itemCode">
AND item.item_code LIKE CONCAT('%', #{itemCode}, '%')
</if>
<!-- 如果itemName不为空则添加条件 -->
<if test="itemName">
AND item.item_name LIKE CONCAT('%', #{itemName}, '%')
</if>
<!-- 如果ids不为空则添加条件 -->
<if test="ids">
AND t.ID IN
<foreach collection="ids" item="item" separator="," open="(" close=")">
#{item}
</foreach>
</if>
<!-- 如果excludeIds不为空则添加条件 -->
<if test="excludeIds">
AND t.ID NOT IN
<foreach collection="excludeIds" item="item" separator="," open="(" close=")">

@ -7,6 +7,7 @@ package com.xmomen.module.stock.mapper;
*/
public interface StockRecordMapperExt {
// 定义StockRecordMapperExt命名空间
public static final String StockRecordMapperNameSpace = "com.xmomen.module.stock.mapper.StockRecordMapperExt.";
}

@ -1,22 +1,40 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xmomen.module.stock.mapper.StockRecordMapperExt" >
<!-- 查询消息 -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xmomen.module.stock.mapper.StockRecordMapperExt">
<!--
定义一个查询语句,用于获取库存记录模型数据。
id: 该查询语句的唯一标识,在代码中通过此标识调用该查询。
resultType: 指定查询结果映射到的 Java 类,这里是 com.xmomen.module.stock.model.StockRecordModel。
parameterType: 指定传入的参数类型,这里是查询条件对象 com.xmomen.module.stock.model.StockRecordQuery。
-->
<select id="getStockRecordModel"
resultType="com.xmomen.module.stock.model.StockRecordModel"
parameterType="com.xmomen.module.stock.model.StockRecordQuery">
SELECT
t.*
,item.item_name
,item.item_code
,tborder.order_no
t.*,
<!-- 关联查询出商品的名称 -->
item.item_name,
<!-- 关联查询出商品的编码 -->
item.item_code,
<!-- 关联查询出订单的订单号 -->
tborder.order_no
FROM
cd_stock_record t
cd_stock_record t
<!-- 左连接 cd_stock 表,根据库存记录中的 stock_id 关联库存表 -->
LEFT JOIN cd_stock stock ON t.stock_id = stock.id
<!-- 左连接 cd_item 表,根据库存表中的 item_id 关联商品表 -->
LEFT JOIN cd_item item ON stock.item_id = item.id
<!-- 左连接 tb_order 表,根据库存记录中的 ref_order_id 关联订单表 -->
LEFT JOIN tb_order tborder ON tborder.id = t.ref_order_id
<!--
<where> 标签用于动态生成 SQL 的 WHERE 子句。
它会自动处理子句开头多余的 AND 关键字。
-->
<where>
<!--
如果查询条件中的 id 不为空,添加条件 t.ID = #{id} 到 WHERE 子句中。
#{id} 是 MyBatis 的占位符,会在执行时被实际的参数值替换。
-->
<if test="id">
AND t.ID = #{id}
</if>
@ -28,13 +46,14 @@
</if>
<if test="dailyDate">
<![CDATA[
AND DATE_FORMAT(t.insert_date ,'%Y-%m-%d') = #{dailyDate}
<!-- 使用 DATE_FORMAT 函数将插入日期格式化为 '%Y-%m-%d' 的形式,并与传入的 dailyDate 进行比较 -->
AND DATE_FORMAT(t.insert_date ,'%Y-%m-%d') = #{dailyDate}
]]>
</if>
<if test="ids">
AND t.ID IN
<foreach collection="ids" item="item" separator="," open="(" close=")">
#{item}
#{item}
</foreach>
</if>
<if test="excludeIds">
@ -43,8 +62,8 @@
#{item}
</foreach>
</if>
</where>
ORDER BY t.insert_date
</where>
<!-- 按照插入日期对查询结果进行排序 -->
ORDER BY t.insert_date
</select>
</mapper>

@ -11,9 +11,9 @@ import java.io.Serializable;
@Data
public class StockChange extends BaseModel implements Serializable{
private String stockId;
private String stockId;//库存ID
private Integer type;//1-入库2-破损3-核销
private Integer number;
private Integer actionBy;
private Integer number;//数量
private Integer actionBy;//操作人
}

@ -33,6 +33,10 @@ public @Data class StockCreate implements Serializable {
/** 更新人 */
private Integer updateUserId;
/**
* StockCreateStock
* @return Stock
*/
public Stock getEntity(){
Stock stock = new Stock();
BeanUtils.copyProperties(this, stock);

@ -37,6 +37,10 @@ public @Data class StockRecordCreate implements Serializable {
/** 更新时间 */
private Date updateDate;
/**
* StockRecordCreateStockRecord
* @return StockRecord
*/
public StockRecord getEntity(){
StockRecord stockRecord = new StockRecord();
BeanUtils.copyProperties(this, stockRecord);

@ -25,8 +25,17 @@ class StockRecordQuery implements Serializable {
*/
private String[] excludeIds;
/**
* ID
*/
private String stockId;
/**
*
*/
private Integer changeType;
/**
*
*/
private String dailyDate;
}

@ -38,6 +38,10 @@ public @Data class StockRecordUpdate implements Serializable {
private Date updateDate;
/**
* StockRecordUpdateStockRecord
* @return StockRecord
*/
public StockRecord getEntity(){
StockRecord stockRecord = new StockRecord();
BeanUtils.copyProperties(this, stockRecord);

@ -34,6 +34,10 @@ public @Data class StockUpdate implements Serializable {
private Integer updateUserId;
/**
* StockUpdateStock
* @return Stock
*/
public Stock getEntity(){
Stock stock = new Stock();
BeanUtils.copyProperties(this, stock);

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save