pzobk9anl
/
fresh
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request 'lzh' (#4) from lzh into qwer

Browse Source
qwer
pzobk9anl 1 month ago
parent 68178fa10d 11d3b2f728
commit 29309f6845
175 changed files with 5112 additions and 735 deletions
Show Stats Download Patch File Download Diff File

405
src/main/java/com/xmomen/module/resource/entity/ResourceExample.java
Unescape View File

@ -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设为null，distinct设为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
src/main/java/com/xmomen/module/resource/mapper/ResourceMapperExt.java
Unescape View File

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

40
src/main/java/com/xmomen/module/resource/mapper/ResourceMapperExt.xml
Unescape View File

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

4
src/main/java/com/xmomen/module/resource/model/ResourceCreate.java
Unescape View File

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

115
src/main/java/com/xmomen/module/resource/model/ResourceModel.java
Unescape View File

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

6
src/main/java/com/xmomen/module/resource/model/ResourceQuery.java
Unescape View File

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

21
src/main/java/com/xmomen/module/resource/model/ResourceUpdate.java
Unescape View File

@ -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;
/**
* 将ResourceUpdate对象转换为Resource对象
* @return Resource对象
*/
public Resource getEntity(){
Resource resource = new Resource();
BeanUtils.copyProperties(this, resource);

14
src/main/java/com/xmomen/module/resource/service/ResourceUtilsService.java
Unescape View File

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

73
src/main/java/com/xmomen/module/resource/service/impl/ResourceServiceImpl.java
Unescape View File

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

5
src/main/java/com/xmomen/module/schedule/ItemPurchaseJob.java
Unescape View File

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

4
src/main/java/com/xmomen/module/schedule/PlanJob.java
Unescape View File

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

192
src/main/java/com/xmomen/module/schedule/QuartzManager.java
Unescape View File

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

3
src/main/java/com/xmomen/module/schedule/StockDailyJob.java
Unescape View File

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

80
src/main/java/com/xmomen/module/schedule/controller/ScheduleController.java
Unescape View File

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

8
src/main/java/com/xmomen/module/schedule/controller/vo/ScheduleJobVo.java
Unescape View File

@ -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() {

4
src/main/java/com/xmomen/module/schedule/controller/vo/UpdateQuartzJob.java
Unescape View File

@ -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";
// 动作

100
src/main/java/com/xmomen/module/schedule/entity/ScheduleJobExample.java
Unescape View File

@ -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
src/main/java/com/xmomen/module/schedule/entity/mapper/ScheduleJobMapper.java
Unescape View File

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

1
src/main/java/com/xmomen/module/schedule/mapper/ScheduleMapper.java
Unescape View File

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

39
src/main/java/com/xmomen/module/schedule/mapper/ScheduleMapper.xml
Unescape View File

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

22
src/main/java/com/xmomen/module/sms/api/Client.java
Unescape View File

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

22
src/main/java/com/xmomen/module/sms/api/Response.java
Unescape View File

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

4
src/main/java/com/xmomen/module/sms/api/SmsMessageService.java
Unescape View File

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

8
src/main/java/com/xmomen/module/sms/api/SmsResponse.java
Unescape View File

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

8
src/main/java/com/xmomen/module/sms/model/IdentifyCodeModel.java
Unescape View File

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

3
src/main/java/com/xmomen/module/sms/util/GlobalIdentifyCodeManager.java
Unescape View File

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

128
src/main/java/com/xmomen/module/sms/util/HttpUtil.java
Unescape View File

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

41
src/main/java/com/xmomen/module/sms/util/HttpUtils.java
Unescape View File

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

98
src/main/java/com/xmomen/module/stock/entity/StockExample.java
Unescape View File

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

91
src/main/java/com/xmomen/module/stock/entity/StockRecordExample.java
Unescape View File

@ -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
src/main/java/com/xmomen/module/stock/entity/mapper/StockMapper.java
Unescape View File

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

193
src/main/java/com/xmomen/module/stock/entity/mapper/StockMapper.xml
Unescape View File

@ -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
src/main/java/com/xmomen/module/stock/entity/mapper/StockRecordMapper.java
Unescape View File

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

5
src/main/java/com/xmomen/module/stock/entity/mapper/StockRecordMapper.xml
Unescape View File

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

1
src/main/java/com/xmomen/module/stock/mapper/StockMapperExt.java
Unescape View File

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

6
src/main/java/com/xmomen/module/stock/mapper/StockMapperExt.xml
Unescape View File

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

1
src/main/java/com/xmomen/module/stock/mapper/StockRecordMapperExt.java
Unescape View File

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

49
src/main/java/com/xmomen/module/stock/mapper/StockRecordMapperExt.xml
Unescape View File

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

6
src/main/java/com/xmomen/module/stock/model/StockChange.java
Unescape View File

@ -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;//操作人
}

4
src/main/java/com/xmomen/module/stock/model/StockCreate.java
Unescape View File

@ -33,6 +33,10 @@ public @Data class StockCreate implements Serializable {
/** 更新人 */
private Integer updateUserId;
/**
* 将StockCreate对象转换为Stock实体对象
* @return Stock实体对象
*/
public Stock getEntity(){
Stock stock = new Stock();
BeanUtils.copyProperties(this, stock);

4
src/main/java/com/xmomen/module/stock/model/StockRecordCreate.java
Unescape View File

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

9
src/main/java/com/xmomen/module/stock/model/StockRecordQuery.java
Unescape View File

@ -25,8 +25,17 @@ class StockRecordQuery implements Serializable {
*/
private String[] excludeIds;
/**
* 股票ID
*/
private String stockId;
/**
* 变动类型
*/
private Integer changeType;
/**
* 日期
*/
private String dailyDate;
}

4
src/main/java/com/xmomen/module/stock/model/StockRecordUpdate.java
Unescape View File

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

4
src/main/java/com/xmomen/module/stock/model/StockUpdate.java
Unescape View File

@ -34,6 +34,10 @@ public @Data class StockUpdate implements Serializable {
private Integer updateUserId;
/**
* 将StockUpdate对象转换为Stock实体对象
* @return Stock实体对象
*/
public Stock getEntity(){
Stock stock = new Stock();
BeanUtils.copyProperties(this, stock);

2
src/main/java/com/xmomen/module/stock/service/StockRecordService.java
Unescape View File

@ -1,4 +1,4 @@
package com.xmomen.module.stock.service;
Vpackage com.xmomen.module.stock.service;
import com.xmomen.framework.mybatis.page.Page;
import com.xmomen.module.stock.model.StockRecordQuery;

208
src/main/java/com/xmomen/module/stockdaily/entity/StockDailyExample.java
View File

File diff suppressed because it is too large Load Diff

5
src/main/java/com/xmomen/module/stockdaily/entity/mapper/StockDailyMapper.java
Unescape View File

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

13
src/main/java/com/xmomen/module/stockdaily/entity/mapper/StockDailyMapper.xml
Unescape View File

@ -1,8 +1,11 @@
<?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.stockdaily.entity.mapper.StockDailyMapper" >
<!-- 定义结果映射 -->
<resultMap id="BaseResultMap" type="com.xmomen.module.stockdaily.entity.StockDaily" >
<!-- 定义主键 -->
<id column="id" property="id" jdbcType="VARCHAR" />
<!-- 定义其他字段 -->
<result column="stock_id" property="stockId" jdbcType="VARCHAR" />
<result column="item_id" property="itemId" jdbcType="VARCHAR" />
<result column="old_stock_num" property="oldStockNum" jdbcType="INTEGER" />
@ -13,8 +16,9 @@
<result column="verification_num" property="verificationNum" jdbcType="INTEGER" />
<result column="new_stock_num" property="newStockNum" jdbcType="INTEGER" />
<result column="daily_date" property="dailyDate" jdbcType="DATE" />
<result column="insert_date" property="insertDate" jdbcType="TIMESTAMP" />
<result column="insert_date" propeVrty="insertDate" jdbcType="TIMESTAMP" />
</resultMap>
<!-- 定义查询条件 -->
<sql id="Example_Where_Clause" >
<where >
<foreach collection="oredCriteria" item="criteria" separator="or" >
@ -44,6 +48,7 @@
</foreach>
</where>
</sql>
<!-- 定义更新条件 -->
<sql id="Update_By_Example_Where_Clause" >
<where >
<foreach collection="example.oredCriteria" item="criteria" separator="or" >
@ -73,10 +78,12 @@
</foreach>
</where>
</sql>
<!-- 定义基本字段列表 -->
<sql id="Base_Column_List" >
id, stock_id, item_id, old_stock_num, in_num, return_in_num, out_num, damaged_num,
verification_num, new_stock_num, daily_date, insert_date
</sql>
<!-- 根据条件查询 -->
<select id="selectByExample" resultMap="BaseResultMap" parameterType="com.xmomen.module.stockdaily.entity.StockDailyExample" >
select
<if test="distinct" >
@ -91,12 +98,14 @@
order by ${orderByClause}
</if>
</select>
<!-- 根据条件删除 -->
<delete id="deleteByExample" parameterType="com.xmomen.module.stockdaily.entity.StockDailyExample" >
delete from cd_stock_daily
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
</delete>
<!-- 插入数据 -->
<insert id="insertSelective" parameterType="com.xmomen.module.stockdaily.entity.StockDaily" useGeneratedKeys="true" keyProperty="id" keyColumn="id" >
<selectKey resultType="java.lang.String" keyProperty="id" order="BEFORE" >
SELECT replace(UUID(),'-','')
@ -175,12 +184,14 @@
</if>
</trim>
</insert>
<!-- 根据条件统计 -->
<select id="countByExample" parameterType="com.xmomen.module.stockdaily.entity.StockDailyExample" resultType="java.lang.Integer" >
select count(*) from cd_stock_daily
<if test="_parameter != null" >
<include refid="Example_Where_Clause" />
</if>
</select>
<!-- 根据条件更新 -->
<update id="updateByExampleSelective" parameterType="map" >
update cd_stock_daily
<set >

1
src/main/java/com/xmomen/module/stockdaily/mapper/StockDailyMapperExt.java
Unescape View File

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

4
src/main/java/com/xmomen/module/stockdaily/model/StockDailyCreate.java
Unescape View File

@ -41,6 +41,10 @@ public @Data class StockDailyCreate implements Serializable {
/** 插入时间 */
private Date insertDate;
/**
* 将StockDailyCreate对象转换为StockDaily实体对象
* @return StockDaily实体对象
*/
public StockDaily getEntity(){
StockDaily stockDaily = new StockDaily();
BeanUtils.copyProperties(this, stockDaily);

40
src/main/java/com/xmomen/module/stockdaily/model/StockDailyModel.java
Unescape View File

@ -29,82 +29,118 @@ class StockDailyModel implements Serializable {
/**
* 主键
*/
// 主键为必填项
@NotBlank(message = "主键为必填项")
// 主键字符长度限制[0,32]
@Length(max = 32, message = "主键字符长度限制[0,32]")
private String id;
/** */
// 标识该字段为Excel中的列名
@Excel(name = "")
// 标识该字段为必填项，如果为空则抛出异常，异常信息为"为必填项"
// 为必填项
@NotBlank(message = "为必填项")
// 字符长度限制[0,32]
@Length(max = 32, message = "字符长度限制[0,32]")
private String stockId;
/** */
// 标识该字段在Excel中的名称
@Excel(name = "")
// 非空校验，如果为空则抛出异常，异常信息为"为必填项"
@NotBlank(message = "为必填项")
// 长度校验，最大长度为32，如果超过则抛出异常，异常信息为"字符长度限制[0,32]"
@Length(max = 32, message = "字符长度限制[0,32]")
private String itemId;
/**
* 昨日库存
*/
// 昨日库存
@Excel(name = "昨日库存")
// 昨日库存数值范围[999999999,-999999999]
@Range(max = 999999999, min = -999999999, message = "昨日库存数值范围[999999999,-999999999]")
private Integer oldStockNum;
/**
* 入库库存
*/
// 标识该字段为Excel中的入库库存
@Excel(name = "入库库存")
// 验证该字段是否为空
@NotBlank(message = "入库库存为必填项")
// 验证该字段的数值范围
@Range(max = 999999999, min = -999999999, message = "入库库存数值范围[999999999,-999999999]")
private Integer inNum;
/**
* 取消退货入库数
*/
// 标识该字段为Excel中的取消退货入库数
@Excel(name = "取消退货入库数")
// 验证该字段是否为必填项
@NotBlank(message = "取消退货入库数为必填项")
// 验证该字段的数值范围
@Range(max = 999999999, min = -999999999, message = "取消退货入库数数值范围[999999999,-999999999]")
private Integer returnInNum;
/**
* 出库库存
*/
// 标识该字段为Excel中的出库库存
@Excel(name = "出库库存")
// 验证该字段不能为空
@NotBlank(message = "出库库存为必填项")
// 验证该字段的数值范围在-999999999到999999999之间
@Range(max = 999999999, min = -999999999, message = "出库库存数值范围[999999999,-999999999]")
private Integer outNum;
/**
* 破损数
*/
// 标识该字段为Excel中的"破损数"列
@Excel(name = "破损数")
// 验证该字段不能为空
@NotBlank(message = "破损数为必填项")
// 验证该字段的数值范围在-999999999到999999999之间
@Range(max = 999999999, min = -999999999, message = "破损数数值范围[999999999,-999999999]")
private Integer damagedNum;
/**
* 核销数
*/
// 核销数
@Excel(name = "核销数")
// 核销数为必填项
@NotBlank(message = "核销数为必填项")
// 核销数数值范围[999999999,-999999999]
@Range(max = 999999999, min = -999999999, message = "核销数数值范围[999999999,-999999999]")
private Integer verificationNum;
/**
* 现库存
*/
// 标识Excel中的列名为"现库存"
@Excel(name = "现库存")
// 非空校验，如果为空则提示"现库存为必填项"
@NotBlank(message = "现库存为必填项")
// 数值范围校验，最大值为999999999，最小值为-999999999，如果超出范围则提示"现库存数值范围[999999999,-999999999]"
@Range(max = 999999999, min = -999999999, message = "现库存数值范围[999999999,-999999999]")
private Integer newStockNum;
/**
* 快照时间
*/
// Excel注解，指定该字段在Excel中的列名为“快照时间”
@Excel(name = "快照时间")
// 非空校验注解，指定该字段为必填项，如果为空则返回message中的提示信息
@NotBlank(message = "快照时间为必填项")
// 定义一个Date类型的字段，用于存储快照时间
private Date dailyDate;
/**
* 插入时间
*/
// 插入时间
@Excel(name = "插入时间")
// 插入时间为必填项
@NotBlank(message = "插入时间为必填项")
private Date insertDate;
// 项目名称
private String itemName;
// 项目编码
private String itemCode;
/**
@ -113,9 +149,13 @@ class StockDailyModel implements Serializable {
* @return
*/
@JsonIgnore
// 获取实体
public StockDaily getEntity() {
// 创建StockDaily对象
StockDaily stockDaily = new StockDaily();
// 将当前对象的属性复制到StockDaily对象中
BeanUtils.copyProperties(this, stockDaily);
// 返回StockDaily对象
return stockDaily;
}

4
src/main/java/com/xmomen/module/stockdaily/model/StockDailyQuery.java
Unescape View File

@ -23,12 +23,16 @@ class StockDailyQuery implements Serializable {
/**
* 排除主键集
*/
// 排除的ID数组
private String[] excludeIds;
// 每日日期开始
private String dailyDateStart;
// 每日日期结束
private String dailyDateEnd;
// 关键字
private String keyword;
}

4
src/main/java/com/xmomen/module/stockdaily/model/StockDailyUpdate.java
Unescape View File

@ -42,9 +42,13 @@ public @Data class StockDailyUpdate implements Serializable {
private Date insertDate;
// 获取实体
public StockDaily getEntity(){
// 创建StockDaily对象
StockDaily stockDaily = new StockDaily();
// 将当前对象的属性复制到StockDaily对象中
BeanUtils.copyProperties(this, stockDaily);
// 返回StockDaily对象
return stockDaily;
}
}

20
src/main/java/com/xmomen/module/stockdaily/service/impl/StockDailyServiceImpl.java
Unescape View File

@ -43,12 +43,17 @@ public class StockDailyServiceImpl implements StockDailyService {
* @return StockDailyModel 库存日报领域对象
*/
@Override
// 使用@Transactional注解，表示该方法是一个事务方法
@Transactional
public StockDailyModel createStockDaily(StockDailyModel stockDailyModel) {
// 调用createStockDaily方法，将stockDailyModel.getEntity()作为参数传入
StockDaily stockDaily = createStockDaily(stockDailyModel.getEntity());
// 如果stockDaily不为空
if (stockDaily != null) {
// 调用getOneStockDailyModel方法，将stockDaily.getId()作为参数传入，返回StockDailyModel对象
return getOneStockDailyModel(stockDaily.getId());
}
// 如果stockDaily为空，返回null
return null;
}
@ -57,7 +62,9 @@ public class StockDailyServiceImpl implements StockDailyService {
*
* @param stockDaily 新增库存日报实体对象参数
* @return StockDaily 库存日报实体对象
// 标识该方法重写了父类或接口中的方法
*/
// 标识该方法是一个事务方法，即该方法中的所有操作要么全部成功，要么全部失败
@Override
@Transactional
public StockDaily createStockDaily(StockDaily stockDaily) {
@ -72,12 +79,19 @@ public class StockDailyServiceImpl implements StockDailyService {
*/
@Override
@Transactional
// 事务注解，表示该方法是一个事务方法
public List<StockDailyModel> createStockDailys(List<StockDailyModel> stockDailyModels) {
// 定义一个List类型的变量stockDailyModelList，用于存储创建的StockDailyModel对象
List<StockDailyModel> stockDailyModelList = null;
// 遍历stockDailyModels列表
for (StockDailyModel stockDailyModel : stockDailyModels) {
// 调用createStockDaily方法，创建StockDailyModel对象
stockDailyModel = createStockDaily(stockDailyModel);
// 如果创建的StockDailyModel对象不为空
if (stockDailyModel != null) {
// 如果stockDailyModelList为空
if (stockDailyModelList == null) {
// 创建一个新的ArrayList对象，用于存储创建的StockDailyModel对象
stockDailyModelList = new ArrayList<>();
}
stockDailyModelList.add(stockDailyModel);
@ -88,7 +102,9 @@ public class StockDailyServiceImpl implements StockDailyService {
/**
* 更新库存日报
// 重写父类方法
*
// 声明事务
* @param stockDailyModel 更新库存日报对象参数
*/
@Override
@ -115,10 +131,14 @@ public class StockDailyServiceImpl implements StockDailyService {
* @param ids 主键数组
*/
@Override
// 使用@Transactional注解，表示该方法是一个事务方法
@Transactional
public void deleteStockDaily(String[] ids) {
// 创建StockDailyExample对象
StockDailyExample stockDailyExample = new StockDailyExample();
// 设置查询条件，id在ids数组中
stockDailyExample.createCriteria().andIdIn(Arrays.<String>asList((String[]) ids));
// 调用mybatisDao的deleteByExample方法，根据查询条件删除数据
mybatisDao.deleteByExample(stockDailyExample);
}

48
src/main/java/com/xmomen/module/system/LoggerAspect.java
Unescape View File

@ -21,9 +21,11 @@ import java.util.Date;
@Aspect
public class LoggerAspect {
// 注入LogService
@Autowired
LogService logService;
// 注入HttpServletRequest
@Autowired
HttpServletRequest request;
@ -59,45 +61,83 @@ public class LoggerAspect {
return;
}
String actionName = an.actionName();
//获取当前登录用户id
Integer user_id =(Integer) SecurityUtils.getSubject().getSession().getAttribute("user_id");
//创建日志对象
LogModel log = new LogModel();
log.setUserId(user_id);//设置管理员id
log.setActionDate(new Date());//操作时间
log.setActionResult(null);//操作内容
log.setUserId(user_id);
//设置管理员id
log.setActionDate(new Date());
//操作时间
log.setActionResult(null);
//操作内容
log.setClientIp(getRemoteHost(request));
log.setActionName(actionName);//操作
log.setActionName(actionName);
//操作
/**
* 根据方法获取注解
* @param method
//根据方法和方法注解类获取注解
* @param annoClass
//获取方法上的所有注解
* @return
*/
logService.insertLog(log);//添加日志
}
public Annotation getAnnotationByMethod(Method method , Class annoClass){
// 获取方法上的所有注解
Annotation all[] = method.getAnnotations();
// 遍历所有注解
for (Annotation annotation : all) {
// 如果注解类型与传入的注解类型相同
if (annotation.annotationType() == annoClass) {
// 返回该注解
return annotation;
/**
* 根据类和方法名获取方法
* @param c
* @param methodName
* @return
*/
}
}
return null;
}
// 根据类和名称获取方法
public Method getMethodByClassAndName(Class c , String methodName){
// 获取类的所有方法
Method[] methods = c.getDeclaredMethods();
// 遍历所有方法
for (Method method : methods) {
// 如果方法名称与传入的名称相同
if(method.getName().equals(methodName)){
/**
* 获取客户端ip
* @param request
* @return
*/
return method ;
}
}
return null;
}
// 获取请求头中的x-forwarded-for字段，该字段表示客户端的IP地址
public String getRemoteHost(javax.servlet.http.HttpServletRequest request){
// 如果x-forwarded-for字段为空或者长度为0，或者值为unknown，则获取Proxy-Client-IP字段
String ip = request.getHeader("x-forwarded-for");
if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
ip = request.getHeader("Proxy-Client-IP");
// 如果Proxy-Client-IP字段为空或者长度为0，或者值为unknown，则获取WL-Proxy-Client-IP字段
}
if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
// 如果ip为空或者长度为0或者等于"unknown"，则获取request的远程地址
// 如果WL-Proxy-Client-IP字段为空或者长度为0，或者值为unknown，则获取request的remoteAddr属性
ip = request.getHeader("WL-Proxy-Client-IP");
}
// 如果ip等于"0:0:0:0:0:0:0:1"，则返回"127.0.0.1"，否则返回ip
if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
ip = request.getRemoteAddr();
}

30
src/main/java/com/xmomen/module/system/controller/DictionaryController.java
Unescape View File

@ -31,21 +31,29 @@ public class DictionaryController {
* @return
*/
@RequestMapping(value = "/dictionary/{group_id}/child", method = RequestMethod.GET)
// 查询数据字典
@Log(actionName = "查询数据字典")
public Page<SysDictionary> getList(
// 分组ID
@PathVariable(value = "group_id") Integer group_id,
// 每页显示数量
@RequestParam(value = "limit") Integer limit,
// 起始位置
@RequestParam(value = "offset") Integer offset){
// 调用dictionaryService的getDictionaryList方法，传入分组ID、每页显示数量和起始位置，返回查询结果
return dictionaryService.getDictionaryList(group_id, limit, offset);
}
/**
* 数据字典列表
* @param id
// 根据group_id和id查询数据字典
*/
// 记录日志，操作名称为查询数据字典
@RequestMapping(value = "/dictionary/{group_id}/child/{id}", method = RequestMethod.GET)
@Log(actionName = "查询数据字典")
public SysDictionaryParameter get(@PathVariable(value = "group_id") Integer group_id,
// 调用dictionaryService的getDictionary方法，根据id查询数据字典
@PathVariable(value = "id") Integer id){
return dictionaryService.getDictionary(id);
}
@ -59,18 +67,23 @@ public class DictionaryController {
* @throws ArgumentValidException
*/
@RequestMapping(value = "/dictionary/{group_id}/child", method = RequestMethod.POST)
// 添加日志注解，记录新增数据字典的操作
@Log(actionName = "新增数据字典")
public SysDictionaryParameter create(@PathVariable(value = "group_id") Integer group_id,
@RequestBody @Valid CreateDictionary createDictionary, BindingResult bindingResult) throws ArgumentValidException {
// 如果参数校验有错误，抛出异常
if(bindingResult != null && bindingResult.hasErrors()){
throw new ArgumentValidException(bindingResult);
}
// 创建SysDictionaryParameter对象
SysDictionaryParameter sysDictionaryParameter = new SysDictionaryParameter();
// 设置SysDictionaryParameter对象的属性
sysDictionaryParameter.setSysDictionaryId(createDictionary.getSysDictionaryId());
sysDictionaryParameter.setRealValue(createDictionary.getRealValue());
sysDictionaryParameter.setShowValue(createDictionary.getShowValue());
sysDictionaryParameter.setSortValue(createDictionary.getSortValue());
sysDictionaryParameter.setAvailable(createDictionary.getAvailable());
// 调用dictionaryService的createDictionary方法，创建数据字典
return dictionaryService.createDictionary(sysDictionaryParameter);
}
@ -81,34 +94,51 @@ public class DictionaryController {
* @param updateDictionary
* @param bindingResult
* @throws ArgumentValidException
// 根据group_id和id更新数据字典
*/
// 记录操作日志
@RequestMapping(value = "/dictionary/{group_id}/child/{id}", method = RequestMethod.PUT)
@Log(actionName = "更新数据字典")
public void update(@PathVariable(value = "group_id") Integer group_id,
@PathVariable(value = "id") Integer id,
// 如果参数校验有错误，抛出异常
@RequestBody @Valid UpdateDictionary updateDictionary, BindingResult bindingResult) throws ArgumentValidException {
if(bindingResult != null && bindingResult.hasErrors()){
throw new ArgumentValidException(bindingResult);
// 创建SysDictionaryParameter对象
}
// 设置id
SysDictionaryParameter sysDictionaryParameter = new SysDictionaryParameter();
// 设置group_id
sysDictionaryParameter.setId(id);
// 设置realValue
sysDictionaryParameter.setSysDictionaryId(group_id);
// 设置showValue
sysDictionaryParameter.setRealValue(updateDictionary.getRealValue());
// 设置sortValue
sysDictionaryParameter.setShowValue(updateDictionary.getShowValue());
// 设置available
sysDictionaryParameter.setSortValue(updateDictionary.getSortValue());
// 调用dictionaryService的updateDictionary方法更新数据字典
sysDictionaryParameter.setAvailable(updateDictionary.getAvailable());
dictionaryService.updateDictionary(sysDictionaryParameter);
}
/**
* 删除数据字典
// 根据group_id和id删除数据字典
// 记录删除数据字典的操作
// 调用dictionaryService的deleteDictionary方法删除数据字典
* @param group_id
* @param id
*/
// 根据group_id和id删除数据字典
@RequestMapping(value = "/dictionary/{group_id}/child/{id}", method = RequestMethod.DELETE)
// 记录删除数据字典的操作
@Log(actionName = "删除数据字典")
public void delete(@PathVariable(value = "group_id") Integer group_id,
@PathVariable(value = "id") Integer id){
// 调用dictionaryService的deleteDictionary方法删除数据字典
dictionaryService.deleteDictionary(id);
}

35
src/main/java/com/xmomen/module/system/controller/DictionaryGroupController.java
Unescape View File

@ -19,6 +19,7 @@ import javax.validation.Valid;
@RestController
public class DictionaryGroupController {
// 注入DictionaryGroupService
@Autowired
DictionaryGroupService dictionaryGroupService;
@ -29,20 +30,27 @@ public class DictionaryGroupController {
* @param keyword
* @return
*/
// 使用@RequestMapping注解，指定请求路径为"/dictionary"，请求方法为GET
@RequestMapping(value = "/dictionary", method = RequestMethod.GET)
// 使用@Log注解，记录操作日志，操作名称为"查询数据字典组"
@Log(actionName = "查询数据字典组")
public Page<SysDictionary> getList(@RequestParam(value = "limit") Integer limit,
@RequestParam(value = "offset") Integer offset,
@RequestParam(value = "keyword", required = false) String keyword){
// 调用dictionaryGroupService的getDictionaryList方法，传入keyword、limit、offset参数，返回查询结果
return dictionaryGroupService.getDictionaryList(keyword, limit, offset);
}
/**
* 数据字典组列表
* @param id
// 使用@RequestMapping注解，指定请求路径为/dictionary/{id}，请求方法为GET
*/
// 使用@Log注解，记录操作日志，操作名称为“查询数据字典组”
@RequestMapping(value = "/dictionary/{id}", method = RequestMethod.GET)
// 定义get方法，参数为id，类型为Integer
@Log(actionName = "查询数据字典组")
// 调用dictionaryGroupService的getDictionary方法，传入id，返回SysDictionary对象
public SysDictionary get(@PathVariable(value = "id") Integer id){
return dictionaryGroupService.getDictionary(id);
}
@ -51,16 +59,27 @@ public class DictionaryGroupController {
* 新增数据字典组
* @param createDictionaryGroup
* @param bindingResult
// 使用@RequestMapping注解指定请求路径和请求方法
* @return
// 使用@Log注解记录日志，指定操作名称为“新增数据字典组”
*/
// 使用@RequestBody注解将请求体中的数据绑定到CreateDictionaryGroup对象中
// 使用@Valid注解进行数据校验
// 使用BindingResult对象接收校验结果
@RequestMapping(value = "/dictionary", method = RequestMethod.POST)
// 如果校验结果不为空且存在错误，则抛出ArgumentValidException异常
@Log(actionName = "新增数据字典组")
public SysDictionary create(@RequestBody @Valid CreateDictionaryGroup createDictionaryGroup, BindingResult bindingResult) throws ArgumentValidException {
if(bindingResult != null && bindingResult.hasErrors()){
// 创建SysDictionary对象
throw new ArgumentValidException(bindingResult);
// 设置字典编码
}
// 设置字典描述
SysDictionary sysDictionary = new SysDictionary();
// 设置字典是否可用
sysDictionary.setDictionaryCode(createDictionaryGroup.getDictionaryCode());
// 调用dictionaryGroupService的createDictionary方法创建字典
sysDictionary.setDictionaryDesc(createDictionaryGroup.getDictionaryDesc());
sysDictionary.setAvailable(createDictionaryGroup.getAvailable());
return dictionaryGroupService.createDictionary(sysDictionary);
@ -72,10 +91,20 @@ public class DictionaryGroupController {
* @param updateDictionaryGroup
* @param bindingResult
* @throws ArgumentValidException
// 记录操作日志
// 请求体中的数据
// 如果有错误，抛出异常
*/
// 根据id更新数据字典组
// 创建SysDictionary对象
// 设置id
@RequestMapping(value = "/dictionary/{id}", method = RequestMethod.PUT)
// 设置可用状态
// 设置字典编码
@Log(actionName = "更新数据字典组")
// 设置字典描述
public void update(@PathVariable(value = "id") Integer id,
// 调用更新方法
@RequestBody @Valid UpdateDictionaryGroup updateDictionaryGroup, BindingResult bindingResult) throws ArgumentValidException {
if(bindingResult != null && bindingResult.hasErrors()){
throw new ArgumentValidException(bindingResult);
@ -85,16 +114,22 @@ public class DictionaryGroupController {
sysDictionary.setAvailable(updateDictionaryGroup.getAvailable());
sysDictionary.setDictionaryCode(updateDictionaryGroup.getDictionaryCode());
sysDictionary.setDictionaryDesc(updateDictionaryGroup.getDictionaryDesc());
// 使用@Log注解，记录删除数据字典组的操作
// 使用@RequestMapping注解，指定请求路径为/dictionary/{id}，请求方法为DELETE
dictionaryGroupService.updateDictionary(sysDictionary);
// 调用dictionaryGroupService的deleteDictionary方法，传入id参数，删除数据字典组
}
/**
* 删除数据字典组
* @param id
*/
// 使用@RequestMapping注解，指定请求路径为/dictionary/{id}，请求方法为DELETE
@RequestMapping(value = "/dictionary/{id}", method = RequestMethod.DELETE)
// 使用@Log注解，记录删除数据字典组的操作
@Log(actionName = "删除数据字典组")
public void delete(@PathVariable(value = "id") Integer id){
// 调用dictionaryGroupService的deleteDictionary方法，传入id参数，删除数据字典组
dictionaryGroupService.deleteDictionary(id);
}

23
src/main/java/com/xmomen/module/system/controller/OrganizationController.java
Unescape View File

@ -23,6 +23,7 @@ import java.util.List;
@RestController
public class OrganizationController {
// 注入OrganizationService
@Autowired
OrganizationService organizationService;
@ -31,9 +32,13 @@ public class OrganizationController {
* @param id
* @return
*/
// 使用@RequestMapping注解，指定请求路径为/organization，请求方法为GET
@RequestMapping(value = "/organization", method = RequestMethod.GET)
// 使用@Log注解，记录操作日志，操作名称为查询组织机构信息
@Log(actionName = "查询组织机构信息")
// 使用@RequestParam注解，指定请求参数名为id，非必需
public List<OrganizationModel> getOrganizationTree(@RequestParam(value = "id", required = false) Integer id){
// 调用organizationService的getOrganizationTree方法，传入id参数，返回组织机构信息列表
return organizationService.getOrganizationTree(id);
}
@ -43,16 +48,23 @@ public class OrganizationController {
* @param bindingResult
* @throws ArgumentValidException
*/
// 定义一个POST请求，请求路径为/organization
@RequestMapping(value = "/organization", method = RequestMethod.POST)
// 记录日志，操作名称为新增组织机构
@Log(actionName = "新增组织机构")
// 接收一个CreateOrganization对象，并进行验证
public void createOrganization(@RequestBody @Valid CreateOrganization createOrganization, BindingResult bindingResult) throws ArgumentValidException {
// 如果验证结果不为空且存在错误，则抛出ArgumentValidException异常
if(bindingResult != null && bindingResult.hasErrors()){
throw new ArgumentValidException(bindingResult);
}
// 创建一个SysOrganization对象
SysOrganization sysOrganization = new SysOrganization();
// 设置SysOrganization对象的属性
sysOrganization.setName(createOrganization.getName());
sysOrganization.setDescription(createOrganization.getDescription());
sysOrganization.setParentId(createOrganization.getParentId());
// 调用organizationService的createOrganization方法，创建组织机构
organizationService.createOrganization(sysOrganization);
}
@ -71,17 +83,26 @@ public class OrganizationController {
* @param id
*/
@RequestMapping(value = "/organization/{id}", method = RequestMethod.PUT)
// 记录日志，操作名称为“修改组织机构”
@Log(actionName = "修改组织机构")
public void updateOrganization(@PathVariable(value = "id") Integer id,
// 请求体，验证CreateOrganization对象
@RequestBody @Valid CreateOrganization createOrganization, BindingResult bindingResult) throws ArgumentValidException {
// 如果验证结果不为空且存在错误，抛出ArgumentValidException异常
if(bindingResult != null && bindingResult.hasErrors()){
throw new ArgumentValidException(bindingResult);
}
// 创建SysOrganization对象
SysOrganization sysOrganization = new SysOrganization();
// 设置id
sysOrganization.setId(id);
// 设置名称
sysOrganization.setName(createOrganization.getName());
// 设置描述
sysOrganization.setDescription(createOrganization.getDescription());
// 设置父id
sysOrganization.setParentId(createOrganization.getParentId());
// 调用organizationService的updateOrganization方法更新组织机构
organizationService.updateOrganization(sysOrganization);
}
@ -91,10 +112,12 @@ public class OrganizationController {
* @param userIds
*/
@RequestMapping(value = "/organization/{id}/user", method = RequestMethod.POST)
// 添加日志记录，操作名称为“新增组织机构用户”
@Log(actionName = "新增组织机构用户")
public void bindOrganizationUser(@PathVariable(value = "id") Integer id,
@RequestParam(value = "userIds") Integer[] userIds) {
// 调用organizationService的bindOrganizationUser方法，传入id和userIds
organizationService.bindOrganizationUser(id, userIds);
}

25
src/main/java/com/xmomen/module/system/controller/TaskController.java
Unescape View File

@ -35,21 +35,41 @@ public class TaskController {
* @return
*/
@RequestMapping(value = "/task", method = RequestMethod.GET)
// 查询任务信息
@Log(actionName = "查询任务信息")
public Page<TaskModel> getTaskTree(@RequestParam(value = "limit") Integer limit,
@RequestParam(value = "offset") Integer offset,
@RequestParam(value = "taskStatus", required = false) Integer[] taskStatus,
@RequestParam(value = "executorIds", required = false) Integer[] executorIds,
// 创建任务查询对象
@RequestParam(value = "keyword", required = false) String keyword){
// 设置关键字
// 创建任务查询对象
// 设置任务状态
// 创建任务查询对象
// 设置执行者ID
// 设置关键字
// 调用任务服务获取任务列表
TaskQuery taskQuery = new TaskQuery();
// 设置任务状态
// 设置关键字
// 设置执行者ID
// 设置任务状态
// 调用任务服务获取任务列表
taskQuery.setKeyword(keyword);
// 设置执行者ID
taskQuery.setTaskStatus(taskStatus);
// 调用任务服务获取任务列表
taskQuery.setExecutorIds(executorIds);
return taskService.getTaskList(taskQuery, limit, offset);
}
/**
// 使用@RequestMapping注解指定请求路径和请求方法
// 使用@PathVariable注解获取路径中的参数id
// 调用taskService的deleteTask方法删除任务
// 使用@Log注解记录日志，actionName为删除任务
* 删除机构组织
* @param id
*/
@ -63,15 +83,20 @@ public class TaskController {
* 修改机构组织
* @param id
*/
// 修改任务
@RequestMapping(value = "/task/{id}", method = RequestMethod.PUT)
@Log(actionName = "修改任务")
public void updateTask(@PathVariable(value = "id") Integer id,
@RequestBody @Valid CreateTask createTask, BindingResult bindingResult) throws ArgumentValidException {
// 如果参数校验有错误，抛出异常
if(bindingResult != null && bindingResult.hasErrors()){
throw new ArgumentValidException(bindingResult);
}
// 创建SysTask对象
SysTask sysTask = new SysTask();
// 设置任务id
sysTask.setId(id);
// 调用taskService的updateTask方法更新任务
taskService.updateTask(sysTask);
}

20
src/main/java/com/xmomen/module/system/entity/SysDictionary.java
Unescape View File

@ -31,28 +31,40 @@ public class SysDictionary extends BaseMybatisModel {
*/
private Integer available;
// 定义ID字段
@Column(name = "ID")
// 设置ID为主键
@Id
// 设置ID的生成方式为UUID
@GeneratedValue(generator = "UUIDGenerator")
public Integer getId() {
// 返回ID
return id;
}
// 设置ID
public void setId(Integer id) {
// 将传入的ID赋值给成员变量
this.id = id;
// 如果ID为空
if(id == null){
// 移除验证字段
removeValidField("id");
// 返回
return;
}
addValidField("id");
}
// 获取字典代码
@Column(name = "DICTIONARY_CODE")
public String getDictionaryCode() {
return dictionaryCode;
}
// 设置字典代码
public void setDictionaryCode(String dictionaryCode) {
// 如果字典代码为空，则移除有效字段
this.dictionaryCode = dictionaryCode;
if(dictionaryCode == null){
removeValidField("dictionaryCode");
@ -62,27 +74,35 @@ public class SysDictionary extends BaseMybatisModel {
}
@Column(name = "DICTIONARY_DESC")
// 获取字典描述
public String getDictionaryDesc() {
return dictionaryDesc;
}
// 设置字典描述
public void setDictionaryDesc(String dictionaryDesc) {
this.dictionaryDesc = dictionaryDesc;
// 如果字典描述为空
if(dictionaryDesc == null){
// 移除有效字段
removeValidField("dictionaryDesc");
return;
}
addValidField("dictionaryDesc");
}
// 获取AVAILABLE字段的值
@Column(name = "AVAILABLE")
public Integer getAvailable() {
return available;
}
// 设置AVAILABLE字段的值
public void setAvailable(Integer available) {
this.available = available;
// 如果AVAILABLE字段的值为空
if(available == null){
// 移除验证字段
removeValidField("available");
return;
}

133
src/main/java/com/xmomen/module/system/entity/SysDictionaryExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 系统字典实体类
public class SysDictionaryExample extends BaseMybatisExample {
// 排序字段
protected String orderByClause;
// 是否去重
protected boolean distinct;
// 查询条件
protected List<Criteria> oredCriteria;
// 构造函数
public SysDictionaryExample() {
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 SysDictionaryExample 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 SysDictionaryExample 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 SysDictionaryExample 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 SysDictionaryExample 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 +127,339 @@ public class SysDictionaryExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 添加查询条件
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeIsNull() {
addCriterion("DICTIONARY_CODE is null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeIsNotNull() {
addCriterion("DICTIONARY_CODE is not null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeEqualTo(String value) {
addCriterion("DICTIONARY_CODE =", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeNotEqualTo(String value) {
addCriterion("DICTIONARY_CODE <>", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeGreaterThan(String value) {
addCriterion("DICTIONARY_CODE >", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeGreaterThanOrEqualTo(String value) {
addCriterion("DICTIONARY_CODE >=", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeLessThan(String value) {
addCriterion("DICTIONARY_CODE <", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeLessThanOrEqualTo(String value) {
addCriterion("DICTIONARY_CODE <=", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeLike(String value) {
addCriterion("DICTIONARY_CODE like", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeNotLike(String value) {
addCriterion("DICTIONARY_CODE not like", value, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeIn(List<String> values) {
addCriterion("DICTIONARY_CODE in", values, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeNotIn(List<String> values) {
addCriterion("DICTIONARY_CODE not in", values, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeBetween(String value1, String value2) {
addCriterion("DICTIONARY_CODE between", value1, value2, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryCodeNotBetween(String value1, String value2) {
addCriterion("DICTIONARY_CODE not between", value1, value2, "dictionaryCode");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescIsNull() {
addCriterion("DICTIONARY_DESC is null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescIsNotNull() {
addCriterion("DICTIONARY_DESC is not null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescEqualTo(String value) {
addCriterion("DICTIONARY_DESC =", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescNotEqualTo(String value) {
addCriterion("DICTIONARY_DESC <>", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescGreaterThan(String value) {
addCriterion("DICTIONARY_DESC >", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescGreaterThanOrEqualTo(String value) {
addCriterion("DICTIONARY_DESC >=", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescLessThan(String value) {
addCriterion("DICTIONARY_DESC <", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescLessThanOrEqualTo(String value) {
addCriterion("DICTIONARY_DESC <=", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescLike(String value) {
// 添加查询条件，查询字典描述字段中包含指定值的记录
addCriterion("DICTIONARY_DESC like", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescNotLike(String value) {
addCriterion("DICTIONARY_DESC not like", value, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescIn(List<String> values) {
addCriterion("DICTIONARY_DESC in", values, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
public Criteria andDictionaryDescNotIn(List<String> values) {
// 添加查询条件，字段为DICTIONARY_DESC，条件为not in，值为values，字段名为dictionaryDesc
addCriterion("DICTIONARY_DESC not in", values, "dictionaryDesc");
return (Criteria) this;
}
// 添加查询条件
// 添加一个条件，字典描述在value1和value2之间
public Criteria andDictionaryDescBetween(String value1, String value2) {
// 添加条件
addCriterion("DICTIONARY_DESC between", value1, value2, "dictionaryDesc");
// 返回当前对象
return (Criteria) this;
}
// 添加查询条件
// 添加一个条件，字典描述不在value1和value2之间
public Criteria andDictionaryDescNotBetween(String value1, String value2) {
// 添加条件
addCriterion("DICTIONARY_DESC not between", value1, value2, "dictionaryDesc");
// 返回当前对象
return (Criteria) this;
}
// 添加查询条件
public Criteria andAvailableIsNull() {
addCriterion("AVAILABLE is null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andAvailableIsNotNull() {
addCriterion("AVAILABLE is not null");
return (Criteria) this;
}
// 添加查询条件
public Criteria andAvailableEqualTo(Integer value) {
addCriterion("AVAILABLE =", value, "available");
return (Criteria) this;
}
// 添加查询条件
// 添加一个条件，AVAILABLE不等于value
public Criteria andAvailableNotEqualTo(Integer value) {
addCriterion("AVAILABLE <>", value, "available");
return (Criteria) this;
}
// 添加查询条件
// 添加一个条件，AVAILABLE字段的值大于value
public Criteria andAvailableGreaterThan(Integer value) {
addCriterion("AVAILABLE >", value, "available");
return (Criteria) this;
}
// 添加查询条件
public Criteria andAvailableGreaterThanOrEqualTo(Integer value) {
addCriterion("AVAILABLE >=", value, "available");
return (Criteria) this;
}
// 添加查询条件
public Criteria andAvailableLessThan(Integer value) {
addCriterion("AVAILABLE <", value, "available");
return (Criteria) this;
}
// 添加查询条件
// 添加一个条件，AVAILABLE字段小于等于value
public Criteria andAvailableLessThanOrEqualTo(Integer value) {
// 添加查询条件，AVAILABLE字段小于等于value
addCriterion("AVAILABLE <=", value, "available");
return (Criteria) this;
}
// 添加查询条件
public Criteria andAvailableIn(List<Integer> values) {
// 添加查询条件，AVAILABLE字段在values列表中
addCriterion("AVAILABLE in", values, "available");
return (Criteria) this;
}
// 添加查询条件
// 根据传入的值，添加一个条件，表示AVAILABLE字段不在传入的值列表中
public Criteria andAvailableNotIn(List<Integer> values) {
addCriterion("AVAILABLE not in", values, "available");
return (Criteria) this;
}
// 添加查询条件
// 添加一个条件，AVAILABLE字段在value1和value2之间
public Criteria andAvailableBetween(Integer value1, Integer value2) {
addCriterion("AVAILABLE between", value1, value2, "available");
return (Criteria) this;
}
// 添加查询条件
// 添加一个条件，AVAILABLE字段的值不在value1和value2之间
// 添加一个条件，AVAILABLE字段的值不在value1和value2之间
public Criteria andAvailableNotBetween(Integer value1, Integer value2) {
// 调用addCriterion方法，添加条件
addCriterion("AVAILABLE not between", value1, value2, "available");
// 返回当前Criteria对象
return (Criteria) this;
}
}
// 查询条件
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
@ -373,87 +467,126 @@ public class SysDictionaryExample extends BaseMybatisExample {
}
}
// 查询条件
public static class Criterion {
private String condition;
// 值
private Object value;
// 第二个值
private Object secondValue;
// 没有值
private boolean noValue;
// 单个值
private boolean singleValue;
// 两个值之间的值
private boolean betweenValue;
// 列表值
private boolean listValue;
// 类型处理器
private String typeHandler;
// 获取查询条件
public String getCondition() {
return condition;
}
// 获取查询条件
public Object getValue() {
return value;
}
// 获取查询条件
public Object getSecondValue() {
return secondValue;
}
// 判断查询条件是否为空
public boolean isNoValue() {
return noValue;
}
// 判断查询条件是否为单个值
public boolean isSingleValue() {
return singleValue;
}
// 判断查询条件是否为范围值
public boolean isBetweenValue() {
return betweenValue;
}
// 判断查询条件是否为列表值
public boolean isListValue() {
return listValue;
}
// 获取查询条件
public String getTypeHandler() {
return typeHandler;
}
// 构造函数
protected Criterion(String condition) {
super();
// 设置条件
this.condition = condition;
// 设置类型处理器
this.typeHandler = null;
// 设置无值
this.noValue = true;
}
// 构造函数
// 构造函数，用于创建Criterion对象
protected Criterion(String condition, Object value, String typeHandler) {
super();
// 设置条件
this.condition = condition;
// 设置值
this.value = value;
// 设置类型处理器
this.typeHandler = typeHandler;
// 判断值是否为List类型
if (value instanceof List<?>) {
// 如果是List类型，则设置listValue为true
this.listValue = true;
} else {
// 否则，设置singleValue为true
this.singleValue = true;
}
}
// 构造函数
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
// 调用父类的构造方法
// 设置条件
// 构造函数
// 设置值
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
// 设置第二个值
super();
// 设置类型处理器
this.condition = condition;
// 设置betweenValue为true
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
// 构造函数，传入条件、值、第二个值
// 构造函数
// 调用另一个构造函数，传入条件、值、第二个值和null
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

31
src/main/java/com/xmomen/module/system/entity/SysDictionaryParameter.java
Unescape View File

@ -12,7 +12,7 @@ import javax.persistence.Version;
@Table(name = "sys_dictionary_parameter")
public class SysDictionaryParameter extends BaseMybatisModel {
/**
*
* 主键
*/
private Integer id;
@ -41,29 +41,42 @@ public class SysDictionaryParameter extends BaseMybatisModel {
*/
private Integer available;
// 定义ID列
@Column(name = "ID")
// 定义主键
@Id
// 使用UUID生成器生成ID
@GeneratedValue(generator = "UUIDGenerator")
public Integer getId() {
// 返回ID
return id;
}
// 设置ID
public void setId(Integer id) {
// 将传入的ID赋值给成员变量
this.id = id;
// 如果ID为空
if(id == null){
// 移除验证字段
removeValidField("id");
// 返回
return;
}
// 添加验证字段
addValidField("id");
}
// 获取系统字典ID
@Column(name = "SYS_DICTIONARY_ID")
public Integer getSysDictionaryId() {
return sysDictionaryId;
}
// 设置系统字典ID
public void setSysDictionaryId(Integer sysDictionaryId) {
this.sysDictionaryId = sysDictionaryId;
// 如果系统字典ID为空，则移除有效字段
if(sysDictionaryId == null){
removeValidField("sysDictionaryId");
return;
@ -71,59 +84,75 @@ public class SysDictionaryParameter extends BaseMybatisModel {
addValidField("sysDictionaryId");
}
// 获取showValue属性
@Column(name = "SHOW_VALUE")
public String getShowValue() {
return showValue;
}
// 设置showValue属性
public void setShowValue(String showValue) {
this.showValue = showValue;
// 如果showValue为空，则移除有效字段
if(showValue == null){
removeValidField("showValue");
return;
}
// 否则，添加有效字段
addValidField("showValue");
}
// 注释：获取REAL_VALUE字段的值
@Column(name = "REAL_VALUE")
public String getRealValue() {
return realValue;
}
// 注释：设置REAL_VALUE字段的值
public void setRealValue(String realValue) {
// 注释：如果realValue为空，则移除validField中的realValue字段
this.realValue = realValue;
if(realValue == null){
removeValidField("realValue");
return;
// 注释：否则，将realValue字段添加到validField中
}
addValidField("realValue");
// 注释：获取排序值
}
@Column(name = "SORT_VALUE")
public Integer getSortValue() {
return sortValue;
// 注释：设置排序值
}
// 注释：如果排序值为空，则移除有效字段
public void setSortValue(Integer sortValue) {
this.sortValue = sortValue;
if(sortValue == null){
removeValidField("sortValue");
// 注释：否则添加有效字段
return;
}
addValidField("sortValue");
}
// 获取AVAILABLE字段的值
@Column(name = "AVAILABLE")
public Integer getAvailable() {
return available;
}
// 设置AVAILABLE字段的值
public void setAvailable(Integer available) {
this.available = available;
// 如果available为null，则移除available字段
if(available == null){
removeValidField("available");
return;
}
// 否则，添加available字段
addValidField("available");
}
}

140
src/main/java/com/xmomen/module/system/entity/SysDictionaryParameterExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 系统字典参数示例类
public class SysDictionaryParameterExample extends BaseMybatisExample {
// 排序字段
protected String orderByClause;
// 是否去重
protected boolean distinct;
// 查询条件
protected List<Criteria> oredCriteria;
// 构造函数
public SysDictionaryParameterExample() {
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,37 +66,46 @@ public class SysDictionaryParameterExample 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;
// 构造函数
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 SysDictionaryParameterExample 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 SysDictionaryParameterExample 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,358 +129,434 @@ public class SysDictionaryParameterExample 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;
}
// 添加SYS_DICTIONARY_ID为空的查询条件
public Criteria andSysDictionaryIdIsNull() {
addCriterion("SYS_DICTIONARY_ID is null");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID不为空的查询条件
public Criteria andSysDictionaryIdIsNotNull() {
addCriterion("SYS_DICTIONARY_ID is not null");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID等于指定值的查询条件
public Criteria andSysDictionaryIdEqualTo(Integer value) {
addCriterion("SYS_DICTIONARY_ID =", value, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID不等于指定值的查询条件
public Criteria andSysDictionaryIdNotEqualTo(Integer value) {
addCriterion("SYS_DICTIONARY_ID <>", value, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID大于指定值的查询条件
public Criteria andSysDictionaryIdGreaterThan(Integer value) {
addCriterion("SYS_DICTIONARY_ID >", value, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID大于等于指定值的查询条件
public Criteria andSysDictionaryIdGreaterThanOrEqualTo(Integer value) {
addCriterion("SYS_DICTIONARY_ID >=", value, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID小于指定值的查询条件
public Criteria andSysDictionaryIdLessThan(Integer value) {
addCriterion("SYS_DICTIONARY_ID <", value, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID小于等于指定值的查询条件
public Criteria andSysDictionaryIdLessThanOrEqualTo(Integer value) {
addCriterion("SYS_DICTIONARY_ID <=", value, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID在指定值列表中的查询条件
public Criteria andSysDictionaryIdIn(List<Integer> values) {
addCriterion("SYS_DICTIONARY_ID in", values, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID不在指定值列表中的查询条件
public Criteria andSysDictionaryIdNotIn(List<Integer> values) {
addCriterion("SYS_DICTIONARY_ID not in", values, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID在指定值之间的查询条件
public Criteria andSysDictionaryIdBetween(Integer value1, Integer value2) {
addCriterion("SYS_DICTIONARY_ID between", value1, value2, "sysDictionaryId");
return (Criteria) this;
}
// 添加SYS_DICTIONARY_ID不在指定值之间的查询条件
public Criteria andSysDictionaryIdNotBetween(Integer value1, Integer value2) {
addCriterion("SYS_DICTIONARY_ID not between", value1, value2, "sysDictionaryId");
return (Criteria) this;
}
// 添加SHOW_VALUE为空的查询条件
public Criteria andShowValueIsNull() {
addCriterion("SHOW_VALUE is null");
return (Criteria) this;
}
// 添加SHOW_VALUE不为空的查询条件
public Criteria andShowValueIsNotNull() {
addCriterion("SHOW_VALUE is not null");
return (Criteria) this;
}
// 添加SHOW_VALUE等于指定值的查询条件
public Criteria andShowValueEqualTo(String value) {
addCriterion("SHOW_VALUE =", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE不等于指定值的查询条件
public Criteria andShowValueNotEqualTo(String value) {
addCriterion("SHOW_VALUE <>", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE大于指定值的查询条件
public Criteria andShowValueGreaterThan(String value) {
addCriterion("SHOW_VALUE >", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE大于等于指定值的查询条件
public Criteria andShowValueGreaterThanOrEqualTo(String value) {
addCriterion("SHOW_VALUE >=", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE小于指定值的查询条件
public Criteria andShowValueLessThan(String value) {
addCriterion("SHOW_VALUE <", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE小于等于指定值的查询条件
public Criteria andShowValueLessThanOrEqualTo(String value) {
addCriterion("SHOW_VALUE <=", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE包含指定值的查询条件
public Criteria andShowValueLike(String value) {
addCriterion("SHOW_VALUE like", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE不包含指定值的查询条件
public Criteria andShowValueNotLike(String value) {
addCriterion("SHOW_VALUE not like", value, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE在指定值列表中的查询条件
public Criteria andShowValueIn(List<String> values) {
addCriterion("SHOW_VALUE in", values, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE不在指定值列表中的查询条件
public Criteria andShowValueNotIn(List<String> values) {
addCriterion("SHOW_VALUE not in", values, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE在指定值之间的查询条件
public Criteria andShowValueBetween(String value1, String value2) {
addCriterion("SHOW_VALUE between", value1, value2, "showValue");
return (Criteria) this;
}
// 添加SHOW_VALUE不在指定值之间的查询条件
public Criteria andShowValueNotBetween(String value1, String value2) {
addCriterion("SHOW_VALUE not between", value1, value2, "showValue");
return (Criteria) this;
}
// 添加REAL_VALUE为空的查询条件
public Criteria andRealValueIsNull() {
addCriterion("REAL_VALUE is null");
return (Criteria) this;
}
// 添加REAL_VALUE不为空的查询条件
public Criteria andRealValueIsNotNull() {
addCriterion("REAL_VALUE is not null");
return (Criteria) this;
}
// 添加REAL_VALUE等于指定值的查询条件
public Criteria andRealValueEqualTo(String value) {
addCriterion("REAL_VALUE =", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE不等于指定值的查询条件
public Criteria andRealValueNotEqualTo(String value) {
addCriterion("REAL_VALUE <>", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE大于指定值的查询条件
public Criteria andRealValueGreaterThan(String value) {
addCriterion("REAL_VALUE >", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE大于等于指定值的查询条件
public Criteria andRealValueGreaterThanOrEqualTo(String value) {
addCriterion("REAL_VALUE >=", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE小于指定值的查询条件
public Criteria andRealValueLessThan(String value) {
addCriterion("REAL_VALUE <", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE小于等于指定值的查询条件
public Criteria andRealValueLessThanOrEqualTo(String value) {
addCriterion("REAL_VALUE <=", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE包含指定值的查询条件
// 根据传入的value参数，添加一个REAL_VALUE like的条件
public Criteria andRealValueLike(String value) {
addCriterion("REAL_VALUE like", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE不包含指定值的查询条件
public Criteria andRealValueNotLike(String value) {
addCriterion("REAL_VALUE not like", value, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE在指定值列表中的查询条件
public Criteria andRealValueIn(List<String> values) {
addCriterion("REAL_VALUE in", values, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE不在指定值列表中的查询条件
public Criteria andRealValueNotIn(List<String> values) {
addCriterion("REAL_VALUE not in", values, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE在指定值之间的查询条件
public Criteria andRealValueBetween(String value1, String value2) {
addCriterion("REAL_VALUE between", value1, value2, "realValue");
return (Criteria) this;
}
// 添加REAL_VALUE不在指定值之间的查询条件
public Criteria andRealValueNotBetween(String value1, String value2) {
addCriterion("REAL_VALUE not between", value1, value2, "realValue");
return (Criteria) this;
}
// 添加SORT_VALUE为空的查询条件
public Criteria andSortValueIsNull() {
addCriterion("SORT_VALUE is null");
return (Criteria) this;
}
// 添加SORT_VALUE不为空的查询条件
public Criteria andSortValueIsNotNull() {
addCriterion("SORT_VALUE is not null");
return (Criteria) this;
}
// 添加SORT_VALUE等于指定值的查询条件
public Criteria andSortValueEqualTo(Integer value) {
addCriterion("SORT_VALUE =", value, "sortValue");
return (Criteria) this;
}
// 添加SORT_VALUE不等于指定值的查询条件
public Criteria andSortValueNotEqualTo(Integer value) {
addCriterion("SORT_VALUE <>", value, "sortValue");
return (Criteria) this;
}
// 添加SORT_VALUE大于指定值的查询条件
public Criteria andSortValueGreaterThan(Integer value) {
addCriterion("SORT_VALUE >", value, "sortValue");
return (Criteria) this;
}
// 添加SORT_VALUE大于等于指定值的查询条件
public Criteria andSortValueGreaterThanOrEqualTo(Integer value) {
addCriterion("SORT_VALUE >=", value, "sortValue");
return (Criteria) this;
// 添加一个条件，SORT_VALUE 小于指定的值
// 添加SORT_VALUE小于指定值的查询条件
}
public Criteria andSortValueLessThan(Integer value) {
addCriterion("SORT_VALUE <", value, "sortValue");
return (Criteria) this;
// 添加SORT_VALUE小于等于指定值的查询条件
}
public Criteria andSortValueLessThanOrEqualTo(Integer value) {
addCriterion("SORT_VALUE <=", value, "sortValue");
return (Criteria) this;
// 添加SORT_VALUE在指定值列表中的查询条件
}
public Criteria andSortValueIn(List<Integer> values) {
addCriterion("SORT_VALUE in", values, "sortValue");
return (Criteria) this;
// 添加SORT_VALUE不在指定值列表中的查询条件
}
public Criteria andSortValueNotIn(List<Integer> values) {
addCriterion("SORT_VALUE not in", values, "sortValue");
return (Criteria) this;
// 添加SORT_VALUE在指定值之间的查询条件
}
public Criteria andSortValueBetween(Integer value1, Integer value2) {
addCriterion("SORT_VALUE between", value1, value2, "sortValue");
return (Criteria) this;
// 添加SORT_VALUE不在指定值之间的查询条件
}
public Criteria andSortValueNotBetween(Integer value1, Integer value2) {
addCriterion("SORT_VALUE not between", value1, value2, "sortValue");
return (Criteria) this;
// 添加AVAILABLE为空的查询条件
}
public Criteria andAvailableIsNull() {
addCriterion("AVAILABLE is null");
return (Criteria) this;
// 添加AVAILABLE不为空的查询条件
}
public Criteria andAvailableIsNotNull() {
addCriterion("AVAILABLE is not null");
return (Criteria) this;
// 添加AVAILABLE等于指定值的查询条件
}
// 根据传入的value值，将AVAILABLE字段设置为等于value值
public Criteria andAvailableEqualTo(Integer value) {
addCriterion("AVAILABLE =", value, "available");
return (Criteria) this;
// 添加AVAILABLE不等于指定值的查询条件
}
public Criteria andAvailableNotEqualTo(Integer value) {
addCriterion("AVAILABLE <>", value, "available");
return (Criteria) this;
// 添加AVAILABLE大于指定值的查询条件
}
// 添加一个条件，AVAILABLE字段的值大于value
public Criteria andAvailableGreaterThan(Integer value) {
addCriterion("AVAILABLE >", value, "available");
// 添加AVAILABLE大于等于指定值的查询条件
return (Criteria) this;
}
public Criteria andAvailableGreaterThanOrEqualTo(Integer value) {
addCriterion("AVAILABLE >=", value, "available");
// 添加AVAILABLE小于指定值的查询条件
return (Criteria) this;
}
public Criteria andAvailableLessThan(Integer value) {
addCriterion("AVAILABLE <", value, "available");
// 添加AVAILABLE小于等于指定值的查询条件
return (Criteria) this;
}
@ -465,6 +565,7 @@ public class SysDictionaryParameterExample extends BaseMybatisExample {
return (Criteria) this;
}
// 根据传入的值，添加一个AVAILABLE in的条件
public Criteria andAvailableIn(List<Integer> values) {
addCriterion("AVAILABLE in", values, "available");
return (Criteria) this;
@ -473,13 +574,17 @@ public class SysDictionaryParameterExample extends BaseMybatisExample {
public Criteria andAvailableNotIn(List<Integer> values) {
addCriterion("AVAILABLE not in", values, "available");
return (Criteria) this;
// 添加一个条件，AVAILABLE字段在value1和value2之间
}
public Criteria andAvailableBetween(Integer value1, Integer value2) {
addCriterion("AVAILABLE between", value1, value2, "available");
return (Criteria) this;
}
// 添加一个条件，AVAILABLE字段的值不在value1和value2之间
// 调用addCriterion方法，添加条件
// 返回当前Criteria对象
public Criteria andAvailableNotBetween(Integer value1, Integer value2) {
addCriterion("AVAILABLE not between", value1, value2, "available");
return (Criteria) this;
@ -496,44 +601,58 @@ public class SysDictionaryParameterExample extends BaseMybatisExample {
public static class Criterion {
private String condition;
// 用于存储条件的值
private Object value;
// 用于存储第二个条件的值
private Object secondValue;
// 用于判断是否没有值
private boolean noValue;
// 用于判断是否是单个值
private boolean singleValue;
// 用于判断是否是范围值
private boolean betweenValue;
// 用于判断是否是列表值
private boolean listValue;
// 用于存储类型处理器
private String typeHandler;
// 获取条件
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;
}
@ -541,18 +660,26 @@ public class SysDictionaryParameterExample extends BaseMybatisExample {
public String getTypeHandler() {
return typeHandler;
}
// 构造函数，用于创建Criterion对象
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
// 构造函数，用于创建Criterion对象
}
// 设置条件
protected Criterion(String condition, Object value, String typeHandler) {
// 设置值
// 设置类型处理器
super();
// 判断值是否为List类型
// 如果是List类型，则设置listValue为true
this.condition = condition;
this.value = value;
// 否则，设置singleValue为true
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
@ -563,15 +690,28 @@ public class SysDictionaryParameterExample extends BaseMybatisExample {
protected Criterion(String condition, Object value) {
this(condition, value, null);
// 构造函数，用于创建Criterion对象
}
// 设置条件
// 设置值
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
// 设置第二个值
// 设置类型处理器
super();
// 设置条件
// 设置betweenValue为true
// 设置值
this.condition = condition;
// 设置第二个值
// 设置类型处理器
this.value = value;
// 设置betweenValue为true
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
// 构造函数，用于创建Criterion对象
// 调用另一个构造函数，传入condition、value、secondValue和null
}
protected Criterion(String condition, Object value, Object secondValue) {

38
src/main/java/com/xmomen/module/system/entity/SysOrganization.java
Unescape View File

@ -31,59 +31,93 @@ public class SysOrganization extends BaseMybatisModel {
*/
private Integer parentId;
// 定义数据库列名为ID
@Column(name = "ID")
// 定义该字段为主键
@Id
// 使用UUID生成器生成主键值
@GeneratedValue(generator = "UUIDGenerator")
// 定义获取ID的方法
public Integer getId() {
return id;
}
// 设置id
public void setId(Integer id) {
this.id = id;
// 如果id为空，则移除有效字段
if(id == null){
removeValidField("id");
return;
}
// 否则，添加有效字段
addValidField("id");
}
// 获取name
@Column(name = "NAME")
public String getName() {
return name;
}
// 设置name
public void setName(String name) {
this.name = name;
if(name == null){
removeValidField("name");
return;
removeValidField("name");
// 移除有效字段
return;
}
// 否则，添加有效字段
addValidField("name");
}
@Column(name = "DESCRIPTION")
// 设置名称
public void setName(String name) {
this.name = name;
if(name == null){
removeValidField("name");
// 移除有效字段
return;
}
// 否则，添加有效字段
addValidField("name");
}
// 获取描述
public String getDescription() {
return description;
}
// 设置描述
public void setDescription(String description) {
this.description = description;
// 如果描述为空，则移除有效字段
if(description == null){
removeValidField("description");
return;
}
// 否则，添加有效字段
addValidField("description");
}
// 获取父ID
@Column(name = "PARENT_ID")
public Integer getParentId() {
return parentId;
}
// 设置父ID
public void setParentId(Integer parentId) {
this.parentId = parentId;
// 如果parentId为空
public void setParentId(Integer parentId) {
// 移除parentId字段
this.parentId = parentId;
// 返回
if(parentId == null){
removeValidField("parentId");
// 添加parentId字段
return;
}
addValidField("parentId");

177
src/main/java/com/xmomen/module/system/entity/SysOrganizationExample.java
Unescape View File

@ -4,79 +4,108 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 定义SysOrganizationExample类，继承BaseMybatisExample类
public class SysOrganizationExample extends BaseMybatisExample {
// 定义orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义distinct变量，用于存储是否去重
protected boolean distinct;
// 定义oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria变量
public SysOrganizationExample() {
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);
}
// 返回一个新的Criteria对象，并将其添加到oredCriteria列表中
// 创建一个新的Criteria对象
// 创建查询条件
// 将新的Criteria对象添加到oredCriteria列表中
public Criteria or() {
// 返回新的Criteria对象
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
// 创建查询条件
}
// 创建一个Criteria对象
public Criteria createCriteria() {
// 调用createCriteriaInternal()方法创建一个Criteria对象
Criteria criteria = createCriteriaInternal();
// 如果oredCriteria集合为空，则将创建的Criteria对象添加到oredCriteria集合中
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
// 创建查询条件
}
return criteria;
}
protected Criteria createCriteriaInternal() {
// 清空查询条件
Criteria criteria = new Criteria();
return criteria;
}
// 定义GeneratedCriteria内部类
public void clear() {
// 定义criteria变量，用于存储查询条件
oredCriteria.clear();
// 构造函数，初始化criteria变量
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
// 判断查询条件是否有效
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
// 获取所有查询条件
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
// 获取查询条件
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
// 添加查询条件
return criteria;
}
@ -84,267 +113,341 @@ public class SysOrganizationExample extends BaseMybatisExample {
return criteria;
}
// 添加查询条件
// 添加条件
protected void addCriterion(String condition) {
// 如果条件为空，抛出异常
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
// 将条件添加到criteria中
criteria.add(new Criterion(condition));
}
// 添加查询条件
// 添加条件
protected void addCriterion(String condition, Object value, String property) {
// 如果值为空，抛出异常
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
// 添加条件
criteria.add(new Criterion(condition, value));
}
// 添加查询条件，判断ID是否为空
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");
}
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) {
// 添加查询条件，判断ID是否大于某个值
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小于指定值
// 添加一个条件，ID小于指定值
// 添加查询条件，判断ID是否在某个范围内
// 返回当前对象
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
// 添加查询条件，判断ID是否不在某个范围内
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
// 添加查询条件，判断ID是否在某个范围内
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
// 添加查询条件，判断ID是否不在某个范围内
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
// 添加查询条件，判断NAME是否为空
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
// 添加查询条件，判断NAME是否不为空
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
// 添加查询条件，判断NAME是否等于某个值
return (Criteria) this;
}
public Criteria andNameIsNull() {
addCriterion("NAME is null");
// 添加查询条件，判断NAME是否不等于某个值
return (Criteria) this;
}
public Criteria andNameIsNotNull() {
addCriterion("NAME is not null");
// 添加查询条件，判断NAME是否大于某个值
return (Criteria) this;
}
public Criteria andNameEqualTo(String value) {
addCriterion("NAME =", value, "name");
// 添加查询条件，判断NAME是否大于等于某个值
return (Criteria) this;
}
public Criteria andNameNotEqualTo(String value) {
addCriterion("NAME <>", value, "name");
// 添加查询条件，判断NAME是否小于某个值
return (Criteria) this;
}
public Criteria andNameGreaterThan(String value) {
addCriterion("NAME >", value, "name");
// 添加查询条件，判断NAME是否小于等于某个值
return (Criteria) this;
}
public Criteria andNameGreaterThanOrEqualTo(String value) {
addCriterion("NAME >=", value, "name");
// 添加查询条件，判断NAME是否包含某个值
return (Criteria) this;
}
// 添加一个条件，NAME字段的值小于value
public Criteria andNameLessThan(String value) {
// 添加查询条件，判断NAME是否不包含某个值
addCriterion("NAME <", value, "name");
return (Criteria) this;
// 添加一个条件，NAME字段的值小于等于value
}
// 添加查询条件，判断NAME是否在某个范围内
public Criteria andNameLessThanOrEqualTo(String value) {
addCriterion("NAME <=", value, "name");
return (Criteria) this;
}
// 添加查询条件，判断NAME是否不在某个范围内
public Criteria andNameLike(String value) {
addCriterion("NAME like", value, "name");
return (Criteria) this;
}
// 添加查询条件，判断NAME是否在某个范围内
public Criteria andNameNotLike(String value) {
addCriterion("NAME not like", value, "name");
return (Criteria) this;
}
// 添加查询条件，判断NAME是否不在某个范围内
public Criteria andNameIn(List<String> values) {
addCriterion("NAME in", values, "name");
return (Criteria) this;
}
// 添加查询条件，判断DESCRIPTION是否为空
public Criteria andNameNotIn(List<String> values) {
addCriterion("NAME not in", values, "name");
return (Criteria) this;
}
// 添加查询条件，判断DESCRIPTION是否不为空
public Criteria andNameBetween(String value1, String value2) {
addCriterion("NAME between", value1, value2, "name");
return (Criteria) this;
}
// 添加查询条件，判断DESCRIPTION是否等于某个值
public Criteria andNameNotBetween(String value1, String value2) {
// 添加条件，DESCRIPTION字段为空
addCriterion("NAME not between", value1, value2, "name");
return (Criteria) this;
}
// 添加查询条件，判断DESCRIPTION是否不等于某个值
public Criteria andDescriptionIsNull() {
// 添加条件，DESCRIPTION字段不为空
addCriterion("DESCRIPTION is null");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否大于某个值
}
public Criteria andDescriptionIsNotNull() {
addCriterion("DESCRIPTION is not null");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否大于等于某个值
}
public Criteria andDescriptionEqualTo(String value) {
addCriterion("DESCRIPTION =", value, "description");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否小于某个值
}
public Criteria andDescriptionNotEqualTo(String value) {
addCriterion("DESCRIPTION <>", value, "description");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否小于等于某个值
}
public Criteria andDescriptionGreaterThan(String value) {
addCriterion("DESCRIPTION >", value, "description");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否包含某个值
}
public Criteria andDescriptionGreaterThanOrEqualTo(String value) {
addCriterion("DESCRIPTION >=", value, "description");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否不包含某个值
}
public Criteria andDescriptionLessThan(String value) {
addCriterion("DESCRIPTION <", value, "description");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否在某个范围内
}
public Criteria andDescriptionLessThanOrEqualTo(String value) {
addCriterion("DESCRIPTION <=", value, "description");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否不在某个范围内
}
public Criteria andDescriptionLike(String value) {
addCriterion("DESCRIPTION like", value, "description");
return (Criteria) this;
// 添加查询条件，判断DESCRIPTION是否在某个范围内
}
// 返回当前对象
public Criteria andDescriptionNotLike(String value) {
// 添加条件，当DESCRIPTION在values列表中时，返回当前对象
// 添加查询条件，判断DESCRIPTION是否不在某个范围内
addCriterion("DESCRIPTION not like", value, "description");
return (Criteria) this;
}
public Criteria andDescriptionIn(List<String> values) {
// 添加查询条件，判断PARENT_ID是否为空
addCriterion("DESCRIPTION in", values, "description");
return (Criteria) this;
}
public Criteria andDescriptionNotIn(List<String> values) {
// 添加查询条件，判断PARENT_ID是否不为空
addCriterion("DESCRIPTION not in", values, "description");
// 定义Criterion内部类
return (Criteria) this;
// 添加条件，父ID在value1和value2之间
}
public Criteria andDescriptionBetween(String value1, String value2) {
// 添加查询条件，判断PARENT_ID是否等于某个值
addCriterion("DESCRIPTION between", value1, value2, "description");
return (Criteria) this;
}
public Criteria andDescriptionNotBetween(String value1, String value2) {
// 添加查询条件，判断PARENT_ID是否不等于某个值
addCriterion("DESCRIPTION not between", value1, value2, "description");
return (Criteria) this;
}
public Criteria andParentIdIsNull() {
// 添加查询条件，判断PARENT_ID是否大于某个值
addCriterion("PARENT_ID is null");
return (Criteria) this;
}
public Criteria andParentIdIsNotNull() {
// 添加查询条件，判断PARENT_ID是否大于等于某个值
addCriterion("PARENT_ID is not null");
return (Criteria) this;
}
public Criteria andParentIdEqualTo(Integer value) {
// 添加查询条件，判断PARENT_ID是否小于某个值
addCriterion("PARENT_ID =", value, "parentId");
return (Criteria) this;
}
public Criteria andParentIdNotEqualTo(Integer value) {
// 添加查询条件，判断PARENT_ID是否小于等于某个值
addCriterion("PARENT_ID <>", value, "parentId");
return (Criteria) this;
}
public Criteria andParentIdGreaterThan(Integer value) {
// 添加查询条件，判断PARENT_ID是否在某个范围内
addCriterion("PARENT_ID >", value, "parentId");
return (Criteria) this;
}
public Criteria andParentIdGreaterThanOrEqualTo(Integer value) {
// 添加查询条件，判断PARENT_ID是否不在某个范围内
addCriterion("PARENT_ID >=", value, "parentId");
return (Criteria) this;
}
public Criteria andParentIdLessThan(Integer value) {
// 添加查询条件，判断PARENT_ID是否在某个范围内
// 添加条件，父ID小于等于指定值
addCriterion("PARENT_ID <", value, "parentId");
return (Criteria) this;
}
// 添加查询条件，判断PARENT_ID是否不在某个范围内
// 添加条件，父ID在指定值列表中
public Criteria andParentIdLessThanOrEqualTo(Integer value) {
addCriterion("PARENT_ID <=", value, "parentId");
return (Criteria) this;
}
// 定义Criteria内部类
public Criteria andParentIdIn(List<Integer> values) {
addCriterion("PARENT_ID in", values, "parentId");
return (Criteria) this;
@ -352,73 +455,115 @@ public class SysOrganizationExample extends BaseMybatisExample {
public Criteria andParentIdNotIn(List<Integer> values) {
addCriterion("PARENT_ID not in", values, "parentId");
// 定义Criterion内部类
return (Criteria) this;
// 添加条件，父ID在value1和value2之间
}
public Criteria andParentIdBetween(Integer value1, Integer value2) {
addCriterion("PARENT_ID between", value1, value2, "parentId");
return (Criteria) this;
public GeneratedCriteria(android.content.Context context) {
this(context, null);
}
public GeneratedCriteria(Context context, android.util.AttributeSet attrs) {
this(context, attrs, 0);
}
public GeneratedCriteria(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
// 添加一个条件，判断PARENT_ID字段的值是否在value1和value2之间
public Criteria andParentIdNotBetween(Integer value1, Integer value2) {
// 添加条件
addCriterion("PARENT_ID not between", value1, value2, "parentId");
// 返回当前对象
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
// 获取condition变量
protected Criteria() {
super();
}
// 条件
// 获取value变量
}
// 值
public static class Criterion {
// 获取secondValue变量
private String condition;
// 第二个值
private Object value;
// 判断是否没有值
// 是否没有值
private Object secondValue;
// 是否是单个值
// 判断是否只有一个值
// 是否在值之间
private boolean noValue;
// 判断是否在某个范围内
// 是否是列表值
private boolean singleValue;
// 类型处理器
// 判断是否在某个范围内
private boolean betweenValue;
// 获取条件
private boolean listValue;
// 获取typeHandler变量
private String typeHandler;
// 获取值
// 构造函数，初始化condition变量
public String getCondition() {
return condition;
}
// 获取第二个值
public Object getValue() {
return value;
// 构造函数，初始化condition、value和typeHandler变量
}
// 判断是否没有值
public Object getSecondValue() {
return secondValue;
}
// 判断是否是单个值
public boolean isNoValue() {
return noValue;
}
// 构造函数，初始化condition和value变量
public boolean isSingleValue() {
return singleValue;
}
// 判断是否在值之间
// 构造函数，初始化condition、value、secondValue和typeHandler变量
public boolean isBetweenValue() {
return betweenValue;
// 判断是否为列表值
}
public boolean isListValue() {
return listValue;
// 获取类型处理器
// 构造函数，初始化condition、value和secondValue变量
}
public String getTypeHandler() {
// 构造函数，传入条件
return typeHandler;
}
@ -426,11 +571,21 @@ public class SysOrganizationExample extends BaseMybatisExample {
super();
this.condition = condition;
this.typeHandler = null;
// 构造函数，用于创建Criterion对象
this.noValue = true;
}
// 设置值
// 设置条件
// 构造函数，用于创建Criterion对象
// 设置类型处理器
// 设置条件
// 设置值
protected Criterion(String condition, Object value, String typeHandler) {
// 设置类型处理器
super();
// 判断值是否为List类型
// 如果是List类型，则设置listValue为true
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
@ -440,18 +595,34 @@ public class SysOrganizationExample extends BaseMybatisExample {
this.singleValue = true;
}
}
// 构造函数，传入条件、值和类型处理器
// 调用父类的构造函数
// 构造函数，传入条件、值和类型处理器
// 调用父类的构造函数
// 构造函数，传入条件、值、第二个值和类型处理器
// 调用父类的构造函数
protected Criterion(String condition, Object value) {
this(condition, value, null);
// 构造函数，传入条件、值、第二个值和类型处理器
}
// 设置条件
// 调用父类的构造函数
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
// 设置条件
super();
// 设置值
this.condition = condition;
// 设置第二个值
// 设置类型处理器
this.value = value;
// 设置betweenValue为true
this.secondValue = secondValue;
this.typeHandler = typeHandler;
// 构造函数，设置条件、值和第二个值
this.betweenValue = true;
// 调用另一个构造函数，设置条件、值和第二个值，类型处理器为null
}
protected Criterion(String condition, Object value, Object secondValue) {

30
src/main/java/com/xmomen/module/system/entity/SysTask.java
Unescape View File

@ -48,28 +48,36 @@ public class SysTask extends BaseMybatisModel {
private Integer taskStatus;
@Column(name = "ID")
// 标识该字段为数据库表的主键
@Id
// 使用UUID生成器生成主键
@GeneratedValue(generator = "UUIDGenerator")
public Integer getId() {
return id;
}
// 设置主键值
public void setId(Integer id) {
this.id = id;
// 如果主键值为空，则移除有效字段
if(id == null){
removeValidField("id");
return;
}
// 否则，添加有效字段
addValidField("id");
}
// 注释：获取任务头ID
@Column(name = "TASK_HEAD_ID")
public Integer getTaskHeadId() {
return taskHeadId;
}
// 注释：设置任务头ID
public void setTaskHeadId(Integer taskHeadId) {
this.taskHeadId = taskHeadId;
// 注释：如果任务头ID为空，则移除有效字段
if(taskHeadId == null){
removeValidField("taskHeadId");
return;
@ -77,13 +85,16 @@ public class SysTask extends BaseMybatisModel {
addValidField("taskHeadId");
}
// 获取创建时间
@Column(name = "CREATE_TIME")
public Date getCreateTime() {
return createTime;
}
// 设置创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
// 如果创建时间为空，则移除验证字段
if(createTime == null){
removeValidField("createTime");
return;
@ -91,40 +102,52 @@ public class SysTask extends BaseMybatisModel {
addValidField("createTime");
}
// 获取开始时间
@Column(name = "START_TIME")
public Date getStartTime() {
return startTime;
}
// 设置开始时间
public void setStartTime(Date startTime) {
this.startTime = startTime;
// 如果开始时间为空，则移除验证字段
if(startTime == null){
removeValidField("startTime");
return;
}
// 否则，添加验证字段
addValidField("startTime");
}
// 获取完成时间
@Column(name = "FINISH_TIME")
public Date getFinishTime() {
return finishTime;
}
// 设置完成时间
public void setFinishTime(Date finishTime) {
this.finishTime = finishTime;
// 如果完成时间为空
if(finishTime == null){
// 移除有效字段
removeValidField("finishTime");
return;
}
// 添加有效字段
addValidField("finishTime");
}
// 获取执行者ID
@Column(name = "EXECUTOR_ID")
public Integer getExecutorId() {
return executorId;
}
// 设置执行者ID
public void setExecutorId(Integer executorId) {
// 如果执行者ID为空，则移除验证字段
this.executorId = executorId;
if(executorId == null){
removeValidField("executorId");
@ -133,17 +156,24 @@ public class SysTask extends BaseMybatisModel {
addValidField("executorId");
}
// 获取任务状态
@Column(name = "TASK_STATUS")
public Integer getTaskStatus() {
return taskStatus;
}
// 设置任务状态
public void setTaskStatus(Integer taskStatus) {
// 设置任务状态
this.taskStatus = taskStatus;
// 如果taskStatus为空
if(taskStatus == null){
// 移除有效的字段
removeValidField("taskStatus");
// 返回
return;
}
// 添加有效的字段
addValidField("taskStatus");
}
}

116
src/main/java/com/xmomen/module/system/entity/SysTaskExample.java
Unescape View File

@ -5,45 +5,61 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
// 定义一个SysTaskExample类，继承自BaseMybatisExample类
public class SysTaskExample extends BaseMybatisExample {
// 定义一个orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量，用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria变量
public SysTaskExample() {
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;
// 创建一个Criteria对象
// 调用createCriteriaInternal()方法创建一个Criteria对象
// 创建一个新的查询条件
// 如果oredCriteria集合为空，则将创建的Criteria对象添加到oredCriteria集合中
}
public Criteria createCriteria() {
@ -51,38 +67,54 @@ public class SysTaskExample extends BaseMybatisExample {
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
// 创建一个新的查询条件
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
// 清空查询条件
return criteria;
}
// 清空oredCriteria
// 将orderByClause置为null
// 将distinct置为false
// 定义一个GeneratedCriteria内部类，用于存储查询条件
public void clear() {
// 定义一个criteria变量，用于存储查询条件
oredCriteria.clear();
orderByClause = null;
// 构造函数，初始化criteria变量
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> 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) {
@ -90,336 +122,420 @@ public class SysTaskExample extends BaseMybatisExample {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
// 添加查询条件
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
// 添加条件
// 如果value1或value2为null，则抛出异常
throw new RuntimeException("Value for " + property + " cannot be null");
// 添加查询条件，判断ID是否为空
}
// 添加条件到criteria中
criteria.add(new Criterion(condition, value));
}
// 添加查询条件，判断ID是否不为空
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");
}
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是否大于某个值
}
// 添加一个条件，ID不等于value
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
// 添加查询条件，判断ID是否大于等于某个值
return (Criteria) this;
// 添加一个条件，ID大于value
}
public Criteria andIdNotEqualTo(Integer value) {
// 添加查询条件，判断ID是否小于某个值
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
// 添加查询条件，判断ID是否小于等于某个值
addCriterion("ID >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
// 添加查询条件，判断ID是否在某个范围内
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
// 添加查询条件，判断ID是否不在某个范围内
addCriterion("ID <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
// 添加查询条件，判断ID是否在某个范围内
addCriterion("ID <=", value, "id");
return (Criteria) this;
// 返回当前对象
}
// 添加查询条件，判断ID是否不在某个范围内
public Criteria andIdIn(List<Integer> values) {
// 添加ID不在指定范围内的条件
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 添加查询条件，判断TASK_HEAD_ID是否为空
// 添加ID在指定范围内的条件
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
// 添加查询条件，判断TASK_HEAD_ID是否不为空
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
// 添加查询条件，判断TASK_HEAD_ID是否等于某个值
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
// 添加查询条件，判断TASK_HEAD_ID是否不等于某个值
}
public Criteria andTaskHeadIdIsNull() {
addCriterion("TASK_HEAD_ID is null");
return (Criteria) this;
// 添加查询条件，判断TASK_HEAD_ID是否大于某个值
}
public Criteria andTaskHeadIdIsNotNull() {
addCriterion("TASK_HEAD_ID is not null");
return (Criteria) this;
// 添加查询条件，判断TASK_HEAD_ID是否大于等于某个值
}
public Criteria andTaskHeadIdEqualTo(Integer value) {
addCriterion("TASK_HEAD_ID =", value, "taskHeadId");
// 添加条件，TASK_HEAD_ID不等于value
// 添加查询条件，判断TASK_HEAD_ID是否小于某个值
return (Criteria) this;
}
// 添加条件，TASK_HEAD_ID大于value
public Criteria andTaskHeadIdNotEqualTo(Integer value) {
// 添加查询条件，判断TASK_HEAD_ID是否小于等于某个值
addCriterion("TASK_HEAD_ID <>", value, "taskHeadId");
return (Criteria) this;
}
public Criteria andTaskHeadIdGreaterThan(Integer value) {
// 添加查询条件，判断TASK_HEAD_ID是否在某个范围内
addCriterion("TASK_HEAD_ID >", value, "taskHeadId");
return (Criteria) this;
}
public Criteria andTaskHeadIdGreaterThanOrEqualTo(Integer value) {
// 添加查询条件，判断TASK_HEAD_ID是否不在某个范围内
addCriterion("TASK_HEAD_ID >=", value, "taskHeadId");
return (Criteria) this;
}
public Criteria andTaskHeadIdLessThan(Integer value) {
// 添加查询条件，判断TASK_HEAD_ID是否在某个范围内
addCriterion("TASK_HEAD_ID <", value, "taskHeadId");
return (Criteria) this;
}
public Criteria andTaskHeadIdLessThanOrEqualTo(Integer value) {
// 添加查询条件，判断TASK_HEAD_ID是否不在某个范围内
addCriterion("TASK_HEAD_ID <=", value, "taskHeadId");
return (Criteria) this;
}
public Criteria andTaskHeadIdIn(List<Integer> values) {
// 添加查询条件，判断CREATE_TIME是否为空
addCriterion("TASK_HEAD_ID in", values, "taskHeadId");
return (Criteria) this;
}
public Criteria andTaskHeadIdNotIn(List<Integer> values) {
// 添加查询条件，判断CREATE_TIME是否不为空
// 添加TASK_HEAD_ID在value1和value2之间的条件
addCriterion("TASK_HEAD_ID not in", values, "taskHeadId");
return (Criteria) this;
}
// 添加查询条件，判断CREATE_TIME是否等于某个值
// 添加TASK_HEAD_ID不在value1和value2之间的条件
public Criteria andTaskHeadIdBetween(Integer value1, Integer value2) {
addCriterion("TASK_HEAD_ID between", value1, value2, "taskHeadId");
return (Criteria) this;
}
// 添加查询条件，判断CREATE_TIME是否不等于某个值
// 添加CREATE_TIME为空的条件
public Criteria andTaskHeadIdNotBetween(Integer value1, Integer value2) {
addCriterion("TASK_HEAD_ID not between", value1, value2, "taskHeadId");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否大于某个值
}
public Criteria andCreateTimeIsNull() {
addCriterion("CREATE_TIME is null");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否大于等于某个值
}
public Criteria andCreateTimeIsNotNull() {
addCriterion("CREATE_TIME is not null");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否小于某个值
}
public Criteria andCreateTimeEqualTo(Date value) {
addCriterion("CREATE_TIME =", value, "createTime");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否小于等于某个值
}
public Criteria andCreateTimeNotEqualTo(Date value) {
addCriterion("CREATE_TIME <>", value, "createTime");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否在某个范围内
}
public Criteria andCreateTimeGreaterThan(Date value) {
addCriterion("CREATE_TIME >", value, "createTime");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否不在某个范围内
}
public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
addCriterion("CREATE_TIME >=", value, "createTime");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否在某个范围内
}
public Criteria andCreateTimeLessThan(Date value) {
addCriterion("CREATE_TIME <", value, "createTime");
return (Criteria) this;
// 添加查询条件，判断CREATE_TIME是否不在某个范围内
}
public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
addCriterion("CREATE_TIME <=", value, "createTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否为空
}
public Criteria andCreateTimeIn(List<Date> values) {
addCriterion("CREATE_TIME in", values, "createTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否不为空
}
public Criteria andCreateTimeNotIn(List<Date> values) {
addCriterion("CREATE_TIME not in", values, "createTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否等于某个值
}
public Criteria andCreateTimeBetween(Date value1, Date value2) {
addCriterion("CREATE_TIME between", value1, value2, "createTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否不等于某个值
}
public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
addCriterion("CREATE_TIME not between", value1, value2, "createTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否大于某个值
}
public Criteria andStartTimeIsNull() {
addCriterion("START_TIME is null");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否大于等于某个值
}
public Criteria andStartTimeIsNotNull() {
addCriterion("START_TIME is not null");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否小于某个值
}
public Criteria andStartTimeEqualTo(Date value) {
addCriterion("START_TIME =", value, "startTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否小于等于某个值
}
public Criteria andStartTimeNotEqualTo(Date value) {
addCriterion("START_TIME <>", value, "startTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否在某个范围内
}
public Criteria andStartTimeGreaterThan(Date value) {
addCriterion("START_TIME >", value, "startTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否不在某个范围内
}
public Criteria andStartTimeGreaterThanOrEqualTo(Date value) {
addCriterion("START_TIME >=", value, "startTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否在某个范围内
}
public Criteria andStartTimeLessThan(Date value) {
addCriterion("START_TIME <", value, "startTime");
return (Criteria) this;
// 添加查询条件，判断START_TIME是否不在某个范围内
}
public Criteria andStartTimeLessThanOrEqualTo(Date value) {
addCriterion("START_TIME <=", value, "startTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否为空
}
public Criteria andStartTimeIn(List<Date> values) {
addCriterion("START_TIME in", values, "startTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否不为空
}
public Criteria andStartTimeNotIn(List<Date> values) {
addCriterion("START_TIME not in", values, "startTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否等于某个值
}
public Criteria andStartTimeBetween(Date value1, Date value2) {
addCriterion("START_TIME between", value1, value2, "startTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否不等于某个值
}
public Criteria andStartTimeNotBetween(Date value1, Date value2) {
addCriterion("START_TIME not between", value1, value2, "startTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否大于某个值
}
public Criteria andFinishTimeIsNull() {
addCriterion("FINISH_TIME is null");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否大于等于某个值
}
public Criteria andFinishTimeIsNotNull() {
addCriterion("FINISH_TIME is not null");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否小于某个值
}
public Criteria andFinishTimeEqualTo(Date value) {
addCriterion("FINISH_TIME =", value, "finishTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否小于等于某个值
}
public Criteria andFinishTimeNotEqualTo(Date value) {
addCriterion("FINISH_TIME <>", value, "finishTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否在某个范围内
}
public Criteria andFinishTimeGreaterThan(Date value) {
addCriterion("FINISH_TIME >", value, "finishTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否不在某个范围内
}
public Criteria andFinishTimeGreaterThanOrEqualTo(Date value) {
addCriterion("FINISH_TIME >=", value, "finishTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否在某个范围内
}
public Criteria andFinishTimeLessThan(Date value) {
addCriterion("FINISH_TIME <", value, "finishTime");
return (Criteria) this;
// 添加查询条件，判断FINISH_TIME是否不在某个范围内
}
public Criteria andFinishTimeLessThanOrEqualTo(Date value) {
addCriterion("FINISH_TIME <=", value, "finishTime");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否为空
}
public Criteria andFinishTimeIn(List<Date> values) {
addCriterion("FINISH_TIME in", values, "finishTime");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否不为空
}
public Criteria andFinishTimeNotIn(List<Date> values) {
addCriterion("FINISH_TIME not in", values, "finishTime");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否等于某个值
}
public Criteria andFinishTimeBetween(Date value1, Date value2) {
addCriterion("FINISH_TIME between", value1, value2, "finishTime");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否不等于某个值
}
public Criteria andFinishTimeNotBetween(Date value1, Date value2) {
addCriterion("FINISH_TIME not between", value1, value2, "finishTime");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否大于某个值
}
public Criteria andExecutorIdIsNull() {
addCriterion("EXECUTOR_ID is null");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否大于等于某个值
}
public Criteria andExecutorIdIsNotNull() {
addCriterion("EXECUTOR_ID is not null");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否小于某个值
}
public Criteria andExecutorIdEqualTo(Integer value) {
addCriterion("EXECUTOR_ID =", value, "executorId");
return (Criteria) this;
// 添加查询条件，判断EXECUTOR_ID是否小于等于某个值
}
addCriterion("EXECUTOR_ID <=", value, "executorId
```java
public Criteria andExecutorIdNotEqualTo(Integer value) {
addCriterion("EXECUTOR_ID <>", value, "executorId");

19
src/main/java/com/xmomen/module/system/entity/SysTaskHead.java
Unescape View File

@ -27,28 +27,37 @@ public class SysTaskHead extends BaseMybatisModel {
private String taskDesc;
@Column(name = "ID")
// 标识该字段为数据库表的主键
@Id
// 使用UUID生成器生成主键
@GeneratedValue(generator = "UUIDGenerator")
public Integer getId() {
return id;
}
// 设置主键
public void setId(Integer id) {
this.id = id;
// 如果主键为空，则移除验证字段
if(id == null){
removeValidField("id");
return;
}
// 否则，添加验证字段
addValidField("id");
}
// 标识该字段为数据库表的列
@Column(name = "TASK_NAME")
// 获取任务名称
public String getTaskName() {
return taskName;
}
// 设置任务名称
public void setTaskName(String taskName) {
this.taskName = taskName;
// 如果任务名称为空，则移除验证字段
if(taskName == null){
removeValidField("taskName");
return;
@ -58,13 +67,23 @@ public class SysTaskHead extends BaseMybatisModel {
@Column(name = "TASK_DESC")
public String getTaskDesc() {
// 设置任务描述
// 将传入的任务描述赋值给成员变量
return taskDesc;
// 如果任务描述为空
}
// 移除有效的字段
// 返回
// 设置任务描述
public void setTaskDesc(String taskDesc) {
// 将传入的任务描述赋值给成员变量
this.taskDesc = taskDesc;
// 如果任务描述为空
if(taskDesc == null){
// 移除有效的字段
removeValidField("taskDesc");
// 返回
return;
}
addValidField("taskDesc");

132
src/main/java/com/xmomen/module/system/entity/SysTaskHeadExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 定义SysTaskHeadExample类，继承BaseMybatisExample类
public class SysTaskHeadExample extends BaseMybatisExample {
// 定义orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义distinct变量，用于存储是否去重
protected boolean distinct;
// 定义oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria变量
public SysTaskHeadExample() {
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 SysTaskHeadExample 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,206 +113,265 @@ public class SysTaskHeadExample 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");
}
criteria.add(new Criterion(condition, value));
// 添加条件
// 如果value1或value2为null，则抛出异常
// 添加查询条件
}
// 添加条件到criteria中
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");
}
// 添加ID为空的查询条件
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("ID is null");
// 添加ID不为空的查询条件
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
// 添加ID等于指定值的查询条件
return (Criteria) this;
}
// 根据id等于某个值进行查询
// 添加查询条件，id等于某个值
// 添加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");
// 添加一个条件，ID小于等于value
return (Criteria) this;
// 添加ID在指定值列表中的查询条件
// 添加一个条件，ID小于等于value
}
// 返回当前对象
public Criteria andIdLessThanOrEqualTo(Integer value) {
// 添加ID不在指定值列表中的查询条件
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
// 添加ID在指定值之间的查询条件
addCriterion("ID in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
// 添加ID不在指定值之间的查询条件
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
// 添加TASK_NAME为空的查询条件
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
// 添加TASK_NAME不为空的查询条件
// 添加条件，任务名称为空
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 添加TASK_NAME等于指定值的查询条件
public Criteria andTaskNameIsNull() {
addCriterion("TASK_NAME is null");
return (Criteria) this;
}
// 添加TASK_NAME不等于指定值的查询条件
public Criteria andTaskNameIsNotNull() {
addCriterion("TASK_NAME is not null");
return (Criteria) this;
}
// 添加TASK_NAME大于指定值的查询条件
public Criteria andTaskNameEqualTo(String value) {
addCriterion("TASK_NAME =", value, "taskName");
return (Criteria) this;
}
// 添加TASK_NAME大于等于指定值的查询条件
public Criteria andTaskNameNotEqualTo(String value) {
addCriterion("TASK_NAME <>", value, "taskName");
return (Criteria) this;
}
// 添加TASK_NAME小于指定值的查询条件
public Criteria andTaskNameGreaterThan(String value) {
addCriterion("TASK_NAME >", value, "taskName");
return (Criteria) this;
}
// 添加TASK_NAME小于等于指定值的查询条件
public Criteria andTaskNameGreaterThanOrEqualTo(String value) {
addCriterion("TASK_NAME >=", value, "taskName");
return (Criteria) this;
// 添加一个条件，任务名称小于指定值
// 添加条件，TASK_NAME < value
// 添加TASK_NAME包含指定值的查询条件
}
// 返回当前对象
public Criteria andTaskNameLessThan(String value) {
addCriterion("TASK_NAME <", value, "taskName");
// 添加TASK_NAME不包含指定值的查询条件
return (Criteria) this;
}
public Criteria andTaskNameLessThanOrEqualTo(String value) {
addCriterion("TASK_NAME <=", value, "taskName");
// 添加TASK_NAME在指定值列表中的查询条件
return (Criteria) this;
}
public Criteria andTaskNameLike(String value) {
addCriterion("TASK_NAME like", value, "taskName");
// 添加TASK_NAME不在指定值列表中的查询条件
return (Criteria) this;
}
public Criteria andTaskNameNotLike(String value) {
addCriterion("TASK_NAME not like", value, "taskName");
// 添加TASK_NAME在指定值之间的查询条件
return (Criteria) this;
}
public Criteria andTaskNameIn(List<String> values) {
addCriterion("TASK_NAME in", values, "taskName");
// 添加TASK_NAME不在指定值之间的查询条件
return (Criteria) this;
}
public Criteria andTaskNameNotIn(List<String> values) {
addCriterion("TASK_NAME not in", values, "taskName");
// 添加TASK_DESC为空的查询条件
return (Criteria) this;
}
public Criteria andTaskNameBetween(String value1, String value2) {
addCriterion("TASK_NAME between", value1, value2, "taskName");
// 添加TASK_DESC不为空的查询条件
return (Criteria) this;
}
public Criteria andTaskNameNotBetween(String value1, String value2) {
// 添加条件，TASK_DESC为空
// 添加TASK_DESC等于指定值的查询条件
addCriterion("TASK_NAME not between", value1, value2, "taskName");
return (Criteria) this;
}
public Criteria andTaskDescIsNull() {
// 添加TASK_DESC不等于指定值的查询条件
addCriterion("TASK_DESC is null");
return (Criteria) this;
}
public Criteria andTaskDescIsNotNull() {
// 添加TASK_DESC大于指定值的查询条件
addCriterion("TASK_DESC is not null");
return (Criteria) this;
}
public Criteria andTaskDescEqualTo(String value) {
// 添加TASK_DESC大于等于指定值的查询条件
addCriterion("TASK_DESC =", value, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescNotEqualTo(String value) {
// 添加TASK_DESC小于指定值的查询条件
addCriterion("TASK_DESC <>", value, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescGreaterThan(String value) {
// 添加TASK_DESC小于等于指定值的查询条件
addCriterion("TASK_DESC >", value, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescGreaterThanOrEqualTo(String value) {
// 添加TASK_DESC包含指定值的查询条件
addCriterion("TASK_DESC >=", value, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescLessThan(String value) {
// 添加TASK_DESC不包含指定值的查询条件
addCriterion("TASK_DESC <", value, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescLessThanOrEqualTo(String value) {
// 添加TASK_DESC在指定值列表中的查询条件
addCriterion("TASK_DESC <=", value, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescLike(String value) {
// 添加TASK_DESC不在指定值列表中的查询条件
addCriterion("TASK_DESC like", value, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescNotLike(String value) {
// 添加TASK_DESC在指定值之间的查询条件
addCriterion("TASK_DESC not like", value, "taskDesc");
return (Criteria) this;
// 根据taskDesc的值在values中，添加条件
}
// 添加TASK_DESC不在指定值之间的查询条件
// 根据传入的values参数，将TASK_DESC字段添加到查询条件中
public Criteria andTaskDescIn(List<String> values) {
addCriterion("TASK_DESC in", values, "taskDesc");
return (Criteria) this;
}
public Criteria andTaskDescNotIn(List<String> values) {
// 定义Criteria内部类
addCriterion("TASK_DESC not in", values, "taskDesc");
return (Criteria) this;
}
@ -298,6 +379,7 @@ public class SysTaskHeadExample extends BaseMybatisExample {
public Criteria andTaskDescBetween(String value1, String value2) {
addCriterion("TASK_DESC between", value1, value2, "taskDesc");
return (Criteria) this;
// 定义Criterion内部类
}
public Criteria andTaskDescNotBetween(String value1, String value2) {
@ -315,86 +397,134 @@ public class SysTaskHeadExample extends BaseMybatisExample {
public static class Criterion {
private String condition;
// 获取condition变量
private Object value;
private Object secondValue;
// 获取value变量
private boolean noValue;
private boolean singleValue;
// 获取secondValue变量
private boolean betweenValue;
private boolean listValue;
// 判断是否没有值
private String typeHandler;
// 获取条件
public String getCondition() {
// 判断是否只有一个值
return condition;
}
// 获取值
public Object getValue() {
// 判断是否在指定值之间
return value;
}
// 获取第二个值
public Object getSecondValue() {
// 判断是否在值列表中
return secondValue;
}
// 判断是否没有值
public boolean isNoValue() {
// 获取typeHandler变量
return noValue;
}
// 判断是否为单个值
public boolean isSingleValue() {
// 构造函数，初始化condition变量
return singleValue;
}
// 判断是否为值之间
public boolean isBetweenValue() {
return betweenValue;
}
// 构造函数，初始化condition、value和typeHandler变量
// 判断是否为列表值
// 判断是否为列表值
public boolean isListValue() {
return listValue;
// 获取类型处理器
}
// 获取类型处理器
public String getTypeHandler() {
return typeHandler;
// 构造函数，传入条件
}
// 构造函数，传入一个条件字符串
// 构造函数，初始化condition和value变量
protected Criterion(String condition) {
// 将传入的条件字符串赋值给成员变量condition
super();
// 将typeHandler赋值为null
this.condition = condition;
// 将noValue赋值为true
// 构造函数，初始化condition、value、secondValue和typeHandler变量
this.typeHandler = null;
this.noValue = true;
}
// 设置条件
protected Criterion(String condition, Object value, String typeHandler) {
// 构造函数，初始化condition、value和secondValue变量
// 设置值
super();
// 设置类型处理器
// 判断值是否为List类型
this.condition = condition;
// 如果是List类型，则设置listValue为true
this.value = value;
// 否则，设置singleValue为true
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
// 构造函数，设置条件、值
this.singleValue = true;
}
}
// 构造函数，设置条件、值、第二个值、类型处理器
protected Criterion(String condition, Object value) {
// 设置条件
// 设置值
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
// 设置第二个值
super();
// 设置类型处理器
// 设置between值为true
// 构造函数，设置条件、第一个值和第二个值
this.condition = condition;
// 设置条件
this.value = value;
// 设置值
this.secondValue = secondValue;
// 设置第二个值
this.typeHandler = typeHandler;
// 设置类型处理器
this.betweenValue = true;
// 构造函数，用于创建Criterion对象
}
// 调用另一个构造函数，传入condition、value、secondValue和null
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}

25
src/main/java/com/xmomen/module/system/entity/SysUserOrganization.java
Unescape View File

@ -26,47 +26,72 @@ public class SysUserOrganization extends BaseMybatisModel {
*/
private Integer userId;
// 定义ID字段
@Column(name = "ID")
// 设置ID为主键
@Id
// 设置ID的生成方式为UUID
@GeneratedValue(generator = "UUIDGenerator")
public Integer getId() {
// 返回ID
return id;
}
// 设置ID
public void setId(Integer id) {
// 将传入的ID赋值给成员变量
this.id = id;
// 如果ID为空
if(id == null){
// 移除验证字段
removeValidField("id");
// 返回
return;
}
addValidField("id");
}
// 获取组织ID
@Column(name = "ORGANIZATION_ID")
public Integer getOrganizationId() {
return organizationId;
}
// 设置组织ID
public void setOrganizationId(Integer organizationId) {
this.organizationId = organizationId;
// 如果组织ID为空，则移除验证字段
if(organizationId == null){
removeValidField("organizationId");
return;
}
// 否则，添加验证字段
addValidField("organizationId");
}
// 获取用户ID
@Column(name = "USER_ID")
public Integer getUserId() {
return userId;
}
// 获取用户ID
public void setUserId(Integer userId) {
this.userId = userId;
if(userId == null){
removeValidField("userId");
return;
}
}
// 设置用户ID
public void setUserId(Integer userId) {
// 如果用户ID为空，则移除验证字段
this.userId = userId;
if(userId == null){
removeValidField("userId");
return;
}
// 添加有效的字段
addValidField("userId");
}
}

124
src/main/java/com/xmomen/module/system/entity/SysUserOrganizationExample.java
Unescape View File

@ -4,145 +4,206 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 定义一个SysUserOrganizationExample类，继承自BaseMybatisExample类
public class SysUserOrganizationExample extends BaseMybatisExample {
// 定义一个orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量，用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria列表
public SysUserOrganizationExample() {
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);
}
// 返回一个新的Criteria对象，并将其添加到oredCriteria列表中
public Criteria or() {
// 创建一个新的Criteria对象
Criteria criteria = createCriteriaInternal();
// 将新的Criteria对象添加到oredCriteria列表中
oredCriteria.add(criteria);
// 返回新的Criteria对象
return criteria;
}
// 创建一个Criteria对象
// 调用createCriteriaInternal()方法创建一个Criteria对象
public Criteria createCriteria() {
// 如果oredCriteria集合为空，则将创建的Criteria对象添加到oredCriteria集合中
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
// 创建内部条件
}
// 创建一个新的条件对象
// 返回条件对象
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
// 清空查询条件
// 清空oredCriteria中的所有条件
// 将orderByClause置为null
return criteria;
// 将distinct置为false
}
// 清空查询条件
public void clear() {
oredCriteria.clear();
// 定义一个抽象静态类GeneratedCriteria
orderByClause = null;
// 定义一个List类型的变量criteria，用于存储Criterion对象
distinct = false;
}
// 定义一个抽象静态类GeneratedCriteria
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
// 构造函数
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
// 构造函数
protected GeneratedCriteria() {
super();
// 初始化一个空的Criterion列表
criteria = new ArrayList<Criterion>();
}
// 判断生成的条件是否有效
public boolean isValid() {
// 如果条件列表不为空，则返回true，否则返回false
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");
// 将条件添加到条件列表中
}
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");
// 将条件和值添加到条件列表中
}
// 添加一个条件，条件为condition，值为value1和value2，属性为property
return (Criteria) this;
// 如果value1或value2为null，则抛出异常
criteria.add(new Criterion(condition, value));
}
// 添加一个条件，条件为condition，值为value1和value2
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");
// 添加一个条件，条件为ID is null
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
// 添加ID字段不为空的查询条件
addCriterion("ID is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
// 添加ID字段等于指定值的查询条件
addCriterion("ID is not null");
return (Criteria) this;
}
// 添加ID字段不等于指定值的查询条件
// 根据id等于某个值进行查询
public Criteria andIdEqualTo(Integer value) {
// 添加查询条件，id等于某个值
addCriterion("ID =", value, "id");
// 返回当前查询条件
return (Criteria) this;
}
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小于等于指定值的条件
}
// 添加一个条件，ID小于等于value
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
// 添加ID在指定值列表中的条件
}
public Criteria andIdIn(List<Integer> values) {
@ -153,93 +214,122 @@ public class SysUserOrganizationExample extends BaseMybatisExample {
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
// 添加条件，ID在value1和value2之间
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
// 添加条件，ID不在value1和value2之间
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
// 添加条件，ORGANIZATION_ID为空
}
// 添加条件，ORGANIZATION_ID为空
// 添加条件，ORGANIZATION_ID为空
public Criteria andOrganizationIdIsNull() {
addCriterion("ORGANIZATION_ID is null");
return (Criteria) this;
}
// 添加一个条件，ORGANIZATION_ID不能为空
public Criteria andOrganizationIdIsNotNull() {
addCriterion("ORGANIZATION_ID is not null");
return (Criteria) this;
}
// 根据organizationId的值等于value进行查询
public Criteria andOrganizationIdEqualTo(Integer value) {
addCriterion("ORGANIZATION_ID =", value, "organizationId");
return (Criteria) this;
}
// 根据organizationId的值不等于value进行查询
public Criteria andOrganizationIdNotEqualTo(Integer value) {
addCriterion("ORGANIZATION_ID <>", value, "organizationId");
// 返回当前对象
return (Criteria) this;
}
// 添加条件，当organizationId大于指定值时
public Criteria andOrganizationIdGreaterThan(Integer value) {
// 添加条件
addCriterion("ORGANIZATION_ID >", value, "organizationId");
// 返回当前对象
return (Criteria) this;
}
// 添加organizationId大于等于value的条件
// 添加条件，ORGANIZATION_ID大于等于value
// 添加条件，ORGANIZATION_ID大于等于value
public Criteria andOrganizationIdGreaterThanOrEqualTo(Integer value) {
// 添加查询条件，ORGANIZATION_ID大于等于value
addCriterion("ORGANIZATION_ID >=", value, "organizationId");
// 返回当前Criteria对象
return (Criteria) this;
}
// 添加organizationId小于value的条件
public Criteria andOrganizationIdLessThan(Integer value) {
addCriterion("ORGANIZATION_ID <", value, "organizationId");
return (Criteria) this;
}
// 添加organizationId小于等于value的条件
public Criteria andOrganizationIdLessThanOrEqualTo(Integer value) {
addCriterion("ORGANIZATION_ID <=", value, "organizationId");
return (Criteria) this;
}
// 添加organizationId在values列表中的条件
public Criteria andOrganizationIdIn(List<Integer> values) {
addCriterion("ORGANIZATION_ID in", values, "organizationId");
return (Criteria) this;
}
// 添加organizationId不在values列表中的条件
public Criteria andOrganizationIdNotIn(List<Integer> values) {
addCriterion("ORGANIZATION_ID not in", values, "organizationId");
return (Criteria) this;
}
// 添加organizationId在value1和value2之间的条件
// 添加organizationId在value1和value2之间的条件
public Criteria andOrganizationIdBetween(Integer value1, Integer value2) {
addCriterion("ORGANIZATION_ID between", value1, value2, "organizationId");
return (Criteria) this;
}
// 添加条件，ORGANIZATION_ID字段不在value1和value2之间
public Criteria andOrganizationIdNotBetween(Integer value1, Integer value2) {
addCriterion("ORGANIZATION_ID not between", value1, value2, "organizationId");
return (Criteria) this;
}
// 添加USER_ID为空的查询条件
// 添加条件，USER_ID为空
public Criteria andUserIdIsNull() {
addCriterion("USER_ID is null");
return (Criteria) this;
}
// 添加USER_ID不为空的查询条件
public Criteria andUserIdIsNotNull() {
addCriterion("USER_ID is not null");
return (Criteria) this;
}
// 添加USER_ID等于指定值的查询条件
public Criteria andUserIdEqualTo(Integer value) {
addCriterion("USER_ID =", value, "userId");
return (Criteria) this;
}
// 添加USER_ID不等于指定值的查询条件
public Criteria andUserIdNotEqualTo(Integer value) {
addCriterion("USER_ID <>", value, "userId");
return (Criteria) this;
@ -269,22 +359,33 @@ public class SysUserOrganizationExample extends BaseMybatisExample {
addCriterion("USER_ID in", values, "userId");
return (Criteria) this;
}
// 根据用户ID列表，添加不包含在列表中的条件
// 根据用户ID列表，添加条件，用户ID不在列表中
// 根据用户ID列表，添加条件，用户ID不在列表中
// 根据用户ID列表，添加不包含在列表中的条件
public Criteria andUserIdNotIn(List<Integer> values) {
// 添加条件
addCriterion("USER_ID not in", values, "userId");
// 返回当前对象
return (Criteria) this;
}
// 根据用户ID范围，添加包含在范围内的条件
public Criteria andUserIdBetween(Integer value1, Integer value2) {
// 根据用户ID范围，添加不包含在范围内的条件
addCriterion("USER_ID between", value1, value2, "userId");
return (Criteria) this;
}
// 根据用户ID范围，添加不包含在范围内的条件
public Criteria andUserIdNotBetween(Integer value1, Integer value2) {
// 根据用户ID范围，添加包含在范围内的条件
addCriterion("USER_ID not between", value1, value2, "userId");
return (Criteria) this;
}
}
// 生成Criteria类
public static class Criteria extends GeneratedCriteria {
@ -342,6 +443,7 @@ public class SysUserOrganizationExample extends BaseMybatisExample {
return typeHandler;
}
// 构造函数，传入条件
protected Criterion(String condition) {
super();
this.condition = condition;
@ -349,11 +451,13 @@ public class SysUserOrganizationExample extends BaseMybatisExample {
this.noValue = true;
}
// 构造函数，传入条件、值和类型处理器
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
// 判断值是否为List类型
if (value instanceof List<?>) {
this.listValue = true;
} else {
@ -361,18 +465,22 @@ public class SysUserOrganizationExample extends BaseMybatisExample {
}
}
// 构造函数，传入条件、值
protected Criterion(String condition, Object value) {
this(condition, value, null);
// 构造函数，用于创建一个Criterion对象，该对象包含条件、值、第二个值和类型处理器
}
// 构造函数，用于创建一个Criterion对象，该对象包含条件、值和第二个值
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
// 构造函数，用于创建一个Criterion对象，该对象包含条件、值和第二个值
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);

5
src/main/java/com/xmomen/module/system/entity/mapper/SysDictionaryMapper.java
Unescape View File

@ -5,12 +5,17 @@ import com.xmomen.module.system.entity.SysDictionary;
import com.xmomen.module.system.entity.SysDictionaryExample;
import org.apache.ibatis.annotations.Param;
// 系统字典Mapper接口
public interface SysDictionaryMapper extends MybatisMapper {
// 根据条件统计字典数量
int countByExample(SysDictionaryExample example);
// 根据条件删除字典
int deleteByExample(SysDictionaryExample example);
// 插入字典
int insertSelective(SysDictionary record);
// 根据条件更新字典
int updateByExampleSelective(@Param("record") SysDictionary record, @Param("example") SysDictionaryExample example);
}

5
src/main/java/com/xmomen/module/system/entity/mapper/SysDictionaryParameterMapper.java
Unescape View File

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

5
src/main/java/com/xmomen/module/system/entity/mapper/SysOrganizationMapper.java
Unescape View File

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

5
src/main/java/com/xmomen/module/system/entity/mapper/SysTaskHeadMapper.java
Unescape View File

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

5
src/main/java/com/xmomen/module/system/entity/mapper/SysTaskMapper.java
Unescape View File

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

5
src/main/java/com/xmomen/module/system/entity/mapper/SysUserOrganizationMapper.java
Unescape View File

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

2
src/main/java/com/xmomen/module/system/mapper/DictionaryMapper.java
Unescape View File

@ -10,6 +10,8 @@ import org.apache.ibatis.annotations.Select;
*/
public interface DictionaryMapper {
// 根据关键字获取字典列表
// 根据关键字查询字典列表
@Select(value = "")
@ResultType(Dictionary.class)
public Dictionary getDictionaryList(@Param(value = "keyword") String keyword);

2
src/main/java/com/xmomen/module/system/mapper/LogMapper.java
Unescape View File

@ -9,7 +9,9 @@ import org.apache.ibatis.annotations.Options;
*/
public interface LogMapper {
// 向sys_log表中插入一条日志记录
@Insert("insert into sys_log(user_id,action_name,action_date,action_params,client_ip,action_result) values(#{userId},#{actionName},#{actionDate},#{actionParams},#{clientIp},#{actionResult}) ")
// 使用自动生成的主键
@Options(useGeneratedKeys = true, keyProperty = "id")
public void insertLog(LogModel logModel);
}

2
src/main/java/com/xmomen/module/system/mapper/LogMapper.xml
Unescape View File

@ -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，命名空间为com.xmomen.module.system.mapper.LogMapper -->
<mapper namespace="com.xmomen.module.system.mapper.LogMapper" >
<!-- 定义一个parameterMap，id为logModel，类型为com.xmomen.module.system.model.LogModel -->
<parameterMap id="logModel" type="com.xmomen.module.system.model.LogModel" />
</mapper>

2
src/main/java/com/xmomen/module/system/mapper/OrganizationMapper.java
Unescape View File

@ -12,7 +12,9 @@ import java.util.List;
*/
public interface OrganizationMapper {
// 根据id查询组织树
@Select(value = "SELECT s.ID,s.NAME,s.DESCRIPTION, s.PARENT_ID,p.NAME AS parent_name FROM sys_organization s LEFT JOIN sys_organization p ON p.ID=s.PARENT_ID where FIND_IN_SET(s.id, query_children_organization(${id}))")
// 返回类型为OrganizationModel
@ResultType(OrganizationModel.class)
public List<OrganizationModel> getOrganizationTree(@Param(value = "id") Integer id);
}

1
src/main/java/com/xmomen/module/system/mapper/TaskMapper.java
Unescape View File

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

2
src/main/java/com/xmomen/module/system/mapper/TaskMapper.xml
Unescape View File

@ -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，命名空间为com.xmomen.module.system.mapper.TaskMapper -->
<mapper namespace="com.xmomen.module.system.mapper.TaskMapper" >
<!-- 根据id查询数据 -->
<select id="" >

11
src/main/java/com/xmomen/module/system/model/CreateDictionary.java
Unescape View File

@ -39,44 +39,55 @@ public class CreateDictionary implements Serializable {
/**
* 0-禁用，1-启用
*/
// 定义一个Integer类型的变量available
private Integer available;
// 获取sysDictionaryId的值
public Integer getSysDictionaryId() {
return sysDictionaryId;
}
// 设置sysDictionaryId的值
public void setSysDictionaryId(Integer sysDictionaryId) {
this.sysDictionaryId = sysDictionaryId;
}
// 获取showValue的值
public String getShowValue() {
return showValue;
}
// 设置showValue的值
public void setShowValue(String showValue) {
this.showValue = showValue;
}
// 获取realValue的值
public String getRealValue() {
return realValue;
}
// 设置realValue的值
public void setRealValue(String realValue) {
this.realValue = realValue;
}
// 获取sortValue的值
public Integer getSortValue() {
return sortValue;
}
// 设置sortValue的值
public void setSortValue(Integer sortValue) {
this.sortValue = sortValue;
}
// 获取available的值
public Integer getAvailable() {
return available;
}
// 设置available的值
public void setAvailable(Integer available) {
this.available = available;
}

7
src/main/java/com/xmomen/module/system/model/CreateDictionaryGroup.java
Unescape View File

@ -26,28 +26,35 @@ public class CreateDictionaryGroup implements Serializable {
/**
* 是否启用
*/
// 定义一个Integer类型的变量available
private Integer available;
// 获取dictionaryCode的值
public String getDictionaryCode() {
return dictionaryCode;
}
// 设置dictionaryCode的值
public void setDictionaryCode(String dictionaryCode) {
this.dictionaryCode = dictionaryCode;
}
// 获取dictionaryDesc的值
public String getDictionaryDesc() {
return dictionaryDesc;
}
// 设置dictionaryDesc的值
public void setDictionaryDesc(String dictionaryDesc) {
this.dictionaryDesc = dictionaryDesc;
}
// 获取available的值
public Integer getAvailable() {
return available;
}
// 设置available的值
public void setAvailable(Integer available) {
this.available = available;
}

7
src/main/java/com/xmomen/module/system/model/CreateOrganization.java
Unescape View File

@ -17,28 +17,35 @@ public class CreateOrganization implements Serializable {
@NotBlank
private String description;
// 父节点ID
private Integer parentId;
// 获取名称
public String getName() {
return name;
}
// 设置名称
public void setName(String name) {
this.name = name;
}
// 获取描述
public String getDescription() {
return description;
}
// 设置描述
public void setDescription(String description) {
this.description = description;
}
// 获取父节点ID
public Integer getParentId() {
return parentId;
}
// 设置父节点ID
public void setParentId(Integer parentId) {
this.parentId = parentId;
}

2
src/main/java/com/xmomen/module/system/model/CreateTask.java
Unescape View File

@ -10,6 +10,8 @@ import java.io.Serializable;
public @Data
class CreateTask implements Serializable {
// 任务头ID
private Integer taskHeadId;
// 执行者ID
private Integer executorId;
}

15
src/main/java/com/xmomen/module/system/model/Dictionary.java
Unescape View File

@ -40,60 +40,75 @@ public class Dictionary implements Serializable {
/**
* 启用状态描述
*/
// 可用描述
private String availableDesc;
// 获取id
public Integer getId() {
return id;
}
// 设置id
public void setId(Integer id) {
this.id = id;
}
// 获取系统字典id
public Integer getSysDictionaryId() {
return sysDictionaryId;
}
// 设置系统字典id
public void setSysDictionaryId(Integer sysDictionaryId) {
this.sysDictionaryId = sysDictionaryId;
}
// 获取显示值
public String getShowValue() {
return showValue;
}
// 设置显示值
public void setShowValue(String showValue) {
this.showValue = showValue;
}
// 获取实际值
public String getRealValue() {
return realValue;
}
// 设置实际值
public void setRealValue(String realValue) {
this.realValue = realValue;
}
// 获取排序值
public Integer getSortValue() {
return sortValue;
}
// 设置排序值
public void setSortValue(Integer sortValue) {
this.sortValue = sortValue;
}
// 获取可用状态
public Integer getAvailable() {
return available;
}
// 设置可用状态
public void setAvailable(Integer available) {
this.available = available;
}
// 获取可用描述
public String getAvailableDesc() {
return availableDesc;
}
// 设置可用描述
public void setAvailableDesc(String availableDesc) {
this.availableDesc = availableDesc;
}

11
src/main/java/com/xmomen/module/system/model/DictionaryGroup.java
Unescape View File

@ -32,44 +32,55 @@ public class DictionaryGroup implements Serializable {
/**
* 启用状态描述
*/
// 可用描述
private String availableDesc;
// 获取id
public Integer getId() {
return id;
}
// 设置id
public void setId(Integer id) {
this.id = id;
}
// 获取字典编码
public String getDictionaryCode() {
return dictionaryCode;
}
// 设置字典编码
public void setDictionaryCode(String dictionaryCode) {
this.dictionaryCode = dictionaryCode;
}
// 获取字典描述
public String getDictionaryDesc() {
return dictionaryDesc;
}
// 设置字典描述
public void setDictionaryDesc(String dictionaryDesc) {
this.dictionaryDesc = dictionaryDesc;
}
// 获取可用状态
public Integer getAvailable() {
return available;
}
// 设置可用状态
public void setAvailable(Integer available) {
this.available = available;
}
// 获取可用描述
public String getAvailableDesc() {
return availableDesc;
}
// 设置可用描述
public void setAvailableDesc(String availableDesc) {
this.availableDesc = availableDesc;
}

21
src/main/java/com/xmomen/module/system/model/LogModel.java
Unescape View File

@ -8,66 +8,87 @@ import java.util.Date;
*/
public class LogModel implements Serializable{
// 用户ID
private Integer userId;
// 动作名称
private String actionName;
// 动作日期
private Date actionDate;
// 客户端IP
private String clientIp;
// 动作参数
private String actionParams;
// 动作结果
private String actionResult;
// 备注
private String remark;
// 获取用户ID
public Integer getUserId() {
return userId;
}
// 设置用户ID
public void setUserId(Integer userId) {
this.userId = userId;
}
// 获取动作名称
public String getActionName() {
return actionName;
}
// 设置动作名称
public void setActionName(String actionName) {
this.actionName = actionName;
}
// 获取客户端IP
public String getClientIp() {
return clientIp;
}
// 设置客户端IP
public void setClientIp(String clientIp) {
this.clientIp = clientIp;
}
// 获取动作日期
public Date getActionDate() {
return actionDate;
}
// 设置动作日期
public void setActionDate(Date actionDate) {
this.actionDate = actionDate;
}
// 获取动作参数
public String getActionParams() {
return actionParams;
}
// 设置动作参数
public void setActionParams(String actionParams) {
this.actionParams = actionParams;
}
// 获取动作结果
public String getActionResult() {
return actionResult;
}
// 设置动作结果
public void setActionResult(String actionResult) {
this.actionResult = actionResult;
}
// 获取备注
public String getRemark() {
return remark;
}
// 设置备注
public void setRemark(String remark) {
this.remark = remark;
}

18
src/main/java/com/xmomen/module/system/model/OrganizationModel.java
Unescape View File

@ -8,57 +8,75 @@ import java.util.List;
*/
public class OrganizationModel implements Serializable {
// 组织ID
private Integer id;
// 组织名称
private String name;
// 组织描述
private String description;
// 父组织ID
private Integer parentId;
// 父组织名称
private String parentName;
// 子组织列表
private List<OrganizationModel> nodes;
// 获取组织ID
public Integer getId() {
return id;
}
// 设置组织ID
public void setId(Integer id) {
this.id = id;
}
// 获取组织名称
public String getName() {
return name;
}
// 设置组织名称
public void setName(String name) {
this.name = name;
}
// 获取组织描述
public String getDescription() {
return description;
}
// 设置组织描述
public void setDescription(String description) {
this.description = description;
}
// 获取父组织ID
public Integer getParentId() {
return parentId;
}
// 设置父组织ID
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
// 获取父组织名称
public String getParentName() {
return parentName;
}
// 设置父组织名称
public void setParentName(String parentName) {
this.parentName = parentName;
}
// 获取子组织列表
public List<OrganizationModel> getNodes() {
return nodes;
}
// 设置子组织列表
public void setNodes(List<OrganizationModel> nodes) {
this.nodes = nodes;
}

3
src/main/java/com/xmomen/module/system/model/TaskQuery.java
Unescape View File

@ -10,8 +10,11 @@ import java.io.Serializable;
public @Data
class TaskQuery implements Serializable{
// 关键字
private String keyword;
// 任务状态
private Integer[] taskStatus;
// 执行者ID
private Integer[] executorIds;
}

13
src/main/java/com/xmomen/module/system/model/UpdateDictionary.java
Unescape View File

@ -41,52 +41,65 @@ public class UpdateDictionary implements Serializable {
/**
* 0-禁用，1-启用
*/
// 定义一个Integer类型的available变量
private Integer available;
// 获取id的值
public Integer getId() {
return id;
}
// 设置id的值
public void setId(Integer id) {
this.id = id;
}
// 获取sysDictionaryId的值
public Integer getSysDictionaryId() {
return sysDictionaryId;
}
// 设置sysDictionaryId的值
public void setSysDictionaryId(Integer sysDictionaryId) {
this.sysDictionaryId = sysDictionaryId;
}
// 获取showValue的值
public String getShowValue() {
return showValue;
}
// 设置showValue的值
public void setShowValue(String showValue) {
this.showValue = showValue;
}
// 获取realValue的值
public String getRealValue() {
return realValue;
}
// 设置realValue的值
public void setRealValue(String realValue) {
this.realValue = realValue;
}
// 获取sortValue的值
public Integer getSortValue() {
return sortValue;
}
// 设置sortValue的值
public void setSortValue(Integer sortValue) {
this.sortValue = sortValue;
}
// 获取available的值
public Integer getAvailable() {
return available;
}
// 设置available的值
public void setAvailable(Integer available) {
this.available = available;
}

7
src/main/java/com/xmomen/module/system/model/UpdateDictionaryGroup.java
Unescape View File

@ -20,28 +20,35 @@ public class UpdateDictionaryGroup implements Serializable {
/**
* 是否启用
*/
// 定义一个Integer类型的变量available
private Integer available;
// 获取dictionaryCode的值
public String getDictionaryCode() {
return dictionaryCode;
}
// 设置dictionaryCode的值
public void setDictionaryCode(String dictionaryCode) {
this.dictionaryCode = dictionaryCode;
}
// 获取dictionaryDesc的值
public String getDictionaryDesc() {
return dictionaryDesc;
}
// 设置dictionaryDesc的值
public void setDictionaryDesc(String dictionaryDesc) {
this.dictionaryDesc = dictionaryDesc;
}
// 获取available的值
public Integer getAvailable() {
return available;
}
// 设置available的值
public void setAvailable(Integer available) {
this.available = available;
}

11
src/main/java/com/xmomen/module/system/service/DictionaryGroupService.java
Unescape View File

@ -15,27 +15,38 @@ import org.springframework.transaction.annotation.Transactional;
@Service
public class DictionaryGroupService {
// 注入MybatisDao
@Autowired
MybatisDao mybatisDao;
// 创建字典
@Transactional
public SysDictionary createDictionary(SysDictionary sysDictionary){
// 调用mybatisDao的insertByModel方法插入字典
return mybatisDao.insertByModel(sysDictionary);
}
// 获取字典列表
public Page<SysDictionary> getDictionaryList(String keyword, Integer limit, Integer offset){
// 将关键字前后加上%符号，用于模糊查询
String keywordP ="%" + StringUtilsExt.trimToEmpty(keyword) + "%";
// 创建SysDictionaryExample对象
SysDictionaryExample sysDictionaryExample = new SysDictionaryExample();
// 添加查询条件，字典编码或字典描述包含关键字
sysDictionaryExample.createCriteria()
.andDictionaryCodeLike(keywordP);
sysDictionaryExample.or().andDictionaryDescLike(keywordP);
// 调用mybatisDao的selectPageByExample方法查询字典列表
return mybatisDao.selectPageByExample(sysDictionaryExample, limit, offset);
}
// 根据id获取字典
public SysDictionary getDictionary(Integer id){
// 更新字典
return mybatisDao.selectByPrimaryKey(SysDictionary.class, id);
}
// 根据id删除字典
public void updateDictionary(SysDictionary sysDictionary){
mybatisDao.update(sysDictionary);
}

13
src/main/java/com/xmomen/module/system/service/DictionaryService.java
Unescape View File

@ -17,24 +17,37 @@ import org.springframework.transaction.annotation.Transactional;
@Service
public class DictionaryService {
// 注入MybatisDao
@Autowired
MybatisDao mybatisDao;
// 创建字典
@Transactional
public SysDictionaryParameter createDictionary(SysDictionaryParameter sysDictionaryParameter){
// 调用MybatisDao的insertByModel方法插入字典
return mybatisDao.insertByModel(sysDictionaryParameter);
}
// 获取字典列表
public Page<SysDictionary> getDictionaryList(Integer groupId, Integer limit, Integer offset){
// 创建SysDictionaryParameterExample对象
SysDictionaryParameterExample sysDictionaryExample = new SysDictionaryParameterExample();
// 设置查询条件
sysDictionaryExample.createCriteria().andSysDictionaryIdEqualTo(groupId);
// 调用MybatisDao的selectPageByExample方法查询字典列表
return mybatisDao.selectPageByExample(sysDictionaryExample, limit, offset);
}
// 获取字典
public SysDictionaryParameter getDictionary(Integer id){
// 调用MybatisDao的selectByPrimaryKey方法查询字典
// 更新字典
return mybatisDao.selectByPrimaryKey(SysDictionaryParameter.class, id);
// 调用mybatisDao的update方法，更新字典
}
// 删除字典
// 调用mybatisDao的deleteByPrimaryKey方法，根据id删除字典
public void updateDictionary(SysDictionaryParameter sysDictionary){
mybatisDao.update(sysDictionary);
}

3
src/main/java/com/xmomen/module/system/service/LogService.java
Unescape View File

@ -13,11 +13,14 @@ import org.springframework.transaction.annotation.Transactional;
@Service
public class LogService {
// 注入LogMapper
@Autowired
LogMapper logMapper;
// 事务注解
@Transactional
public void insertLog(LogModel logModel){
// 调用LogMapper的insertLog方法，插入日志
logMapper.insertLog(logModel);
}
}

43
src/main/java/com/xmomen/module/system/service/OrganizationService.java
Unescape View File

@ -23,9 +23,11 @@ import java.util.Map;
@Service
public class OrganizationService {
// 注入MybatisDao
@Autowired
MybatisDao mybatisDao;
// 注入OrganizationMapper
@Autowired
OrganizationMapper organizationMapper;
@ -35,21 +37,36 @@ public class OrganizationService {
* @return
*/
public List<OrganizationModel> getOrganizationTree(Integer id){
// 创建SysOrganizationExample对象
SysOrganizationExample sysOrganizationExample = new SysOrganizationExample();
// 创建OrganizationModel列表
List<OrganizationModel> result = new ArrayList<OrganizationModel>();
// 判断id是否为空
if(id == null){
// 如果id为空，则设置查询条件为parentId为空
sysOrganizationExample.createCriteria().andParentIdIsNull();
// 遍历sysOrganizationList中的每一个SysOrganization对象
// 根据查询条件查询SysOrganization列表
// 调用organizationMapper的getOrganizationTree方法，传入sysOrganization的id，获取组织树
List<SysOrganization> sysOrganizationList = mybatisDao.selectByExample(sysOrganizationExample);
for (SysOrganization sysOrganization : sysOrganizationList) {
List<OrganizationModel> organizationModels = organizationMapper.getOrganizationTree(sysOrganization.getId());
// 调用getTree方法，传入组织树和id，将结果添加到result中
// 遍历SysOrganization列表
// 根据SysOrganization的id查询OrganizationModel列表
for (SysOrganization sysOrganization : sysOrganizationList) {
List<OrganizationModel> organizationModels = organizationMapper.getOrganizationTree(sysOrganization.getId());
result.add(getTree(organizationModels, id));
}
}
return result;
// 根据id获取树形结构
}
// 创建根节点
// 遍历list
private OrganizationModel getTree(List<OrganizationModel> list, Integer id){
// 如果当前节点的父节点id等于传入的id
OrganizationModel root = new OrganizationModel();
// 将当前节点赋值给根节点
for (OrganizationModel organization : list) {
if(organization.getParentId() == id){
root = organization;
@ -63,17 +80,27 @@ public class OrganizationService {
/**
* 获取子节点
* @param child
// 根据子节点和父节点获取树节点
* @param parent
// 如果子节点的父节点ID不为空，并且等于父节点的ID
*/
// 如果父节点的子节点列表为空
private void getTreeNode(OrganizationModel child, OrganizationModel parent){
// 创建一个子节点列表
if(child.getParentId() != null && child.getParentId().equals(parent.getId())){
// 将子节点添加到子节点列表中
if(parent.getNodes() == null){
// 将子节点列表设置到父节点中
List<OrganizationModel> childes = new ArrayList<OrganizationModel>();
// 如果parent的nodes为空，则将child添加到parent的nodes中
childes.add(child);
parent.setNodes(childes);
// 如果parent的nodes不为空，则遍历parent的nodes
}else{
parent.getNodes().add(child);
// 获取parent的nodes中的每一个childTree
}
// 递归调用getTreeNode方法，将child和childTree作为参数传入
}else{
if(parent.getNodes() != null && parent.getNodes().size() > 0){
for (int i = 0; i < parent.getNodes().size(); i++) {
@ -89,8 +116,10 @@ public class OrganizationService {
* @param sysOrganization
* @return
*/
// 调用mybatisDao的saveByModel方法，将sysOrganization保存到数据库中
@Transactional
public SysOrganization createOrganization(SysOrganization sysOrganization){
// 调用mybatisDao的saveByModel方法，将sysOrganization保存到数据库中
return mybatisDao.saveByModel(sysOrganization);
}
@ -100,10 +129,15 @@ public class OrganizationService {
* @param userId
*/
@Transactional
// 绑定组织用户
public void bindOrganizationUser(Integer organizationId, Integer userId){
// 创建SysUserOrganization对象
SysUserOrganization sysUserOrganization = new SysUserOrganization();
// 设置组织ID
sysUserOrganization.setOrganizationId(organizationId);
// 设置用户ID
sysUserOrganization.setUserId(userId);
// 插入数据
mybatisDao.insert(sysUserOrganization);
}
@ -112,9 +146,14 @@ public class OrganizationService {
* @param organizationId
* @param userIds
*/
// 使用@Transactional注解，表示该方法是一个事务方法
@Transactional
// 绑定组织用户
public void bindOrganizationUser(Integer organizationId, Integer... userIds){
// 遍历用户ID数组
for (Integer userId : userIds) {
// 调用bindOrganizationUser方法，绑定组织用户
// 绑定组织用户
bindOrganizationUser(organizationId, userId);
}
}

31
src/main/java/com/xmomen/module/system/service/TaskService.java
Unescape View File

@ -19,46 +19,77 @@ import org.springframework.util.CollectionUtils;
@Service
public class TaskService {
// 自动注入MybatisDao
@Autowired
MybatisDao mybatisDao;
// 事务注解
@Transactional
public SysTask createTask(CreateTask createTask){
// 创建SysTask对象
SysTask sysTask = new SysTask();
// 设置任务头ID
sysTask.setTaskHeadId(createTask.getTaskHeadId());
// 设置任务创建时间
// 设置执行者ID
// 设置任务状态为0
sysTask.setExecutorId(createTask.getExecutorId());
// 插入任务
// 设置创建时间
sysTask.setCreateTime(mybatisDao.getSysdate());
sysTask.setTaskStatus(0);
// 获取任务列表
return mybatisDao.insertByModel(sysTask);
// 使用MyBatis分页查询任务列表
}
public Page<TaskModel> getTaskList(TaskQuery taskQuery, Integer limit, Integer offset){
// 根据任务ID获取任务
return (Page<TaskModel>) mybatisDao.selectPage(TaskMapper.TASK_MAPPER_NAMESPACE + ".", taskQuery, limit, offset);
// 使用MyBatis根据主键查询任务
}
public SysTask getTask(Integer id){
return mybatisDao.selectByPrimaryKey(SysTask.class, id);
// 根据传入的id数组，将对应的任务状态设置为4
// 创建SysTaskExample对象
// 设置查询条件，id在传入的id数组中
// 创建SysTask对象
}
// 设置任务状态为4
// 根据查询条件更新任务状态
public void cancelTask(Integer... ids){
SysTaskExample sysTaskExample = new SysTaskExample();
sysTaskExample.createCriteria().andIdIn(CollectionUtils.arrayToList(ids));
// 更新任务
// 调用mybatisDao的update方法，更新任务
SysTask sysTask = new SysTask();
sysTask.setTaskStatus(4);
mybatisDao.updateByExampleSelective(sysTask, sysTaskExample);
// 删除任务
// 调用mybatisDao的deleteByPrimaryKey方法，根据id删除任务
}
public void updateTask(SysTask sysTask){
// 删除任务
mybatisDao.update(sysTask);
// 创建SysTaskExample对象
}
// 设置删除条件，id在ids数组中的任务
// 调用mybatisDao的deleteByExample方法，根据条件删除任务
public void deleteTask(Integer id){
mybatisDao.deleteByPrimaryKey(SysTask.class, id);
}
// 根据条件删除数据
public void deleteTask(Integer[] ids){
// 创建SysTaskExample对象
SysTaskExample sysTaskExample = new SysTaskExample();
// 设置查询条件，id在ids集合中
sysTaskExample.createCriteria().andIdIn(CollectionUtils.arrayToList(ids));
// 根据查询条件删除数据
mybatisDao.deleteByExample(sysTaskExample);
}

24
src/main/java/com/xmomen/module/user/entity/SysPermissions.java
Unescape View File

@ -46,41 +46,43 @@ public class SysPermissions extends BaseMybatisModel {
addValidField("id");
}
@Column(name = "PERMISSION")
public String getPermission() {
return permission;
}
public void setPermission(String permission) {
this.permission = permission;
if(permission == null){
removeValidField("permission");
return;
}
V }
addValidField("permission");
}
// 获取描述
@Column(name = "DESCRIPTION")
public String getDescription() {
return description;
}
// 设置描述
public void setDescription(String description) {
this.description = description;
// 如果描述为空，则移除有效字段
if(description == null){
removeValidField("description");
return;
}
// 否则，添加有效字段
addValidField("description");
}
// 获取可用数量
@Column(name = "AVAILABLE")
public Integer getAvailable() {
// 设置可用数量
return available;
// 将传入的可用数量赋值给成员变量
// 设置可用数量
// 如果可用数量为空
}
// 移除有效的字段
// 返回
public void setAvailable(Integer available) {
this.available = available;
// 添加有效的字段
if(available == null){
removeValidField("available");
return;

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

Write Preview
Loading…
Cancel
Save