From 364b5bda41c7c5b11b78cbad23ad0fa346923afb Mon Sep 17 00:00:00 2001
From: unknown <2975965946@qq.com>
Date: Tue, 29 Apr 2025 22:44:23 +0800
Subject: [PATCH] src
---
src/wcp-quartz/pom.xml | 88 ++++
.../com/farm/quartz/adapter/StartSysTask.java | 206 ++++++++
.../quartz/dao/FarmQzSchedulerDaoInter.java | 73 +++
.../farm/quartz/dao/FarmQzTaskDaoInter.java | 69 +++
.../quartz/dao/FarmQzTriggerDaoInter.java | 69 +++
.../quartz/dao/impl/FarmQzSchedulerDao.java | 175 +++++++
.../farm/quartz/dao/impl/FarmQzTaskDao.java | 160 +++++++
.../quartz/dao/impl/FarmQzTriggerDao.java | 148 ++++++
.../farm/quartz/domain/FarmQzScheduler.java | 215 +++++++++
.../com/farm/quartz/domain/FarmQzTask.java | 230 +++++++++
.../com/farm/quartz/domain/FarmQzTrigger.java | 200 ++++++++
.../quartz/job/impl/CommandRuningJob.java | 94 ++++
.../server/DemoJobExecutionContext.java | 164 +++++++
.../server/FarmQzSchedulerManagerInter.java | 184 ++++++++
.../com/farm/quartz/server/QuartzInter.java | 67 +++
.../impl/FarmQzSchedulerManagerImpl.java | 441 ++++++++++++++++++
.../farm/quartz/server/impl/QuartzImpl.java | 75 +++
.../ActionFarmQzSchedulerQuery.java | 327 +++++++++++++
.../web/controller/ActionFarmQzTaskQuery.java | 217 +++++++++
.../controller/ActionFarmQzTriggerQuery.java | 286 ++++++++++++
.../src/main/resources/quartz.properties | 3 +
src/wcp-tag/pom.xml | 92 ++++
.../com/farm/doc/tag/AuditIsShowForUser.java | 76 +++
.../farm/doc/tag/DefaultIndexPageTaget.java | 87 ++++
.../com/farm/doc/tag/DelIsShowForUser.java | 54 +++
.../java/com/farm/doc/tag/DocContent.java | 97 ++++
.../java/com/farm/doc/tag/DocDescribe.java | 108 +++++
.../java/com/farm/doc/tag/DocGroupOption.java | 145 ++++++
.../main/java/com/farm/doc/tag/ImgUrl.java | 86 ++++
.../com/farm/doc/tag/NoDelIsShowForUser.java | 223 +++++++++
.../com/farm/doc/tag/NoReadIsShowForUser.java | 260 +++++++++++
.../farm/doc/tag/NoWriteIsShowForUser.java | 268 +++++++++++
.../com/farm/doc/tag/ReadIsShowForUser.java | 285 +++++++++++
.../com/farm/doc/tag/WriteIsShowForUser.java | 285 +++++++++++
.../main/java/com/farm/doc/tag/farmdoc.tld | 216 +++++++++
.../java/com/farm/wda/tag/DocWebViewUrl.java | 268 +++++++++++
.../main/java/com/farm/wda/tag/IsSupport.java | 330 +++++++++++++
.../main/java/com/farm/wda/tag/RmiServer.java | 264 +++++++++++
.../src/main/java/com/farm/wda/tag/wda.tld | 237 ++++++++++
.../com/farm/web/tag/AuthorityForUser.java | 236 ++++++++++
.../java/com/farm/web/tag/BasePathTaget.java | 257 ++++++++++
.../com/farm/web/tag/DictionaryHandle.java | 104 +++++
.../farm/web/tag/DictionaryOptionTaget.java | 93 ++++
.../farm/web/tag/ParameterEqualsTaget.java | 105 +++++
.../java/com/farm/web/tag/ParameterTaget.java | 91 ++++
.../web/tag/RunDictionaryByConstantKey.java | 127 +++++
.../com/farm/web/tag/RunDictionaryByKey.java | 88 ++++
.../com/farm/web/tag/RunDictionaryByStr.java | 115 +++++
.../java/com/farm/web/tag/TimeFormat.java | 87 ++++
.../main/java/com/farm/web/tag/UrlEncode.java | 71 +++
.../main/java/com/farm/web/tag/platForm.tld | 256 ++++++++++
51 files changed, 8502 insertions(+)
create mode 100644 src/wcp-quartz/pom.xml
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/adapter/StartSysTask.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzSchedulerDaoInter.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTaskDaoInter.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTriggerDaoInter.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzSchedulerDao.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTaskDao.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTriggerDao.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzScheduler.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTask.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTrigger.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/job/impl/CommandRuningJob.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/server/DemoJobExecutionContext.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/server/FarmQzSchedulerManagerInter.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/server/QuartzInter.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/FarmQzSchedulerManagerImpl.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/QuartzImpl.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzSchedulerQuery.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTaskQuery.java
create mode 100644 src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTriggerQuery.java
create mode 100644 src/wcp-quartz/src/main/resources/quartz.properties
create mode 100644 src/wcp-tag/pom.xml
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/AuditIsShowForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/DefaultIndexPageTaget.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/DelIsShowForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/DocContent.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/DocDescribe.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/DocGroupOption.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/ImgUrl.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/NoDelIsShowForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/NoReadIsShowForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/NoWriteIsShowForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/ReadIsShowForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/WriteIsShowForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/doc/tag/farmdoc.tld
create mode 100644 src/wcp-tag/src/main/java/com/farm/wda/tag/DocWebViewUrl.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/wda/tag/IsSupport.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/wda/tag/RmiServer.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/wda/tag/wda.tld
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/AuthorityForUser.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/BasePathTaget.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryHandle.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryOptionTaget.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/ParameterEqualsTaget.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/ParameterTaget.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByConstantKey.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByKey.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByStr.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/TimeFormat.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/UrlEncode.java
create mode 100644 src/wcp-tag/src/main/java/com/farm/web/tag/platForm.tld
diff --git a/src/wcp-quartz/pom.xml b/src/wcp-quartz/pom.xml
new file mode 100644
index 0000000..2efb2a3
--- /dev/null
+++ b/src/wcp-quartz/pom.xml
@@ -0,0 +1,88 @@
+
+
+
+
+ 4.0.0
+
+ com.farm
+
+ wcp-quartz
+
+ ${wcp.version}
+
+
+
+ 3.2.0
+
+ UTF-8
+
+ UTF-8
+
+ UTF-8
+
+
+
+
+
+ com.farm
+ farm-core
+ ${wcp.version}
+
+
+
+ javax.servlet.jsp
+ jsp-api
+
+
+
+
+
+ junit
+ junit
+ 3.8.1
+ test
+
+
+
+ org.quartz-scheduler
+ quartz
+ 2.2.1
+
+
+
+
+
+
+
+
+ maven-compiler-plugin
+
+
+
+ 1.8
+
+ 1.8
+
+
+
+
+ org.apache.maven.plugins
+ maven-jar-plugin
+ 2.1
+
+
+
+
+
+
+ true
+
+ true
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/adapter/StartSysTask.java b/src/wcp-quartz/src/main/java/com/farm/quartz/adapter/StartSysTask.java
new file mode 100644
index 0000000..65cf828
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/adapter/StartSysTask.java
@@ -0,0 +1,206 @@
+// 声明该类所在的包
+package com.farm.quartz.adapter;
+
+// 导入 ServletContext 类，用于表示 Servlet 上下文，可获取应用程序的相关信息
+import javax.servlet.ServletContext;
+
+// 导入 Apache Log4j 的 Logger 类，用于记录日志
+import org.apache.log4j.Logger;
+
+// 导入农场任务调度管理接口，用于管理任务调度相关操作
+import com.farm.quartz.server.FarmQzSchedulerManagerInter;
+// 导入 Spring 工具类，用于从 Spring 容器中获取 Bean
+import com.farm.util.spring.BeanFactory;
+// 导入 Servlet 初始化任务接口，该类需要实现此接口中的方法
+import com.farm.web.task.ServletInitJobInter;
+
+// 定义 StartSysTask 类，实现 ServletInitJobInter 接口，用于在 Servlet 初始化时执行任务
+public class StartSysTask implements ServletInitJobInter {
+ // 定义一个静态的 Logger 对象，用于记录日志，日志记录器关联到 StartSysTask 类
+ private static final Logger log = Logger.getLogger(StartSysTask.class);
+
+ // 重写接口中的 execute 方法，在 Servlet 初始化时执行
+ @Override
+ public void execute(ServletContext context) {
+ // 从 Spring 容器中获取名为 "farmQzSchedulerManagerImpl" 的 Bean，并将其强制转换为 FarmQzSchedulerManagerInter 类型
+ FarmQzSchedulerManagerInter aloneIMP = (FarmQzSchedulerManagerInter) BeanFactory
+ .getBean("farmQzSchedulerManagerImpl");
+ try {
+ // 调用任务调度管理接口的 start 方法，启动任务调度
+ aloneIMP.start();
+ // 记录日志，提示任务调度已启动
+ log.info("started '任务调度'");
+ } catch (Exception e) {
+ // 如果启动过程中出现异常，记录错误日志
+ log.error(e);
+ }
+ }
+}
+// 声明该类所在的包
+package jdk.javadoc.internal.api;
+
+// 导入所需的 Java 标准库类
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+// 导入 Java 编译器工具相关的类
+import javax.tools.DocumentationTool.DocumentationTask;
+import javax.tools.JavaFileObject;
+
+// 导入 Java 编译器内部工具相关的类
+import com.sun.tools.javac.main.Option;
+import com.sun.tools.javac.util.ClientCodeException;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Options;
+import jdk.javadoc.internal.tool.Start;
+
+/**
+ * 提供对 JDK 文档工具 javadoc 特定功能的访问。
+ */
+public class JavadocTaskImpl implements DocumentationTask {
+ // 用于标记该任务是否已经被使用过，使用 AtomicBoolean 保证线程安全
+ private final AtomicBoolean used = new AtomicBoolean();
+
+ // 存储编译上下文信息
+ private final Context context;
+ // 存储文档生成器的类对象
+ private final Class docletClass;
+ // 存储传递给 javadoc 的选项
+ private final Iterable options;
+ // 存储要处理的 Java 文件对象
+ private final Iterable fileObjects;
+ // 存储当前使用的语言环境
+ private Locale locale;
+ // 存储要添加的模块名称列表
+ private final List addModules = new ArrayList<>();
+
+ /**
+ * 构造函数，初始化 Javadoc 任务的相关属性。
+ *
+ * @param context 编译上下文
+ * @param docletClass 文档生成器的类对象
+ * @param options 传递给 javadoc 的选项
+ * @param fileObjects 要处理的 Java 文件对象
+ */
+ public JavadocTaskImpl(Context context,
+ Class docletClass,
+ Iterable options,
+ Iterable fileObjects)
+ {
+ // 初始化编译上下文
+ this.context = context;
+ // 初始化文档生成器的类对象
+ this.docletClass = docletClass;
+
+ // 如果选项为空，则使用空集合，否则检查选项中是否有 null 值
+ this.options = (options == null) ? Set.of()
+ : nullCheck(options);
+ // 如果文件对象为空，则使用空集合，否则检查文件对象中是否有 null 值
+ this.fileObjects = (fileObjects == null) ? Set.of()
+ : nullCheck(fileObjects);
+ // 设置默认语言环境
+ setLocale(Locale.getDefault());
+ }
+
+ /**
+ * 设置任务使用的语言环境。
+ *
+ * @param locale 要设置的语言环境
+ * @throws IllegalStateException 如果任务已经被使用过
+ */
+ @Override
+ public void setLocale(Locale locale) {
+ // 如果任务已经被使用过，抛出异常
+ if (used.get()) {
+ throw new IllegalStateException();
+ }
+ // 设置语言环境
+ this.locale = locale;
+ }
+
+ /**
+ * 添加要处理的模块名称。
+ *
+ * @param moduleNames 要添加的模块名称的可迭代对象
+ * @throws IllegalStateException 如果任务已经被使用过
+ */
+ @Override
+ public void addModules(Iterable moduleNames) {
+ // 检查模块名称中是否有 null 值
+ nullCheck(moduleNames);
+ // 如果任务已经被使用过，抛出异常
+ if (used.get()) {
+ throw new IllegalStateException();
+ }
+ // 遍历模块名称并添加到列表中
+ for (String name : moduleNames) {
+ addModules.add(name);
+ }
+ }
+
+ /**
+ * 执行 Javadoc 任务。
+ *
+ * @return 如果任务成功执行返回 true，否则返回 false
+ * @throws IllegalStateException 如果多次调用该方法
+ */
+ @Override
+ public Boolean call() {
+ // 如果任务已经被使用过，抛出异常
+ if (used.getAndSet(true)) {
+ throw new IllegalStateException("multiple calls to method 'call'");
+ }
+ // 初始化编译上下文
+ initContext();
+ // 创建 Start 对象来启动 Javadoc 任务
+ Start jdoc = new Start(context);
+ try {
+ // 调用 begin 方法开始生成文档
+ return jdoc.begin(docletClass, options, fileObjects);
+ } catch (ClientCodeException e) {
+ // 捕获客户端代码异常并抛出运行时异常
+ throw new RuntimeException(e.getCause());
+ }
+ }
+
+ /**
+ * 初始化编译上下文。
+ */
+ private void initContext() {
+ // 设置编译器的默认语言环境
+ context.put(Locale.class, locale);
+ // 如果有要添加的模块
+ if (!addModules.isEmpty()) {
+ // 将模块名称用逗号连接成字符串
+ String names = String.join(",", addModules);
+ // 获取编译选项实例
+ Options opts = Options.instance(context);
+ // 获取之前设置的添加模块选项
+ String prev = opts.get(Option.ADD_MODULES);
+ // 如果之前没有设置过，使用新的模块名称，否则将新的模块名称追加到之前的后面
+ opts.put(Option.ADD_MODULES, (prev == null) ? names : prev + "," + names);
+ }
+ }
+
+ /**
+ * 检查可迭代对象中的元素是否有 null 值。
+ *
+ * @param items 要检查的可迭代对象
+ * @param 可迭代对象中元素的类型
+ * @return 检查后的可迭代对象
+ * @throws NullPointerException 如果可迭代对象中有 null 值
+ */
+ private static Iterable nullCheck(Iterable items) {
+ // 遍历可迭代对象中的元素
+ for (T item : items) {
+ // 如果元素为 null，抛出空指针异常
+ if (item == null)
+ throw new NullPointerException();
+ }
+ // 返回检查后的可迭代对象
+ return items;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzSchedulerDaoInter.java b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzSchedulerDaoInter.java
new file mode 100644
index 0000000..36343a8
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzSchedulerDaoInter.java
@@ -0,0 +1,73 @@
+package com.farm.quartz.dao;
+
+import com.farm.quartz.domain.FarmQzScheduler;
+import org.hibernate.Session;
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import java.util.List;
+import java.util.Map;
+
+/**计划任务管理
+ * @author MAC_wd
+ *
+ */
+public interface FarmQzSchedulerDaoInter {
+ /** 删除一个实体
+ * @param entity 实体
+ */
+ public void deleteEntity(FarmQzScheduler entity) ;
+ /** 由id获得一个实体
+ * @param id
+ * @return
+ */
+ public FarmQzScheduler getEntity(String id) ;
+ /** 插入一条数据
+ * @param entity
+ */
+ public FarmQzScheduler insertEntity(FarmQzScheduler entity);
+ /** 获得记录数量
+ * @return
+ */
+ public int getAllListNum();
+ /**修改一个记录
+ * @param entity
+ */
+ public void editEntity(FarmQzScheduler entity);
+ /**获得一个session
+ */
+ public Session getSession();
+ /**执行一条查询语句
+ */
+ public DataResult runSqlQuery(DataQuery query);
+ /**
+ * 条件删除实体，依据对象字段值(一般不建议使用该方法)
+ *
+ * @param rules
+ * 删除条件
+ */
+ public void deleteEntitys(List rules);
+
+ /**
+ * 条件查询实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+ *
+ * @param rules
+ * 查询条件
+ * @return
+ */
+ public List selectEntitys(List rules);
+
+ /**
+ * 条件修改实体，依据对象字段值(一般不建议使用该方法)
+ *
+ * @param values
+ * 被修改的键值对
+ * @param rules
+ * 修改条件
+ */
+ public void updataEntitys(Map values, List rules);
+ /**
+ * 获得所有需要自动启动的计划任务
+ */
+ public List getAutoSchedulers();
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTaskDaoInter.java b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTaskDaoInter.java
new file mode 100644
index 0000000..b6070a7
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTaskDaoInter.java
@@ -0,0 +1,69 @@
+package com.farm.quartz.dao;
+
+import com.farm.quartz.domain.FarmQzTask;
+import org.hibernate.Session;
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import java.util.List;
+import java.util.Map;
+
+/**任务定义
+ * @author MAC_wd
+ *
+ */
+public interface FarmQzTaskDaoInter {
+ /** 删除一个实体
+ * @param entity 实体
+ */
+ public void deleteEntity(FarmQzTask entity) ;
+ /** 由id获得一个实体
+ * @param id
+ * @return
+ */
+ public FarmQzTask getEntity(String id) ;
+ /** 插入一条数据
+ * @param entity
+ */
+ public FarmQzTask insertEntity(FarmQzTask entity);
+ /** 获得记录数量
+ * @return
+ */
+ public int getAllListNum();
+ /**修改一个记录
+ * @param entity
+ */
+ public void editEntity(FarmQzTask entity);
+ /**获得一个session
+ */
+ public Session getSession();
+ /**执行一条查询语句
+ */
+ public DataResult runSqlQuery(DataQuery query);
+ /**
+ * 条件删除实体，依据对象字段值(一般不建议使用该方法)
+ *
+ * @param rules
+ * 删除条件
+ */
+ public void deleteEntitys(List rules);
+
+ /**
+ * 条件查询实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+ *
+ * @param rules
+ * 查询条件
+ * @return
+ */
+ public List selectEntitys(List rules);
+
+ /**
+ * 条件修改实体，依据对象字段值(一般不建议使用该方法)
+ *
+ * @param values
+ * 被修改的键值对
+ * @param rules
+ * 修改条件
+ */
+ public void updataEntitys(Map values, List rules);
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTriggerDaoInter.java b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTriggerDaoInter.java
new file mode 100644
index 0000000..e0f2367
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/FarmQzTriggerDaoInter.java
@@ -0,0 +1,69 @@
+package com.farm.quartz.dao;
+
+import com.farm.quartz.domain.FarmQzTrigger;
+import org.hibernate.Session;
+import com.farm.core.sql.query.DBRule;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import java.util.List;
+import java.util.Map;
+
+/**触发器定义
+ * @author MAC_wd
+ *
+ */
+public interface FarmQzTriggerDaoInter {
+ /** 删除一个实体
+ * @param entity 实体
+ */
+ public void deleteEntity(FarmQzTrigger entity) ;
+ /** 由id获得一个实体
+ * @param id
+ * @return
+ */
+ public FarmQzTrigger getEntity(String id) ;
+ /** 插入一条数据
+ * @param entity
+ */
+ public FarmQzTrigger insertEntity(FarmQzTrigger entity);
+ /** 获得记录数量
+ * @return
+ */
+ public int getAllListNum();
+ /**修改一个记录
+ * @param entity
+ */
+ public void editEntity(FarmQzTrigger entity);
+ /**获得一个session
+ */
+ public Session getSession();
+ /**执行一条查询语句
+ */
+ public DataResult runSqlQuery(DataQuery query);
+ /**
+ * 条件删除实体，依据对象字段值(一般不建议使用该方法)
+ *
+ * @param rules
+ * 删除条件
+ */
+ public void deleteEntitys(List rules);
+
+ /**
+ * 条件查询实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+ *
+ * @param rules
+ * 查询条件
+ * @return
+ */
+ public List selectEntitys(List rules);
+
+ /**
+ * 条件修改实体，依据对象字段值(一般不建议使用该方法)
+ *
+ * @param values
+ * 被修改的键值对
+ * @param rules
+ * 修改条件
+ */
+ public void updataEntitys(Map values, List rules);
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzSchedulerDao.java b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzSchedulerDao.java
new file mode 100644
index 0000000..9b74de5
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzSchedulerDao.java
@@ -0,0 +1,175 @@
+// 声明该类所在的包
+package com.farm.quartz.dao.impl;
+
+// 导入 BigInteger 类，用于处理大整数，通常用于数据库查询中获取计数值
+import java.math.BigInteger;
+
+// 导入 Hibernate 的 Query 类，用于执行 HQL（Hibernate Query Language）查询
+import org.hibernate.Query;
+// 导入 Hibernate 的 SQLQuery 类，用于执行原生 SQL 查询
+import org.hibernate.SQLQuery;
+// 导入 Hibernate 的 Session 类，代表与数据库的一次会话，用于执行数据库操作
+import org.hibernate.Session;
+// 导入 Hibernate 的 SessionFactory 类，用于创建 Session 对象
+import org.hibernate.SessionFactory;
+// 导入 Spring 的 Repository 注解，用于将该类标记为数据访问层组件
+import org.springframework.stereotype.Repository;
+
+// 导入农场任务调度数据访问接口，该类需要实现此接口中的方法
+import com.farm.quartz.dao.FarmQzSchedulerDaoInter;
+// 导入农场任务调度实体类，代表数据库中的任务调度表记录
+import com.farm.quartz.domain.FarmQzScheduler;
+// 导入数据库规则类，用于定义数据库查询或操作的规则
+import com.farm.core.sql.query.DBRule;
+// 导入数据查询类，用于构建和执行数据库查询
+import com.farm.core.sql.query.DataQuery;
+// 导入数据结果类，用于处理查询返回的结果
+import com.farm.core.sql.result.DataResult;
+// 导入 Hibernate SQL 工具类，该类继承自该工具类
+import com.farm.core.sql.utils.HibernateSQLTools;
+
+// 导入 List 接口，用于定义列表类型的变量
+import java.util.List;
+// 导入 Map 接口，用于定义映射类型的变量
+import java.util.Map;
+
+// 导入资源注入注解，用于将 Spring 容器中的 Bean 注入到该类的成员变量中
+import javax.annotation.Resource;
+
+/**
+ * 计划任务管理
+ *
+ * @author MAC_wd
+ */
+// 使用 @Repository 注解将该类标记为 Spring 数据访问层组件
+@Repository
+// 定义 FarmQzSchedulerDao 类，继承自 HibernateSQLTools 并实现 FarmQzSchedulerDaoInter 接口
+public class FarmQzSchedulerDao extends HibernateSQLTools
+ implements FarmQzSchedulerDaoInter {
+ // 使用 @Resource 注解注入 SessionFactory 类型的 Bean，名称为 "sessionFactory"
+ @Resource(name = "sessionFactory")
+ private SessionFactory sessionFatory;
+
+ // 删除任务调度实体的方法
+ public void deleteEntity(FarmQzScheduler entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 delete 方法删除实体
+ session.delete(entity);
+ }
+
+ // 获取所有任务调度记录数量的方法
+ public int getAllListNum() {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 创建一个原生 SQL 查询，查询 farm_qz_scheduler 表的记录数量
+ SQLQuery sqlquery = session
+ .createSQLQuery("select count(*) from farm_qz_scheduler");
+ // 执行查询并获取结果列表，取第一个元素并转换为 BigInteger 类型
+ BigInteger num = (BigInteger) sqlquery.list().get(0);
+ // 将 BigInteger 类型的结果转换为 int 类型并返回
+ return num.intValue();
+ }
+
+ // 根据 ID 获取任务调度实体的方法
+ public FarmQzScheduler getEntity(String id) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 get 方法，根据 ID 和实体类类型获取实体对象并返回
+ return (FarmQzScheduler) session.get(FarmQzScheduler.class, id);
+ }
+
+ // 插入任务调度实体的方法
+ public FarmQzScheduler insertEntity(FarmQzScheduler entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 save 方法保存实体
+ session.save(entity);
+ // 返回保存后的实体
+ return entity;
+ }
+
+ // 编辑任务调度实体的方法
+ public void editEntity(FarmQzScheduler entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 update 方法更新实体
+ session.update(entity);
+ }
+
+ // 重写获取 Session 对象的方法
+ @Override
+ public Session getSession() {
+ // 从 SessionFactory 中获取当前的 Session 对象并返回
+ return sessionFatory.getCurrentSession();
+ }
+
+ // 运行 SQL 查询的方法
+ public DataResult runSqlQuery(DataQuery query) {
+ try {
+ // 调用 DataQuery 的 search 方法，传入当前 Session 对象执行查询，并返回查询结果
+ return query.search(sessionFatory.getCurrentSession());
+ } catch (Exception e) {
+ // 如果查询过程中出现异常，返回 null
+ return null;
+ }
+ }
+
+ // 根据规则删除实体的方法
+ @Override
+ public void deleteEntitys(List rules) {
+ // 调用父类的 deleteSqlFromFunction 方法，传入当前 Session 对象和规则列表执行删除操作
+ deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+ }
+
+ // 根据规则查询实体列表的方法
+ @Override
+ public List selectEntitys(List rules) {
+ // 调用父类的 selectSqlFromFunction 方法，传入当前 Session 对象和规则列表执行查询，并返回查询结果列表
+ return selectSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+ }
+
+ // 根据规则更新实体的方法
+ @Override
+ public void updataEntitys(Map values, List rules) {
+ // 调用父类的 updataSqlFromFunction 方法，传入当前 Session 对象、更新值映射和规则列表执行更新操作
+ updataSqlFromFunction(sessionFatory.getCurrentSession(), values, rules);
+ }
+
+ // 获取 SessionFactory 对象的方法
+ public SessionFactory getSessionFatory() {
+ return sessionFatory;
+ }
+
+ // 设置 SessionFactory 对象的方法
+ public void setSessionFatory(SessionFactory sessionFatory) {
+ this.sessionFatory = sessionFatory;
+ }
+
+ // 获取自动调度任务列表的方法
+ @SuppressWarnings("unchecked")
+ @Override
+ public List getAutoSchedulers() {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 创建一个 HQL 查询，查询 AUTOIS 字段为 "1" 的任务调度实体
+ Query query = session
+ .createQuery("from FarmQzScheduler where AUTOIS=?");
+ // 设置查询参数，将第一个参数设置为 "1"
+ query.setString(0, "1");
+ // 执行查询并返回结果列表
+ return query.list();
+ }
+
+ // 重写获取 SessionFactory 对象的方法，供父类使用
+ @Override
+ protected SessionFactory getSessionFactory() {
+ return sessionFatory;
+ }
+
+ // 重写获取实体类类型的方法，供父类使用
+ @Override
+ protected Class getTypeClass() {
+ return FarmQzScheduler.class;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTaskDao.java b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTaskDao.java
new file mode 100644
index 0000000..83536dd
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTaskDao.java
@@ -0,0 +1,160 @@
+// 声明该类所属的包
+package com.farm.quartz.dao.impl;
+
+// 导入 BigInteger 类，用于处理大整数，通常在数据库查询中用于存储和操作计数结果
+import java.math.BigInteger;
+
+// 导入 Hibernate 的 SQLQuery 类，用于执行原生 SQL 查询语句
+import org.hibernate.SQLQuery;
+// 导入 Hibernate 的 Session 类，代表与数据库的一次会话，可用于执行数据库操作
+import org.hibernate.Session;
+// 导入 Hibernate 的 SessionFactory 类，用于创建和管理 Session 对象
+import org.hibernate.SessionFactory;
+// 导入 Spring 的 Repository 注解，将该类标记为数据访问层组件，由 Spring 进行管理
+import org.springframework.stereotype.Repository;
+
+// 导入农场任务调度任务数据访问接口，该类需要实现此接口中的方法
+import com.farm.quartz.dao.FarmQzTaskDaoInter;
+// 导入农场任务调度器实体类，虽在本类未直接使用，但可能与相关业务逻辑有潜在关联
+import com.farm.quartz.domain.FarmQzScheduler;
+// 导入农场任务调度任务实体类，代表数据库中任务相关的数据记录
+import com.farm.quartz.domain.FarmQzTask;
+// 导入数据库规则类，用于定义数据库查询或操作的规则条件
+import com.farm.core.sql.query.DBRule;
+// 导入数据查询类，用于构建和执行数据库查询操作
+import com.farm.core.sql.query.DataQuery;
+// 导入数据结果类，用于存储和处理数据库查询返回的结果
+import com.farm.core.sql.result.DataResult;
+// 导入 Hibernate SQL 工具类，该类继承自该工具类，可使用其提供的数据库操作方法
+import com.farm.core.sql.utils.HibernateSQLTools;
+
+// 导入 List 接口，用于定义列表类型的变量，存储多个元素
+import java.util.List;
+// 导入 Map 接口，用于定义键值对映射类型的变量
+import java.util.Map;
+
+// 导入资源注入注解，用于将 Spring 容器中的 Bean 注入到该类的成员变量中
+import javax.annotation.Resource;
+
+/**
+ * 任务定义
+ *
+ * @author MAC_wd
+ */
+// 使用 @Repository 注解将该类标记为 Spring 数据访问层组件
+@Repository
+// 定义 FarmQzTaskDao 类，继承自 HibernateSQLTools 并实现 FarmQzTaskDaoInter 接口
+public class FarmQzTaskDao extends HibernateSQLTools implements
+ FarmQzTaskDaoInter {
+ // 使用 @Resource 注解注入 SessionFactory 类型的 Bean，名称为 "sessionFactory"
+ @Resource(name = "sessionFactory")
+ private SessionFactory sessionFatory;
+
+ // 删除任务实体的方法
+ public void deleteEntity(FarmQzTask entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 delete 方法，从数据库中删除该任务实体
+ session.delete(entity);
+ }
+
+ // 获取所有任务记录数量的方法
+ public int getAllListNum() {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 创建一个原生 SQL 查询，查询 farm_qz_task 表中的记录数量
+ SQLQuery sqlquery = session
+ .createSQLQuery("select count(*) from farm_qz_task");
+ // 执行查询并获取结果列表，取第一个元素并将其转换为 BigInteger 类型
+ BigInteger num = (BigInteger) sqlquery.list().get(0);
+ // 将 BigInteger 类型的结果转换为 int 类型并返回
+ return num.intValue();
+ }
+
+ // 根据任务 ID 获取任务实体的方法
+ public FarmQzTask getEntity(String id) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 get 方法，根据任务 ID 和任务实体类类型获取对应的任务实体对象
+ return (FarmQzTask) session.get(FarmQzTask.class, id);
+ }
+
+ // 插入新任务实体的方法
+ public FarmQzTask insertEntity(FarmQzTask entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 save 方法，将新的任务实体保存到数据库中
+ session.save(entity);
+ // 返回保存后的任务实体
+ return entity;
+ }
+
+ // 编辑任务实体的方法
+ public void editEntity(FarmQzTask entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 update 方法，更新数据库中该任务实体的信息
+ session.update(entity);
+ }
+
+ // 重写获取 Session 对象的方法
+ @Override
+ public Session getSession() {
+ // 从 SessionFactory 中获取当前的 Session 对象并返回
+ return sessionFatory.getCurrentSession();
+ }
+
+ // 执行 SQL 查询的方法
+ public DataResult runSqlQuery(DataQuery query) {
+ try {
+ // 调用 DataQuery 的 search 方法，传入当前的 Session 对象执行查询操作，并返回查询结果
+ return query.search(sessionFatory.getCurrentSession());
+ } catch (Exception e) {
+ // 如果查询过程中出现异常，返回 null
+ return null;
+ }
+ }
+
+ // 根据规则删除多个任务实体的方法
+ @Override
+ public void deleteEntitys(List rules) {
+ // 调用父类的 deleteSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行删除操作
+ deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+ }
+
+ // 根据规则查询多个任务实体的方法
+ @Override
+ public List selectEntitys(List rules) {
+ // 调用父类的 selectSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行查询操作并返回查询结果列表
+ return selectSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+ }
+
+ // 根据规则更新多个任务实体的方法
+ @Override
+ public void updataEntitys(Map values, List rules) {
+ // 调用父类的 updataSqlFromFunction 方法，传入当前的 Session 对象、更新值映射和规则列表，执行更新操作
+ updataSqlFromFunction(sessionFatory.getCurrentSession(), values, rules);
+ }
+
+ // 获取 SessionFactory 对象的方法
+ public SessionFactory getSessionFatory() {
+ return sessionFatory;
+ }
+
+ // 设置 SessionFactory 对象的方法
+ public void setSessionFatory(SessionFactory sessionFatory) {
+ this.sessionFatory = sessionFatory;
+ }
+
+ // 重写获取 SessionFactory 对象的方法，供父类相关方法使用
+ @Override
+ protected SessionFactory getSessionFactory() {
+ return sessionFatory;
+ }
+
+ // 重写获取实体类类型的方法，供父类相关方法使用
+ @Override
+ protected Class getTypeClass() {
+ return FarmQzTask.class;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTriggerDao.java b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTriggerDao.java
new file mode 100644
index 0000000..9833584
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/dao/impl/FarmQzTriggerDao.java
@@ -0,0 +1,148 @@
+// 声明该类所在的包
+package com.farm.quartz.dao.impl;
+
+// 导入 BigInteger 类，用于处理大整数，这里主要用于接收数据库中 count(*) 函数返回的结果
+import java.math.BigInteger;
+
+// 导入 Hibernate 的 SQLQuery 类，用于执行原生 SQL 查询
+import org.hibernate.SQLQuery;
+// 导入 Hibernate 的 Session 类，它代表与数据库的一次会话，可进行数据库操作
+import org.hibernate.Session;
+// 导入 Hibernate 的 SessionFactory 类，用于创建和管理 Session 对象
+import org.hibernate.SessionFactory;
+// 导入 Spring 的 Repository 注解，将该类标记为数据访问层组件，便于 Spring 管理
+import org.springframework.stereotype.Repository;
+
+// 导入触发器数据访问接口，该类需要实现此接口中的方法
+import com.farm.quartz.dao.FarmQzTriggerDaoInter;
+// 导入触发器实体类，代表数据库中触发器相关的数据记录
+import com.farm.quartz.domain.FarmQzTrigger;
+// 导入数据库规则类，用于定义数据库查询或操作的规则条件
+import com.farm.core.sql.query.DBRule;
+// 导入数据查询类，用于构建和执行数据库查询
+import com.farm.core.sql.query.DataQuery;
+// 导入数据结果类，用于处理数据库查询返回的结果
+import com.farm.core.sql.result.DataResult;
+// 导入 Hibernate SQL 工具类，该类继承自该工具类，可复用其数据库操作相关方法
+import com.farm.core.sql.utils.HibernateSQLTools;
+
+// 导入 List 接口，用于定义存储多个元素的列表
+import java.util.List;
+// 导入 Map 接口，用于定义键值对映射
+import java.util.Map;
+
+// 导入资源注入注解，用于将 Spring 容器中的 Bean 注入到该类的成员变量中
+import javax.annotation.Resource;
+
+/**
+ * 触发器定义
+ *
+ * @author MAC_wd
+ */
+// 使用 @Repository 注解将该类标记为 Spring 数据访问层组件
+@Repository
+// 定义 FarmQzTriggerDao 类，继承自 HibernateSQLTools 并实现 FarmQzTriggerDaoInter 接口
+public class FarmQzTriggerDao extends HibernateSQLTools
+ implements FarmQzTriggerDaoInter {
+ // 使用 @Resource 注解注入 SessionFactory 类型的 Bean，名称为 "sessionFactory"
+ @Resource(name = "sessionFactory")
+ private SessionFactory sessionFatory;
+
+ // 删除触发器实体的方法
+ public void deleteEntity(FarmQzTrigger entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 delete 方法，将该触发器实体从数据库中删除
+ session.delete(entity);
+ }
+
+ // 获取所有触发器记录数量的方法
+ public int getAllListNum() {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 创建一个原生 SQL 查询，用于统计 farm_qz_trigger 表中的记录数量
+ SQLQuery sqlquery = session
+ .createSQLQuery("select count(*) from farm_qz_trigger");
+ // 执行查询并获取结果列表，取第一个元素并将其转换为 BigInteger 类型
+ BigInteger num = (BigInteger) sqlquery.list().get(0);
+ // 将 BigInteger 类型的结果转换为 int 类型并返回
+ return num.intValue();
+ }
+
+ // 根据触发器 ID 获取触发器实体的方法
+ public FarmQzTrigger getEntity(String id) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 get 方法，根据触发器 ID 和触发器实体类类型获取对应的触发器实体对象
+ return (FarmQzTrigger) session.get(FarmQzTrigger.class, id);
+ }
+
+ // 插入新触发器实体的方法
+ public FarmQzTrigger insertEntity(FarmQzTrigger entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 save 方法，将新的触发器实体保存到数据库中
+ session.save(entity);
+ // 返回保存后的触发器实体
+ return entity;
+ }
+
+ // 编辑触发器实体的方法
+ public void editEntity(FarmQzTrigger entity) {
+ // 从 SessionFactory 中获取当前的 Session 对象
+ Session session = sessionFatory.getCurrentSession();
+ // 调用 Session 的 update 方法，更新数据库中该触发器实体的信息
+ session.update(entity);
+ }
+
+ // 重写获取 Session 对象的方法
+ @Override
+ public Session getSession() {
+ // 从 SessionFactory 中获取当前的 Session 对象并返回
+ return sessionFatory.getCurrentSession();
+ }
+
+ // 执行 SQL 查询的方法
+ public DataResult runSqlQuery(DataQuery query) {
+ try {
+ // 调用 DataQuery 的 search 方法，传入当前的 Session 对象执行查询操作，并返回查询结果
+ return query.search(sessionFatory.getCurrentSession());
+ } catch (Exception e) {
+ // 如果查询过程中出现异常，返回 null
+ return null;
+ }
+ }
+
+ // 根据规则删除多个触发器实体的方法
+ @Override
+ public void deleteEntitys(List rules) {
+ // 调用父类的 deleteSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行删除操作
+ deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+ }
+
+ // 根据规则查询多个触发器实体的方法
+ @Override
+ public List selectEntitys(List rules) {
+ // 调用父类的 selectSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行查询操作并返回查询结果列表
+ return selectSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+ }
+
+ // 根据规则更新多个触发器实体的方法
+ @Override
+ public void updataEntitys(Map values, List rules) {
+ // 调用父类的 updataSqlFromFunction 方法，传入当前的 Session 对象、更新值映射和规则列表，执行更新操作
+ updataSqlFromFunction(sessionFatory.getCurrentSession(), values, rules);
+ }
+
+ // 重写获取 SessionFactory 对象的方法，供父类相关方法使用
+ @Override
+ protected SessionFactory getSessionFactory() {
+ return sessionFatory;
+ }
+
+ // 重写获取实体类类型的方法，供父类相关方法使用
+ @Override
+ protected Class getTypeClass() {
+ return FarmQzTrigger.class;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzScheduler.java b/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzScheduler.java
new file mode 100644
index 0000000..561cf34
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzScheduler.java
@@ -0,0 +1,215 @@
+// 声明该类所属的包
+package com.farm.quartz.domain;
+
+// 导入 JPA 用于映射数据库列的注解
+import javax.persistence.Column;
+// 导入 JPA 用于将类标记为实体类的注解
+import javax.persistence.Entity;
+// 导入 JPA 用于指定主键生成方式的注解
+import javax.persistence.GeneratedValue;
+// 导入 JPA 用于标记主键字段的注解
+import javax.persistence.Id;
+// 导入 JPA 用于指定实体对应的数据库表名的注解
+import javax.persistence.Table;
+
+// 导入 Hibernate 自定义主键生成器的注解
+import org.hibernate.annotations.GenericGenerator;
+
+/**
+ * FarmQzScheduler 实体类。由 MyEclipse Persistence Tools 工具生成。
+ */
+// 使用 @Entity 注解将该类标记为 JPA 实体类，并指定实体名称
+@Entity(name = "FarmQzScheduler")
+// 使用 @Table 注解指定该实体对应的数据库表名
+@Table(name = "farm_qz_scheduler")
+// 让该类实现 Serializable 接口，以便对象可以被序列化和反序列化
+public class FarmQzScheduler implements java.io.Serializable {
+ // 定义类的静态常量 serialVersionUID，用于序列化版本控制，确保在反序列化时类的结构兼容性，这里设置为 1
+ private static final long serialVersionUID = 1L;
+
+ // 使用 @Id 注解标记该字段为主键
+ @Id
+ // 定义一个名为 "systemUUID" 的主键生成器，采用 "uuid" 策略生成 UUID 作为主键值
+ @GenericGenerator(name = "systemUUID", strategy = "uuid")
+ // 指定使用 "systemUUID" 生成器来生成主键值
+ @GeneratedValue(generator = "systemUUID")
+ // 映射数据库中的 "ID" 列，指定列的长度为 32，允许插入、更新操作，且该列不能为空
+ @Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+ // 声明一个字符串类型的成员变量 id，用于存储实体的唯一标识符
+ private String id;
+
+ // 映射数据库中的 "TRIGGERID" 列，指定列的长度为 32，该列不能为空
+ @Column(name = "TRIGGERID", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 triggerid，用于存储关联的触发器 ID
+ private String triggerid;
+
+ // 映射数据库中的 "TASKID" 列，指定列的长度为 32，该列不能为空
+ @Column(name = "TASKID", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 taskid，用于存储关联的任务 ID
+ private String taskid;
+
+ // 映射数据库中的 "PCONTENT" 列，指定列的长度为 128
+ @Column(name = "PCONTENT", length = 128)
+ // 声明一个字符串类型的成员变量 pcontent，可能用于存储调度相关的内容
+ private String pcontent;
+
+ // 映射数据库中的 "EUSER" 列，指定列的长度为 32，该列不能为空
+ @Column(name = "EUSER", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 euser，可能用于存储编辑用户信息
+ private String euser;
+
+ // 映射数据库中的 "PSTATE" 列，指定列的长度为 2，该列不能为空
+ @Column(name = "PSTATE", length = 2, nullable = false)
+ // 声明一个字符串类型的成员变量 pstate，可能用于存储调度状态
+ private String pstate;
+
+ // 映射数据库中的 "AUTOIS" 列，指定列的长度为 2，该列不能为空
+ @Column(name = "AUTOIS", length = 2, nullable = false)
+ // 声明一个字符串类型的成员变量 autois，可能用于存储是否自动调度的标识
+ private String autois;
+
+ // 映射数据库中的 "CTIME" 列，指定列的长度为 16，该列不能为空
+ @Column(name = "CTIME", length = 16, nullable = false)
+ // 声明一个字符串类型的成员变量 ctime，用于存储创建时间
+ private String ctime;
+
+ // 映射数据库中的 "ETIME" 列，指定列的长度为 16，该列不能为空
+ @Column(name = "ETIME", length = 16, nullable = false)
+ // 声明一个字符串类型的成员变量 etime，用于存储编辑时间
+ private String etime;
+
+ // 映射数据库中的 "CUSERNAME" 列，指定列的长度为 64，该列不能为空
+ @Column(name = "CUSERNAME", length = 64, nullable = false)
+ // 声明一个字符串类型的成员变量 cusername，用于存储创建用户的名称
+ private String cusername;
+
+ // 映射数据库中的 "EUSERNAME" 列，指定列的长度为 64，该列不能为空
+ @Column(name = "EUSERNAME", length = 64, nullable = false)
+ // 声明一个字符串类型的成员变量 eusername，用于存储编辑用户的名称
+ private String eusername;
+
+ // 映射数据库中的 "CUSER" 列，指定列的长度为 32，该列不能为空
+ @Column(name = "CUSER", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 cuser，用于存储创建用户的 ID
+ private String cuser;
+
+ // 获取关联的触发器 ID 的方法
+ public String getTriggerid() {
+ return this.triggerid;
+ }
+
+ // 设置关联的触发器 ID 的方法
+ public void setTriggerid(String triggerid) {
+ this.triggerid = triggerid;
+ }
+
+ // 获取关联的任务 ID 的方法
+ public String getTaskid() {
+ return this.taskid;
+ }
+
+ // 设置关联的任务 ID 的方法
+ public void setTaskid(String taskid) {
+ this.taskid = taskid;
+ }
+
+ // 获取调度相关内容的方法
+ public String getPcontent() {
+ return this.pcontent;
+ }
+
+ // 设置调度相关内容的方法
+ public void setPcontent(String pcontent) {
+ this.pcontent = pcontent;
+ }
+
+ // 获取编辑用户信息的方法
+ public String getEuser() {
+ return this.euser;
+ }
+
+ // 设置编辑用户信息的方法
+ public void setEuser(String euser) {
+ this.euser = euser;
+ }
+
+ // 获取调度状态的方法
+ public String getPstate() {
+ return this.pstate;
+ }
+
+ // 设置调度状态的方法
+ public void setPstate(String pstate) {
+ this.pstate = pstate;
+ }
+
+ // 获取是否自动调度标识的方法
+ public String getAutois() {
+ return this.autois;
+ }
+
+ // 设置是否自动调度标识的方法
+ public void setAutois(String autois) {
+ this.autois = autois;
+ }
+
+ // 获取创建时间的方法
+ public String getCtime() {
+ return this.ctime;
+ }
+
+ // 设置创建时间的方法
+ public void setCtime(String ctime) {
+ this.ctime = ctime;
+ }
+
+ // 获取编辑时间的方法
+ public String getEtime() {
+ return this.etime;
+ }
+
+ // 设置编辑时间的方法
+ public void setEtime(String etime) {
+ this.etime = etime;
+ }
+
+ // 获取创建用户名称的方法
+ public String getCusername() {
+ return this.cusername;
+ }
+
+ // 设置创建用户名称的方法
+ public void setCusername(String cusername) {
+ this.cusername = cusername;
+ }
+
+ // 获取编辑用户名称的方法
+ public String getEusername() {
+ return this.eusername;
+ }
+
+ // 设置编辑用户名称的方法
+ public void setEusername(String eusername) {
+ this.eusername = eusername;
+ }
+
+ // 获取创建用户 ID 的方法
+ public String getCuser() {
+ return this.cuser;
+ }
+
+ // 设置创建用户 ID 的方法
+ public void setCuser(String cuser) {
+ this.cuser = cuser;
+ }
+
+ // 获取实体唯一标识符的方法
+ public String getId() {
+ return this.id;
+ }
+
+ // 设置实体唯一标识符的方法
+ public void setId(String id) {
+ this.id = id;
+ }
+}}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTask.java b/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTask.java
new file mode 100644
index 0000000..b3fac0b
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTask.java
@@ -0,0 +1,230 @@
+// 声明该类所在的包
+package com.farm.quartz.domain;
+
+// 导入 JPA 中用于映射数据库列的注解
+import javax.persistence.Column;
+// 导入 JPA 中用于将类标记为实体类的注解
+import javax.persistence.Entity;
+// 导入 JPA 中用于指定主键生成策略的注解
+import javax.persistence.GeneratedValue;
+// 导入 JPA 中用于标记主键字段的注解
+import javax.persistence.Id;
+// 导入 JPA 中用于指定实体对应的数据库表名的注解
+import javax.persistence.Table;
+
+// 导入 Hibernate 提供的自定义主键生成器注解
+import org.hibernate.annotations.GenericGenerator;
+
+/**
+ * FarmQzTask 实体类。该类由 MyEclipse Persistence Tools 工具生成，用于映射数据库中的 farm_qz_task 表。
+ */
+// 使用 @Entity 注解将该类标记为 JPA 实体类，并指定实体名称为 "FarmQzTask"
+@Entity(name = "FarmQzTask")
+// 使用 @Table 注解指定该实体对应的数据库表名为 "farm_qz_task"
+@Table(name = "farm_qz_task")
+// 实现 Serializable 接口，表明该类的对象可以被序列化和反序列化，方便在网络传输或持久化存储时使用
+public class FarmQzTask implements java.io.Serializable {
+ // 定义序列化版本号，确保在序列化和反序列化过程中类的版本一致性
+ private static final long serialVersionUID = 1L;
+
+ // 使用 @Id 注解标记该字段为主键
+ @Id
+ // 定义一个名为 "systemUUID" 的自定义主键生成器，使用 "uuid" 策略生成 UUID 作为主键值
+ @GenericGenerator(name = "systemUUID", strategy = "uuid")
+ // 指定使用上面定义的 "systemUUID" 生成器来生成主键值
+ @GeneratedValue(generator = "systemUUID")
+ // 使用 @Column 注解将该字段映射到数据库表的 "ID" 列，指定列的长度为 32，允许插入和更新操作，且该列不能为空
+ @Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+ // 声明一个字符串类型的成员变量 id，用于存储该实体的唯一标识符
+ private String id;
+
+ // 将该字段映射到数据库表的 "JOBKEY" 列，指定列的长度为 128，且该列不能为空
+ @Column(name = "JOBKEY", length = 128, nullable = false)
+ // 声明一个字符串类型的成员变量 jobkey，可能用于标识任务的关键信息
+ private String jobkey;
+
+ // 将该字段映射到数据库表的 "JOBPARAS" 列，指定列的长度为 1024
+ @Column(name = "JOBPARAS", length = 1024)
+ // 声明一个字符串类型的成员变量 jobparas，可能用于存储任务的参数信息
+ private String jobparas;
+
+ // 将该字段映射到数据库表的 "NAME" 列，指定列的长度为 128，且该列不能为空
+ @Column(name = "NAME", length = 128, nullable = false)
+ // 声明一个字符串类型的成员变量 name，用于存储任务的名称
+ private String name;
+
+ // 将该字段映射到数据库表的 "JOBCLASS" 列，指定列的长度为 128，且该列不能为空
+ @Column(name = "JOBCLASS", length = 128, nullable = false)
+ // 声明一个字符串类型的成员变量 jobclass，可能用于存储任务对应的类名
+ private String jobclass;
+
+ // 将该字段映射到数据库表的 "CUSERNAME" 列，指定列的长度为 64，且该列不能为空
+ @Column(name = "CUSERNAME", length = 64, nullable = false)
+ // 声明一个字符串类型的成员变量 cusername，用于存储创建任务的用户名称
+ private String cusername;
+
+ // 将该字段映射到数据库表的 "CUSER" 列，指定列的长度为 32，且该列不能为空
+ @Column(name = "CUSER", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 cuser，用于存储创建任务的用户 ID
+ private String cuser;
+
+ // 将该字段映射到数据库表的 "EUSERNAME" 列，指定列的长度为 64，且该列不能为空
+ @Column(name = "EUSERNAME", length = 64, nullable = false)
+ // 声明一个字符串类型的成员变量 eusername，用于存储编辑任务的用户名称
+ private String eusername;
+
+ // 将该字段映射到数据库表的 "EUSER" 列，指定列的长度为 32，且该列不能为空
+ @Column(name = "EUSER", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 euser，用于存储编辑任务的用户 ID
+ private String euser;
+
+ // 将该字段映射到数据库表的 "PSTATE" 列，指定列的长度为 2，且该列不能为空
+ @Column(name = "PSTATE", length = 2, nullable = false)
+ // 声明一个字符串类型的成员变量 pstate，可能用于存储任务的状态信息
+ private String pstate;
+
+ // 将该字段映射到数据库表的 "PCONTENT" 列，指定列的长度为 128
+ @Column(name = "PCONTENT", length = 128)
+ // 声明一个字符串类型的成员变量 pcontent，可能用于存储任务的相关描述内容
+ private String pcontent;
+
+ // 将该字段映射到数据库表的 "CTIME" 列，指定列的长度为 16，且该列不能为空
+ @Column(name = "CTIME", length = 16, nullable = false)
+ // 声明一个字符串类型的成员变量 ctime，用于存储任务的创建时间
+ private String ctime;
+
+ // 将该字段映射到数据库表的 "ETIME" 列，指定列的长度为 16，且该列不能为空
+ @Column(name = "ETIME", length = 16, nullable = false)
+ // 声明一个字符串类型的成员变量 etime，用于存储任务的编辑时间
+ private String etime;
+
+ // 获取任务关键信息的方法
+ public String getJobkey() {
+ return this.jobkey;
+ }
+
+ // 设置任务关键信息的方法
+ public void setJobkey(String jobkey) {
+ this.jobkey = jobkey;
+ }
+
+ // 获取任务参数信息的方法
+ public String getJobparas() {
+ return this.jobparas;
+ }
+
+ // 设置任务参数信息的方法
+ public void setJobparas(String jobparas) {
+ this.jobparas = jobparas;
+ }
+
+ // 获取任务名称的方法
+ public String getName() {
+ return this.name;
+ }
+
+ // 设置任务名称的方法
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ // 获取任务对应类名的方法
+ public String getJobclass() {
+ return this.jobclass;
+ }
+
+ // 设置任务对应类名的方法
+ public void setJobclass(String jobclass) {
+ this.jobclass = jobclass;
+ }
+
+ // 获取创建任务的用户名称的方法
+ public String getCusername() {
+ return this.cusername;
+ }
+
+ // 设置创建任务的用户名称的方法
+ public void setCusername(String cusername) {
+ this.cusername = cusername;
+ }
+
+ // 获取创建任务的用户 ID 的方法
+ public String getCuser() {
+ return this.cuser;
+ }
+
+ // 设置创建任务的用户 ID 的方法
+ public void setCuser(String cuser) {
+ this.cuser = cuser;
+ }
+
+ // 获取编辑任务的用户名称的方法
+ public String getEusername() {
+ return this.eusername;
+ }
+
+ // 设置编辑任务的用户名称的方法
+ public void setEusername(String eusername) {
+ this.eusername = eusername;
+ }
+
+ // 获取编辑任务的用户 ID 的方法
+ public String getEuser() {
+ return this.euser;
+ }
+
+ // 设置编辑任务的用户 ID 的方法
+ public void setEuser(String euser) {
+ this.euser = euser;
+ }
+
+ // 获取任务状态信息的方法
+ public String getPstate() {
+ return this.pstate;
+ }
+
+ // 设置任务状态信息的方法
+ public void setPstate(String pstate) {
+ this.pstate = pstate;
+ }
+
+ // 获取任务相关描述内容的方法
+ public String getPcontent() {
+ return this.pcontent;
+ }
+
+ // 设置任务相关描述内容的方法
+ public void setPcontent(String pcontent) {
+ this.pcontent = pcontent;
+ }
+
+ // 获取任务创建时间的方法
+ public String getCtime() {
+ return this.ctime;
+ }
+
+ // 设置任务创建时间的方法
+ public void setCtime(String ctime) {
+ this.ctime = ctime;
+ }
+
+ // 获取任务编辑时间的方法
+ public String getEtime() {
+ return this.etime;
+ }
+
+ // 设置任务编辑时间的方法
+ public void setEtime(String etime) {
+ this.etime = etime;
+ }
+
+ // 获取任务唯一标识符的方法
+ public String getId() {
+ return this.id;
+ }
+
+ // 设置任务唯一标识符的方法
+ public void setId(String id) {
+ this.id = id;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTrigger.java b/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTrigger.java
new file mode 100644
index 0000000..373fdf4
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/domain/FarmQzTrigger.java
@@ -0,0 +1,200 @@
+// 声明该类所属的包
+package com.farm.quartz.domain;
+
+// 导入 JPA 用于映射数据库列的注解
+import javax.persistence.Column;
+// 导入 JPA 用于将类标记为实体类的注解
+import javax.persistence.Entity;
+// 导入 JPA 用于指定主键生成方式的注解
+import javax.persistence.GeneratedValue;
+// 导入 JPA 用于标记主键字段的注解
+import javax.persistence.Id;
+// 导入 JPA 用于指定实体对应的数据库表名的注解
+import javax.persistence.Table;
+
+// 导入 Hibernate 自定义主键生成器的注解
+import org.hibernate.annotations.GenericGenerator;
+
+/**
+ * FarmQzTrigger 实体类。由 MyEclipse Persistence Tools 工具生成
+ */
+// 使用 @Entity 注解将该类标记为 JPA 实体类，并指定实体名称
+@Entity(name = "FarmQzTrigger")
+// 使用 @Table 注解指定该实体对应的数据库表名
+@Table(name = "farm_qz_trigger")
+// 让该类实现 Serializable 接口，以便对象可以被序列化和反序列化
+public class FarmQzTrigger implements java.io.Serializable {
+ // 定义类的静态常量 serialVersionUID，用于序列化版本控制，确保在反序列化时类的结构兼容性，这里设置为 1
+ private static final long serialVersionUID = 1L;
+
+ // 使用 @Id 注解标记该字段为主键
+ @Id
+ // 定义一个名为 "systemUUID" 的主键生成器，采用 "uuid" 策略生成 UUID 作为主键值
+ @GenericGenerator(name = "systemUUID", strategy = "uuid")
+ // 指定使用 "systemUUID" 生成器来生成主键值
+ @GeneratedValue(generator = "systemUUID")
+ // 映射数据库中的 "ID" 列，指定列的长度为 32，允许插入、更新操作，且该列不能为空
+ @Column(name = "ID", length = 32, insertable = true, updatable = true, nullable = false)
+ // 声明一个字符串类型的成员变量 id，用于存储实体的唯一标识符
+ private String id;
+
+ // 映射数据库中的 "NAME" 列，指定列的长度为 128，该列不能为空
+ @Column(name = "NAME", length = 128, nullable = false)
+ // 声明一个字符串类型的成员变量 name，用于存储触发器的名称
+ private String name;
+
+ // 映射数据库中的 "DESCRIPT" 列，指定列的长度为 128，该列不能为空
+ @Column(name = "DESCRIPT", length = 128, nullable = false)
+ // 声明一个字符串类型的成员变量 descript，用于存储触发器的描述信息
+ private String descript;
+
+ // 映射数据库中的 "CTIME" 列，指定列的长度为 16，该列不能为空
+ @Column(name = "CTIME", length = 16, nullable = false)
+ // 声明一个字符串类型的成员变量 ctime，用于存储创建时间
+ private String ctime;
+
+ // 映射数据库中的 "ETIME" 列，指定列的长度为 16，该列不能为空
+ @Column(name = "ETIME", length = 16, nullable = false)
+ // 声明一个字符串类型的成员变量 etime，用于存储编辑时间
+ private String etime;
+
+ // 映射数据库中的 "CUSERNAME" 列，指定列的长度为 64，该列不能为空
+ @Column(name = "CUSERNAME", length = 64, nullable = false)
+ // 声明一个字符串类型的成员变量 cusername，用于存储创建用户的名称
+ private String cusername;
+
+ // 映射数据库中的 "CUSER" 列，指定列的长度为 32，该列不能为空
+ @Column(name = "CUSER", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 cuser，用于存储创建用户的 ID
+ private String cuser;
+
+ // 映射数据库中的 "EUSERNAME" 列，指定列的长度为 64，该列不能为空
+ @Column(name = "EUSERNAME", length = 64, nullable = false)
+ // 声明一个字符串类型的成员变量 eusername，用于存储编辑用户的名称
+ private String eusername;
+
+ // 映射数据库中的 "EUSER" 列，指定列的长度为 32，该列不能为空
+ @Column(name = "EUSER", length = 32, nullable = false)
+ // 声明一个字符串类型的成员变量 euser，用于存储编辑用户的 ID
+ private String euser;
+
+ // 映射数据库中的 "PCONTENT" 列，指定列的长度为 128
+ @Column(name = "PCONTENT", length = 128)
+ // 声明一个字符串类型的成员变量 pcontent，可能用于存储触发器的相关内容
+ private String pcontent;
+
+ // 映射数据库中的 "PSTATE" 列，指定列的长度为 2，该列不能为空
+ @Column(name = "PSTATE", length = 2, nullable = false)
+ // 声明一个字符串类型的成员变量 pstate，可能用于存储触发器的状态
+ private String pstate;
+
+ // 获取触发器名称的方法
+ public String getName() {
+ return this.name;
+ }
+
+ // 设置触发器名称的方法
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ // 获取触发器描述信息的方法
+ public String getDescript() {
+ return this.descript;
+ }
+
+ // 设置触发器描述信息的方法
+ public void setDescript(String descript) {
+ this.descript = descript;
+ }
+
+ // 获取创建时间的方法
+ public String getCtime() {
+ return this.ctime;
+ }
+
+ // 设置创建时间的方法
+ public void setCtime(String ctime) {
+ this.ctime = ctime;
+ }
+
+ // 获取编辑时间的方法
+ public String getEtime() {
+ return this.etime;
+ }
+
+ // 设置编辑时间的方法
+ public void setEtime(String etime) {
+ this.etime = etime;
+ }
+
+ // 获取创建用户名称的方法
+ public String getCusername() {
+ return this.cusername;
+ }
+
+ // 设置创建用户名称的方法
+ public void setCusername(String cusername) {
+ this.cusername = cusername;
+ }
+
+ // 获取创建用户 ID 的方法
+ public String getCuser() {
+ return this.cuser;
+ }
+
+ // 设置创建用户 ID 的方法
+ public void setCuser(String cuser) {
+ this.cuser = cuser;
+ }
+
+ // 获取编辑用户名称的方法
+ public String getEusername() {
+ return this.eusername;
+ }
+
+ // 设置编辑用户名称的方法
+ public void setEusername(String eusername) {
+ this.eusername = eusername;
+ }
+
+ // 获取编辑用户 ID 的方法
+ public String getEuser() {
+ return this.euser;
+ }
+
+ // 设置编辑用户 ID 的方法
+ public void setEuser(String euser) {
+ this.euser = euser;
+ }
+
+ // 获取触发器相关内容的方法
+ public String getPcontent() {
+ return this.pcontent;
+ }
+
+ // 设置触发器相关内容的方法
+ public void setPcontent(String pcontent) {
+ this.pcontent = pcontent;
+ }
+
+ // 获取触发器状态的方法
+ public String getPstate() {
+ return this.pstate;
+ }
+
+ // 设置触发器状态的方法
+ public void setPstate(String pstate) {
+ this.pstate = pstate;
+ }
+
+ // 获取实体唯一标识符的方法
+ public String getId() {
+ return this.id;
+ }
+
+ // 设置实体唯一标识符的方法
+ public void setId(String id) {
+ this.id = id;
+ }
+}}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/job/impl/CommandRuningJob.java b/src/wcp-quartz/src/main/java/com/farm/quartz/job/impl/CommandRuningJob.java
new file mode 100644
index 0000000..5aa30c0
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/job/impl/CommandRuningJob.java
@@ -0,0 +1,94 @@
+// 声明该类所属的包
+package com.farm.quartz.job.impl;
+
+// 导入用于读取缓冲字符流的类
+import java.io.BufferedReader;
+// 导入用于处理输入输出异常的类
+import java.io.IOException;
+// 导入表示输入流的类
+import java.io.InputStream;
+// 导入用于将字节流转换为字符流的类
+import java.io.InputStreamReader;
+
+// 导入 Apache Log4j 的 Logger 类，用于记录日志
+import org.apache.log4j.Logger;
+// 导入 Quartz 框架中的 Job 接口，该类需要实现此接口
+import org.quartz.Job;
+// 导入 Quartz 框架中用于传递作业执行上下文信息的类
+import org.quartz.JobExecutionContext;
+// 导入 Quartz 框架中用于表示作业执行异常的类
+import org.quartz.JobExecutionException;
+
+// 导入自定义的工具类，可能包含一些通用的工具方法
+import com.farm.core.FarmUtils;
+
+// 定义 CommandRuningJob 类，实现 Job 接口，用于执行命令行任务
+public class CommandRuningJob implements Job {
+ // 定义一个静态的 Logger 对象，用于记录日志，日志记录器关联到 CommandRuningJob 类
+ private static final Logger log = Logger.getLogger(CommandRuningJob.class);
+
+ // 重写 Job 接口中的 execute 方法，在作业执行时调用
+ @SuppressWarnings("static-access")
+ @Override
+ public void execute(JobExecutionContext arg0) throws JobExecutionException {
+ // 从作业执行上下文的合并作业数据映射中获取键为 "PARA" 的值，并转换为字符串
+ String commandStr = arg0.getMergedJobDataMap().get("PARA").toString();
+ // 使用 FarmUtils 工具类的方法检查命令字符串是否为空字符串
+ if (FarmUtils.getValidUtils().isEmptyString(commandStr)) {
+ // 如果命令字符串为空，抛出运行时异常
+ throw new RuntimeException("空命令行参数");
+ }
+ // 初始化输入流对象，用于获取命令执行的输出
+ InputStream stderr = null;
+ // 初始化输入流读取器对象，用于将字节流转换为字符流
+ InputStreamReader isr = null;
+ // 初始化缓冲字符读取器对象，用于读取字符流
+ BufferedReader br = null;
+ try {
+ // 去除命令字符串两端的空格
+ String cmd = commandStr.trim();
+ // 记录日志，打印要执行的命令行
+ log.info("执行命令行：" + cmd);
+ // 获取当前运行时系统
+ Runtime rt = Runtime.getRuntime();
+ // 执行命令，返回一个表示该命令进程的 Process 对象
+ Process proc = rt.exec(cmd);
+ // 获取命令执行的输入流（通常是标准输出或标准错误输出）
+ stderr = proc.getInputStream();
+ // 将输入流包装为输入流读取器
+ isr = new InputStreamReader(stderr);
+ // 将输入流读取器包装为缓冲字符读取器
+ br = new BufferedReader(isr);
+ // 定义变量用于存储读取的每一行内容
+ String line = null;
+ // 定义字符串缓冲区，用于存储读取的所有行内容
+ StringBuffer lineBuffer = new StringBuffer();
+ // 循环读取命令执行结果的每一行，直到读取到 null（表示文件结束）
+ while ((line = br.readLine()) != null) {
+ // 将读取到的行添加到字符串缓冲区
+ lineBuffer.append(line);
+ // 记录日志，打印读取到的每一行内容
+ log.info(line);
+ }
+ } catch (Exception t) {
+ // 如果在执行过程中发生异常，记录异常信息和异常消息
+ log.error(t + t.getMessage());
+ // 抛出运行时异常，将异常传递给上层调用者
+ throw new RuntimeException(t);
+ } finally {
+ try {
+ // 关闭输入流
+ stderr.close();
+ // 关闭输入流读取器
+ isr.close();
+ // 关闭缓冲字符读取器
+ br.close();
+ } catch (IOException e) {
+ // 如果在关闭流的过程中发生 I/O 异常，记录异常信息和异常消息
+ log.error(e + e.getMessage());
+ // 抛出运行时异常，将异常传递给上层调用者
+ throw new RuntimeException(e);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/server/DemoJobExecutionContext.java b/src/wcp-quartz/src/main/java/com/farm/quartz/server/DemoJobExecutionContext.java
new file mode 100644
index 0000000..b27697e
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/server/DemoJobExecutionContext.java
@@ -0,0 +1,164 @@
+// 声明该类所属的包
+package com.farm.quartz.server;
+
+// 导入表示日期的类，用于处理时间相关操作
+import java.util.Date;
+
+// 导入 Quartz 框架中的 Calendar 接口，用于处理日历相关功能
+import org.quartz.Calendar;
+// 导入 Quartz 框架中的 Job 接口，代表一个可执行的作业
+import org.quartz.Job;
+// 导入 Quartz 框架中用于存储作业数据的类
+import org.quartz.JobDataMap;
+// 导入 Quartz 框架中用于描述作业详细信息的类
+import org.quartz.JobDetail;
+// 导入 Quartz 框架中用于传递作业执行上下文信息的类
+import org.quartz.JobExecutionContext;
+// 导入 Quartz 框架中用于调度作业的类
+import org.quartz.Scheduler;
+// 导入 Quartz 框架中用于触发作业执行的类
+import org.quartz.Trigger;
+// 导入 Quartz 框架中用于标识触发器的类
+import org.quartz.TriggerKey;
+
+// 定义 DemoJobExecutionContext 类，实现 JobExecutionContext 接口，用于自定义作业执行上下文
+public class DemoJobExecutionContext implements JobExecutionContext {
+ // 定义一个 JobDataMap 类型的成员变量，用于存储作业数据
+ private JobDataMap dataMap;
+
+ // 构造函数，接受一个 JobDataMap 类型的参数，并将其赋值给成员变量 dataMap
+ public DemoJobExecutionContext(JobDataMap data) {
+ dataMap = data;
+ }
+
+ // 重写从作业执行上下文中获取指定键对应值的方法，这里直接返回 null
+ @Override
+ public Object get(Object arg0) {
+ return null;
+ }
+
+ // 重写获取与作业相关的日历对象的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Calendar getCalendar() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取触发实例 ID 的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public String getFireInstanceId() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取作业触发时间的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Date getFireTime() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取作业详细信息的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public JobDetail getJobDetail() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取作业实例的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Job getJobInstance() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取作业运行时间的方法，目前是待实现状态（TODO），返回 0
+ @Override
+ public long getJobRunTime() {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ // 重写获取合并后的作业数据映射的方法，返回成员变量 dataMap
+ @Override
+ public JobDataMap getMergedJobDataMap() {
+ return dataMap;
+ }
+
+ // 重写获取作业下一次触发时间的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Date getNextFireTime() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取作业上一次触发时间的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Date getPreviousFireTime() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取恢复中的触发器键的方法，目前是待实现状态（TODO），如果状态不正确会抛出 IllegalStateException 异常，返回 null
+ @Override
+ public TriggerKey getRecoveringTriggerKey() throws IllegalStateException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取作业重新触发次数的方法，目前是待实现状态（TODO），返回 0
+ @Override
+ public int getRefireCount() {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ // 重写获取作业执行结果的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Object getResult() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取作业计划触发时间的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Date getScheduledFireTime() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取调度器的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Scheduler getScheduler() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写获取触发器的方法，目前是待实现状态（TODO），返回 null
+ @Override
+ public Trigger getTrigger() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ // 重写判断作业是否正在恢复的方法，目前是待实现状态（TODO），返回 false
+ @Override
+ public boolean isRecovering() {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ // 重写向作业执行上下文中放入键值对的方法，目前是待实现状态（TODO）
+ @Override
+ public void put(Object arg0, Object arg1) {
+ // TODO Auto-generated method stub
+
+ }
+
+ // 重写设置作业执行结果的方法，目前是待实现状态（TODO）
+ @Override
+ public void setResult(Object arg0) {
+ // TODO Auto-generated method stub
+
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/server/FarmQzSchedulerManagerInter.java b/src/wcp-quartz/src/main/java/com/farm/quartz/server/FarmQzSchedulerManagerInter.java
new file mode 100644
index 0000000..4e2dec3
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/server/FarmQzSchedulerManagerInter.java
@@ -0,0 +1,184 @@
+package com.farm.quartz.server;
+
+import java.text.ParseException;
+
+import org.quartz.SchedulerException;
+
+import com.farm.quartz.domain.FarmQzScheduler;
+import com.farm.quartz.domain.FarmQzTask;
+import com.farm.quartz.domain.FarmQzTrigger;
+import com.farm.core.auth.domain.LoginUser;
+import com.farm.core.sql.query.DataQuery;
+
+/**
+ * 计划任务管理
+ *
+ * @author MAC_wd
+ *
+ */
+public interface FarmQzSchedulerManagerInter {
+ /**
+ *新增实体
+ *
+ * @param entity
+ */
+ public FarmQzScheduler insertSchedulerEntity(FarmQzScheduler entity,
+ LoginUser user);
+
+ /**
+ * 启动一个任务
+ *
+ * @param SchedulerId
+ * @throws ClassNotFoundException
+ * 类class无法解析
+ * @throws ParseException
+ * 计划字符串脚本无法解析
+ * @throws SchedulerException
+ */
+ public void startTask(String SchedulerId) throws ClassNotFoundException,
+ ParseException, SchedulerException;
+
+ /**
+ * 停止一个任务
+ *
+ * @param SchedulerId
+ * @throws SchedulerException
+ */
+ public void stopTask(String SchedulerId) throws SchedulerException;
+
+ /**
+ * 启动调度引擎
+ *
+ * @throws ParseException
+ * @throws ClassNotFoundException
+ */
+ public void start() throws SchedulerException, ParseException,
+ ClassNotFoundException;
+
+ /**
+ *修改实体
+ *
+ * @param entity
+ */
+ public FarmQzScheduler editSchedulerEntity(FarmQzScheduler entity,
+ LoginUser user);
+
+ /**
+ *删除实体
+ *
+ * @param entity
+ */
+ public void deleteSchedulerEntity(String entity, LoginUser user);
+
+ /**
+ *获得实体
+ *
+ * @param id
+ * @return
+ */
+ public FarmQzScheduler getSchedulerEntity(String id);
+
+ /**
+ * 创建一个基本查询用来查询当前实体
+ *
+ * @param query
+ * 传入的查询条件封装
+ * @return
+ */
+ public DataQuery createSchedulerSimpleQuery(DataQuery query);
+
+ /**
+ * 判断一个任务计划是否启动
+ *
+ * @param SchedulerId
+ * @return
+ * @throws SchedulerException
+ */
+ public boolean isRunningFindScheduler(String SchedulerId)
+ throws SchedulerException;
+
+ /**
+ *新增触发器定义实体
+ *
+ * @param entity
+ */
+ public FarmQzTrigger insertTriggerEntity(FarmQzTrigger entity,
+ LoginUser user);
+
+ /**
+ *修改触发器定义实体
+ *
+ * @param entity
+ */
+ public FarmQzTrigger editTriggerEntity(FarmQzTrigger entity, LoginUser user);
+
+ /**
+ *删除触发器定义实体
+ *
+ * @param entity
+ */
+ public void deleteTriggerEntity(String entity, LoginUser user);
+
+ /**
+ *获得触发器定义实体
+ *
+ * @param id
+ * @return
+ */
+ public FarmQzTrigger getTriggerEntity(String id);
+
+ /**
+ * 创建一个基本查询用来查询当前触发器定义实体
+ *
+ * @param query
+ * 传入的查询条件封装
+ * @return
+ */
+ public DataQuery createTriggerSimpleQuery(DataQuery query);
+
+ /**
+ *新增任务定义实体
+ *
+ * @param entity
+ */
+ public FarmQzTask insertTaskEntity(FarmQzTask entity, LoginUser user);
+
+ /**
+ *修改任务定义实体
+ *
+ * @param entity
+ */
+ public FarmQzTask editTaskEntity(FarmQzTask entity, LoginUser user);
+
+ /**
+ *删除任务定义实体
+ *
+ * @param entity
+ */
+ public void deleteTaskEntity(String entity, LoginUser user);
+
+ /**
+ *获得任务定义实体
+ *
+ * @param id
+ * @return
+ */
+ public FarmQzTask getTaskEntity(String id);
+
+ /**
+ * 创建一个基本查询用来查询当前任务定义实体
+ *
+ * @param query
+ * 传入的查询条件封装
+ * @return
+ */
+ public DataQuery createTaskSimpleQuery(DataQuery query);
+
+ /**
+ * 由一个实例获得任务对象
+ *
+ * @param schedulerId
+ * @return
+ */
+ public FarmQzTask getTaskBySchedulerId(String schedulerId);
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/server/QuartzInter.java b/src/wcp-quartz/src/main/java/com/farm/quartz/server/QuartzInter.java
new file mode 100644
index 0000000..01830d5
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/server/QuartzInter.java
@@ -0,0 +1,67 @@
+// 声明该类所在的包，此包名为 com.farm.quartz.server
+package com.farm.quartz.server;
+
+// 导入 java.text 包中的 ParseException 类，该类用于处理日期解析时可能出现的异常
+import java.text.ParseException;
+
+// 导入 org.quartz 包中的 JobDetail 类，JobDetail 用于定义一个具体的作业实例
+import org.quartz.JobDetail;
+// 导入 org.quartz 包中的 JobKey 类，JobKey 是作业的唯一标识符
+import org.quartz.JobKey;
+// 导入 org.quartz 包中的 Trigger 类，Trigger 用于定义作业的执行时间和触发规则
+import org.quartz.Trigger;
+
+// 导入自定义的 com.farm.quartz.domain 包中的 FarmQzScheduler 类，该类可能代表调度器的相关信息
+import com.farm.quartz.domain.FarmQzScheduler;
+// 导入自定义的 com.farm.quartz.domain 包中的 FarmQzTask 类，该类可能代表任务的相关信息
+import com.farm.quartz.domain.FarmQzTask;
+// 导入自定义的 com.farm.quartz.domain 包中的 FarmQzTrigger 类，该类可能代表触发器的相关信息
+import com.farm.quartz.domain.FarmQzTrigger;
+
+/**
+ * queatz的转化接口
+ *
+ * @author Administrator
+ *
+ */
+// 定义一个名为 QuartzInter 的接口，此接口提供了一些与 Quartz 调度器相关的转换方法
+public interface QuartzInter {
+ /**
+ * 根据调度器节点和任务信息获取 JobDetail 对象
+ *
+ * @param node 调度器节点信息，类型为 FarmQzScheduler
+ * @param task 任务信息，类型为 FarmQzTask
+ * @return 返回一个 JobDetail 对象，代表一个具体的作业实例
+ * @throws ClassNotFoundException 如果在加载作业类时找不到对应的类，抛出此异常
+ */
+ public JobDetail getJobDetail(FarmQzScheduler node,FarmQzTask task) throws ClassNotFoundException;
+
+ /**
+ * 根据调度器 ID 和任务信息获取 JobDetail 对象
+ *
+ * @param schedulerId 调度器的 ID，类型为 String
+ * @param task 任务信息，类型为 FarmQzTask
+ * @return 返回一个 JobDetail 对象，代表一个具体的作业实例
+ * @throws ClassNotFoundException 如果在加载作业类时找不到对应的类，抛出此异常
+ */
+ public JobDetail getJobDetail(String schedulerId,FarmQzTask task) throws ClassNotFoundException;
+
+ /**
+ * 根据调度器节点和触发器信息获取 Trigger 对象
+ *
+ * @param node 调度器节点信息，类型为 FarmQzScheduler
+ * @param trigger 触发器信息，类型为 FarmQzTrigger
+ * @return 返回一个 Trigger 对象，用于定义作业的执行时间和触发规则
+ * @throws ParseException 如果在解析触发器的时间表达式时出现错误，抛出此异常
+ */
+ public Trigger getTrigger(FarmQzScheduler node,FarmQzTrigger trigger) throws ParseException;
+
+ /**
+ * 根据调度器节点和任务信息获取 JobKey 对象
+ *
+ * @param node 调度器节点信息，类型为 FarmQzScheduler
+ * @param task 任务信息，类型为 FarmQzTask
+ * @return 返回一个 JobKey 对象，作为作业的唯一标识符
+ */
+ public JobKey getJobKey(FarmQzScheduler node,FarmQzTask task);
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/FarmQzSchedulerManagerImpl.java b/src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/FarmQzSchedulerManagerImpl.java
new file mode 100644
index 0000000..685f129
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/FarmQzSchedulerManagerImpl.java
@@ -0,0 +1,441 @@
+// 声明该类所属的包
+package com.farm.quartz.server.impl;
+
+// 导入处理日期解析异常的类
+import java.text.ParseException;
+
+// 导入 Spring 的资源注入注解，用于将 Spring 容器中的 Bean 注入到该类的成员变量中
+import javax.annotation.Resource;
+
+// 导入自定义的登录用户实体类，用于表示登录用户的信息
+import com.farm.core.auth.domain.LoginUser;
+// 导入自定义的时间工具类，用于处理时间和日期相关的操作
+import com.farm.core.time.TimeTool;
+
+// 导入 Apache Log4j 的 Logger 类，用于记录日志
+import org.apache.log4j.Logger;
+// 导入 Quartz 框架中的 Job 接口，代表一个可执行的作业
+import org.quartz.Job;
+// 导入 Quartz 框架中的 JobDetail 类，用于描述一个作业的详细信息
+import org.quartz.JobDetail;
+// 导入 Quartz 框架中的 Scheduler 类，用于调度作业的执行
+import org.quartz.Scheduler;
+// 导入 Quartz 框架中的 SchedulerException 类，用于表示调度器相关的异常
+import org.quartz.SchedulerException;
+// 导入 Quartz 框架中的 Trigger 类，用于触发作业的执行
+import org.quartz.Trigger;
+// 导入 Quartz 框架中的标准调度器工厂类，用于获取默认的调度器实例
+import org.quartz.impl.StdSchedulerFactory;
+// 导入 Spring 的 Service 注解，将该类标记为服务层组件，由 Spring 进行管理
+import org.springframework.stereotype.Service;
+// 导入 Spring 的事务管理注解，用于声明方法的事务属性
+import org.springframework.transaction.annotation.Transactional;
+
+// 导入自定义的调度器数据访问接口，用于与数据库中的调度器信息进行交互
+import com.farm.quartz.dao.FarmQzSchedulerDaoInter;
+// 导入自定义的任务数据访问接口，用于与数据库中的任务信息进行交互
+import com.farm.quartz.dao.FarmQzTaskDaoInter;
+// 导入自定义的触发器数据访问接口，用于与数据库中的触发器信息进行交互
+import com.farm.quartz.dao.FarmQzTriggerDaoInter;
+// 导入自定义的调度器实体类，代表数据库中的调度器记录
+import com.farm.quartz.domain.FarmQzScheduler;
+// 导入自定义的任务实体类，代表数据库中的任务记录
+import com.farm.quartz.domain.FarmQzTask;
+// 导入自定义的触发器实体类，代表数据库中的触发器记录
+import com.farm.quartz.domain.FarmQzTrigger;
+// 导入自定义的调度器管理接口，该类需要实现此接口中的方法
+import com.farm.quartz.server.FarmQzSchedulerManagerInter;
+// 导入自定义的数据查询类，用于构建和执行数据库查询操作
+import com.farm.core.sql.query.DataQuery;
+
+/**
+ * 计划任务管理
+ *
+ * @author MAC_wd
+ */
+// 使用 @Service 注解将该类标记为 Spring 服务层组件
+@Service
+// 定义 FarmQzSchedulerManagerImpl 类，实现 FarmQzSchedulerManagerInter 接口
+public class FarmQzSchedulerManagerImpl implements FarmQzSchedulerManagerInter {
+ // 使用 @Resource 注解注入 FarmQzSchedulerDaoInter 类型的 Bean
+ @Resource
+ private FarmQzSchedulerDaoInter farmQzSchedulerDao;
+ // 使用 @Resource 注解注入 FarmQzTaskDaoInter 类型的 Bean
+ @Resource
+ private FarmQzTaskDaoInter farmQzTaskDao;
+ // 使用 @Resource 注解注入 FarmQzTriggerDaoInter 类型的 Bean
+ @Resource
+ private FarmQzTriggerDaoInter farmQzTriggerDao;
+
+ // 定义一个静态的 Logger 对象，用于记录日志，日志记录器关联到 FarmQzSchedulerManagerImpl 类
+ private static final Logger log = Logger
+ .getLogger(FarmQzSchedulerManagerImpl.class);
+
+ // 定义一个静态的 Scheduler 对象，用于调度作业的执行
+ private static Scheduler scheduler = null;
+
+ // 重写启动调度器的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public void start() throws SchedulerException, ParseException,
+ ClassNotFoundException {
+ // 如果调度器对象为空，则通过标准调度器工厂获取默认的调度器实例
+ if (scheduler == null) {
+ scheduler = StdSchedulerFactory.getDefaultScheduler();
+ }
+ // 启动调度器
+ scheduler.start();
+ // 遍历所有自动调度的调度器记录
+ for (FarmQzScheduler node : farmQzSchedulerDao.getAutoSchedulers()) {
+ // 根据调度器记录中的任务 ID 获取对应的任务实体
+ FarmQzTask task = getTaskEntity(node.getTaskid());
+ // 根据调度器记录中的触发器 ID 获取对应的触发器实体
+ FarmQzTrigger trigger = getTriggerEntity(node.getTriggerid());
+ // 通过 QuartzImpl 类的实例获取作业详细信息
+ JobDetail job = new QuartzImpl().getJobDetail(node, task);
+ // 通过 QuartzImpl 类的实例获取触发器对象
+ Trigger qtrigger = new QuartzImpl().getTrigger(node, trigger);
+ // 将作业和触发器注册到调度器中，安排作业执行
+ scheduler.scheduleJob(job, qtrigger);
+ }
+ }
+
+ // 重写检查指定调度器是否正在运行的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public boolean isRunningFindScheduler(String SchedulerId)
+ throws SchedulerException {
+ // 根据调度器 ID 获取对应的调度器实体
+ FarmQzScheduler node = getSchedulerEntity(SchedulerId);
+ // 根据调度器实体中的任务 ID 获取对应的任务实体
+ FarmQzTask task = getTaskEntity(node.getTaskid());
+ // 通过调度器检查指定作业是否存在，如果不存在则返回 false，否则返回 true
+ if (scheduler.getJobDetail(new QuartzImpl().getJobKey(node, task)) == null) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ // 重写启动指定任务的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public void startTask(String SchedulerId) throws ClassNotFoundException,
+ ParseException, SchedulerException {
+ // 根据调度器 ID 获取对应的调度器实体
+ FarmQzScheduler node = getSchedulerEntity(SchedulerId);
+ // 根据调度器实体中的任务 ID 获取对应的任务实体
+ FarmQzTask task = getTaskEntity(node.getTaskid());
+ // 根据调度器实体中的触发器 ID 获取对应的触发器实体
+ FarmQzTrigger trigger = getTriggerEntity(node.getTriggerid());
+ // 通过 QuartzImpl 类的实例获取作业详细信息
+ JobDetail job = new QuartzImpl().getJobDetail(node, task);
+ // 通过 QuartzImpl 类的实例获取触发器对象
+ Trigger qtrigger = new QuartzImpl().getTrigger(node, trigger);
+ // 将作业和触发器注册到调度器中，安排作业执行
+ scheduler.scheduleJob(job, qtrigger);
+ }
+
+ // 重写停止指定任务的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public void stopTask(String SchedulerId) throws SchedulerException {
+ // 根据调度器 ID 获取对应的调度器实体
+ FarmQzScheduler node = getSchedulerEntity(SchedulerId);
+ // 根据调度器实体中的任务 ID 获取对应的任务实体
+ FarmQzTask task = getTaskEntity(node.getTaskid());
+ // 通过调度器删除指定的作业
+ scheduler.deleteJob(new QuartzImpl().getJobKey(node, task));
+ }
+
+ // 重写插入调度器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzScheduler insertSchedulerEntity(FarmQzScheduler entity,
+ LoginUser user) {
+ // 设置调度器实体的创建用户 ID
+ entity.setCuser(user.getId());
+ // 设置调度器实体的创建时间，使用时间工具类获取当前时间
+ entity.setCtime(TimeTool.getTimeDate14());
+ // 设置调度器实体的创建用户名称
+ entity.setCusername(user.getName());
+ // 设置调度器实体的编辑用户 ID
+ entity.setEuser(user.getId());
+ // 设置调度器实体的编辑用户名称
+ entity.setEusername(user.getName());
+ // 设置调度器实体的编辑时间，使用时间工具类获取当前时间
+ entity.setEtime(TimeTool.getTimeDate14());
+ // 设置调度器实体的状态为 "1"
+ entity.setPstate("1");
+ // 将调度器实体插入到数据库中
+ entity = farmQzSchedulerDao.insertEntity(entity);
+ // 如果调度器实体的自动调度标识为 "1"，则启动该任务
+ if (entity.getAutois().equals("1")) {
+ try {
+ startTask(entity.getId());
+ } catch (Exception e) {
+ // 如果启动任务时发生异常，抛出运行时异常
+ throw new RuntimeException(e);
+ }
+ }
+ // 将调度器实体再次插入到数据库中（这里可能存在重复插入的问题，可根据实际情况调整）
+ return farmQzSchedulerDao.insertEntity(entity);
+ }
+
+ // 重写编辑调度器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzScheduler editSchedulerEntity(FarmQzScheduler entity,
+ LoginUser user) {
+ // 根据调度器实体的 ID 从数据库中获取原调度器实体
+ FarmQzScheduler entity2 = farmQzSchedulerDao.getEntity(entity.getId());
+ // 设置原调度器实体的编辑用户 ID
+ entity2.setEuser(user.getId());
+ // 设置原调度器实体的编辑用户名称
+ entity2.setEusername(user.getName());
+ // 设置原调度器实体的编辑时间，使用时间工具类获取当前时间
+ entity2.setEtime(TimeTool.getTimeDate14());
+ // 设置原调度器实体的自动调度标识
+ entity2.setAutois(entity.getAutois());
+ // 设置原调度器实体的任务 ID
+ entity2.setTaskid(entity.getTaskid());
+ // 设置原调度器实体的触发器 ID
+ entity2.setTriggerid(entity.getTriggerid());
+ // 更新原调度器实体到数据库中
+ farmQzSchedulerDao.editEntity(entity2);
+ // 返回更新后的调度器实体
+ return entity2;
+ }
+
+ // 重写删除调度器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public void deleteSchedulerEntity(String entity, LoginUser user) {
+ try {
+ // 停止指定的任务
+ stopTask(entity);
+ } catch (SchedulerException e) {
+ // 如果停止任务时发生异常，记录异常信息
+ log.error(e);
+ }
+ // 根据调度器 ID 从数据库中获取调度器实体并删除
+ farmQzSchedulerDao.deleteEntity(farmQzSchedulerDao.getEntity(entity));
+ }
+
+ // 重写根据 ID 获取调度器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzScheduler getSchedulerEntity(String id) {
+ // 如果 ID 为空，则返回 null
+ if (id == null) {
+ return null;
+ }
+ // 根据 ID 从数据库中获取调度器实体并返回
+ return farmQzSchedulerDao.getEntity(id);
+ }
+
+ // 重写创建调度器简单查询的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public DataQuery createSchedulerSimpleQuery(DataQuery query) {
+ // 初始化数据查询对象，指定查询的表和要查询的字段
+ DataQuery dbQuery = DataQuery
+ .init(query,
+ "FARM_QZ_SCHEDULER A LEFT JOIN FARM_QZ_TASK B ON A.TASKID=B.ID LEFT JOIN FARM_QZ_TRIGGER C ON A.TRIGGERID=C.ID",
+ "A.ID AS ID,A.AUTOIS AS AUTOIS,A.AUTOIS AS AUTOISTYPE,B.NAME AS TASKNAME,C.NAME AS CTRIGGERNAME");
+ // 返回初始化后的查询对象
+ return dbQuery;
+ }
+
+ // 重写插入任务实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzTask insertTaskEntity(FarmQzTask entity, LoginUser user) {
+ // 设置任务实体的创建用户 ID
+ entity.setCuser(user.getId());
+ // 设置任务实体的创建时间，使用时间工具类获取当前时间
+ entity.setCtime(TimeTool.getTimeDate14());
+ // 设置任务实体的创建用户名称
+ entity.setCusername(user.getName());
+ // 设置任务实体的编辑用户 ID
+ entity.setEuser(user.getId());
+ // 设置任务实体的编辑用户名称
+ entity.setEusername(user.getName());
+ // 设置任务实体的编辑时间，使用时间工具类获取当前时间
+ entity.setEtime(TimeTool.getTimeDate14());
+ // 设置任务实体的状态为 "1"
+ entity.setPstate("1");
+ // 设置任务实体的作业键为 "NONE"
+ entity.setJobkey("NONE");
+ try {
+ // 遍历任务实体的作业类所实现的接口
+ for (@SuppressWarnings("rawtypes")
+ Class cla : Class.forName(entity.getJobclass().trim())
+ .getInterfaces()) {
+ // 如果作业类实现了 Job 接口，则将任务实体插入到数据库中并返回
+ if (cla.equals(Job.class)) {
+ return farmQzTaskDao.insertEntity(entity);
+ }
+ }
+ } catch (ClassNotFoundException e) {
+ // 如果在查找作业类时发生类未找到异常，抛出运行时异常
+ throw new RuntimeException("类转化异常");
+ }
+ // 如果作业类未实现 Job 接口，抛出运行时异常
+ throw new RuntimeException("类为实现Job接口");
+ }
+
+ // 重写编辑任务实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzTask editTaskEntity(FarmQzTask entity, LoginUser user) {
+ // 根据任务实体的 ID 从数据库中获取原任务实体
+ FarmQzTask entity2 = farmQzTaskDao.getEntity(entity.getId());
+ // 设置原任务实体的编辑用户 ID
+ entity2.setEuser(user.getId());
+ // 设置原任务实体的编辑用户名称
+ entity2.setEusername(user.getName());
+ // 设置原任务实体的编辑时间，使用时间工具类获取当前时间
+ entity2.setEtime(TimeTool.getTimeDate14());
+ // 设置原任务实体的作业类
+ entity2.setJobclass(entity.getJobclass());
+ // 设置原任务实体的名称
+ entity2.setName(entity.getName());
+ // 设置原任务实体的作业键
+ entity2.setJobkey(entity.getJobkey());
+ // 设置原任务实体的作业参数
+ entity2.setJobparas(entity.getJobparas());
+ // 设置原任务实体的作业键为 "NONE"
+ entity2.setJobkey("NONE");
+ // 设置原任务实体的内容
+ entity2.setPcontent(entity.getPcontent());
+ try {
+ // 遍历原任务实体的作业类所实现的接口
+ for (@SuppressWarnings("rawtypes")
+ Class cla : Class.forName(entity2.getJobclass().trim())
+ .getInterfaces()) {
+ // 如果作业类实现了 Job 接口，则更新原任务实体到数据库中并返回
+ if (cla.equals(Job.class)) {
+ farmQzTaskDao.editEntity(entity2);
+ return entity2;
+ }
+ }
+ } catch (ClassNotFoundException e) {
+ // 如果在查找作业类时发生类未找到异常，抛出运行时异常
+ throw new RuntimeException("类转化异常");
+ }
+ // 如果作业类未实现 Job 接口，抛出运行时异常
+ throw new RuntimeException("类为实现Job接口");
+ }
+
+ // 重写删除任务实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public void deleteTaskEntity(String entity, LoginUser user) {
+ // 根据任务 ID 从数据库中获取任务实体并删除
+ farmQzTaskDao.deleteEntity(farmQzTaskDao.getEntity(entity));
+ }
+
+ // 重写根据 ID 获取任务实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzTask getTaskEntity(String id) {
+ // 如果 ID 为空，则返回 null
+ if (id == null) {
+ return null;
+ }
+ // 根据 ID 从数据库中获取任务实体并返回
+ return farmQzTaskDao.getEntity(id);
+ }
+
+ // 重写创建任务简单查询的方法
+ @Override
+ public DataQuery createTaskSimpleQuery(DataQuery query) {
+ // 初始化数据查询对象，指定查询的表和要查询的字段
+ DataQuery dbQuery = DataQuery.init(query, "farm_qz_task",
+ "id,JOBCLASS,NAME,JOBKEY");
+ // 返回初始化后的查询对象
+ return dbQuery;
+ }
+
+ // 重写插入触发器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzTrigger insertTriggerEntity(FarmQzTrigger entity,
+ LoginUser user) {
+ // 设置触发器实体的创建用户 ID
+ entity.setCuser(user.getId());
+ // 设置触发器实体的创建时间，使用时间工具类获取当前时间
+ entity.setCtime(TimeTool.getTimeDate14());
+ // 设置触发器实体的创建用户名称
+ entity.setCusername(user.getName());
+ // 设置触发器实体的编辑用户 ID
+ entity.setEuser(user.getId());
+ // 设置触发器实体的编辑用户名称
+ entity.setEusername(user.getName());
+ // 设置触发器实体的编辑时间，使用时间工具类获取当前时间
+ entity.setEtime(TimeTool.getTimeDate14());
+ // 设置触发器实体的状态为 "1"
+ entity.setPstate("1");
+ // 将触发器实体插入到数据库中并返回
+ return farmQzTriggerDao.insertEntity(entity);
+ }
+
+ // 重写编辑触发器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzTrigger editTriggerEntity(FarmQzTrigger entity, LoginUser user) {
+ // 根据触发器实体的 ID 从数据库中获取原触发器实体
+ FarmQzTrigger entity2 = farmQzTriggerDao.getEntity(entity.getId());
+ // 设置原触发器实体的内容
+ entity2.setPcontent(entity.getPcontent());
+ // 设置原触发器实体的描述
+ entity2.setDescript(entity.getDescript());
+ // 设置原触发器实体的名称
+ entity2.setName(entity.getName());
+ // 更新原触发器实体到数据库中
+ farmQzTriggerDao.editEntity(entity2);
+ // 返回更新后的触发器实体
+ return entity2;
+ }
+
+ // 重写删除触发器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public void deleteTriggerEntity(String entity, LoginUser user) {
+ // 根据触发器 ID 从数据库中获取触发器实体并删除
+ farmQzTriggerDao.deleteEntity(farmQzTriggerDao.getEntity(entity));
+ }
+
+ // 重写根据 ID 获取触发器实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzTrigger getTriggerEntity(String id) {
+ // 如果 ID 为空，则返回 null
+ if (id == null) {
+ return null;
+ }
+ // 根据 ID 从数据库中获取触发器实体并返回
+ return farmQzTriggerDao.getEntity(id);
+ }
+
+ // 重写创建触发器简单查询的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public DataQuery createTriggerSimpleQuery(DataQuery query) {
+ // 初始化数据查询对象，指定查询的表和要查询的字段
+ DataQuery dbQuery = DataQuery.init(query, "farm_qz_trigger",
+ "id,PCONTENT,DESCRIPT,NAME");
+ // 返回初始化后的查询对象
+ return dbQuery;
+ }
+
+ // 重写根据调度器 ID 获取任务实体的方法，该方法在事务管理下执行
+ @Override
+ @Transactional
+ public FarmQzTask getTaskBySchedulerId(String schedulerId) {
+ // 根据调度器 ID 从数据库中获取调度器实体，再从调度器实体中获取任务 ID，最后根据任务 ID 获取任务实体并返回
+ return farmQzTaskDao.getEntity(farmQzSchedulerDao
+ .getEntity(schedulerId).getTaskid());
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/QuartzImpl.java b/src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/QuartzImpl.java
new file mode 100644
index 0000000..2af3c3c
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/server/impl/QuartzImpl.java
@@ -0,0 +1,75 @@
+// 声明该类所属的包
+package com.farm.quartz.server.impl;
+
+// 导入 Quartz 框架中用于构建 Job 的静态方法，方便创建 Job 实例
+import static org.quartz.JobBuilder.newJob;
+
+// 导入处理日期解析异常的类
+import java.text.ParseException;
+
+// 导入 Quartz 框架中用于存储作业数据的类
+import org.quartz.JobDataMap;
+// 导入 Quartz 框架中用于描述作业详细信息的类
+import org.quartz.JobDetail;
+// 导入 Quartz 框架中用于标识作业的类
+import org.quartz.JobKey;
+// 导入 Quartz 框架中用于触发作业执行的类
+import org.quartz.Trigger;
+// 导入 Quartz 框架中具体的 Cron 触发器实现类
+import org.quartz.impl.triggers.CronTriggerImpl;
+
+// 导入自定义的调度器实体类，代表数据库中的调度器记录
+import com.farm.quartz.domain.FarmQzScheduler;
+// 导入自定义的任务实体类，代表数据库中的任务记录
+import com.farm.quartz.domain.FarmQzTask;
+// 导入自定义的触发器实体类，代表数据库中的触发器记录
+import com.farm.quartz.domain.FarmQzTrigger;
+// 导入自定义的 Quartz 相关接口，该类需要实现此接口中的方法
+import com.farm.quartz.server.QuartzInter;
+
+// 定义 QuartzImpl 类，实现 QuartzInter 接口，用于处理与 Quartz 相关的具体操作
+public class QuartzImpl implements QuartzInter {
+
+ // 重写获取作业详细信息的方法，通过调用另一个重载方法来实现
+ @Override
+ public JobDetail getJobDetail(FarmQzScheduler node, FarmQzTask task)
+ throws ClassNotFoundException {
+ return getJobDetail(node.getId(), task);
+ }
+
+ // 重写获取触发器的方法，使用 @SuppressWarnings 注解抑制 "deprecation" 警告（可能是因为使用了过时的方法或类）
+ @SuppressWarnings("deprecation")
+ @Override
+ public Trigger getTrigger(FarmQzScheduler node, FarmQzTrigger trigger)
+ throws ParseException {
+ // 创建一个 Cron 触发器实例，设置触发器的名称（由调度器 ID 和触发器 ID 拼接而成）、所属组（这里为 null）和描述信息
+ Trigger qtrigger = new CronTriggerImpl(node.getId() + trigger.getId(),
+ null, trigger.getDescript().trim());
+ // 返回创建好的触发器实例
+ return qtrigger;
+ }
+
+ // 重写获取作业键的方法，根据调度器 ID 和任务 ID 拼接生成作业键
+ @Override
+ public JobKey getJobKey(FarmQzScheduler node, FarmQzTask task) {
+ return new JobKey(node.getId() + task.getId());
+ }
+
+ // 重写获取作业详细信息的方法，根据调度器 ID 和任务实体来创建作业详细信息
+ @SuppressWarnings("unchecked")
+ @Override
+ public JobDetail getJobDetail(String schedulerId, FarmQzTask task)
+ throws ClassNotFoundException {
+ // 根据任务实体中的作业类名，通过反射获取对应的 Class 对象
+ Class cla = Class.forName(task.getJobclass().trim());
+ // 创建一个作业数据映射对象，用于存储作业相关的数据
+ JobDataMap dataMap = new JobDataMap();
+ // 将任务实体中的作业参数放入作业数据映射中，键为 "PARA"
+ dataMap.put("PARA", task.getJobparas());
+ // 使用 JobBuilder 创建一个作业详细信息对象，设置作业的类、身份标识（由调度器 ID 和任务 ID 拼接而成）以及作业数据
+ JobDetail job = newJob(cla).withIdentity(schedulerId + task.getId())
+ .setJobData(dataMap).build();
+ // 返回创建好的作业详细信息对象
+ return job;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzSchedulerQuery.java b/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzSchedulerQuery.java
new file mode 100644
index 0000000..e5e2b76
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzSchedulerQuery.java
@@ -0,0 +1,327 @@
+// 声明该类所在的包，用于组织和管理代码，包名为 com.farm.quartz.web.controller
+package com.farm.quartz.web.controller;
+
+// 导入自定义的 com.farm.quartz.domain 包中的 FarmQzScheduler 类，可能代表调度器相关实体
+import com.farm.quartz.domain.FarmQzScheduler;
+// 导入自定义的 com.farm.quartz.domain 包中的 FarmQzTask 类，可能代表任务相关实体
+import com.farm.quartz.domain.FarmQzTask;
+// 导入自定义的 com.farm.quartz.server 包中的 DemoJobExecutionContext 类，可能用于作业执行上下文
+import com.farm.quartz.server.DemoJobExecutionContext;
+// 导入自定义的 com.farm.quartz.server 包中的 FarmQzSchedulerManagerInter 接口，可能用于调度器管理
+import com.farm.quartz.server.FarmQzSchedulerManagerInter;
+// 导入自定义的 com.farm.quartz.server.impl 包中的 QuartzImpl 类，可能是 Quartz 相关操作的实现类
+import com.farm.quartz.server.impl.QuartzImpl;
+// 导入自定义的 com.farm.web 包中的 WebUtils 类，可能包含一些 Web 相关的工具方法
+import com.farm.web.WebUtils;
+// 导入自定义的 com.farm.web.easyui 包中的 EasyUiUtils 类，可能用于处理 EasyUI 相关的操作
+import com.farm.web.easyui.EasyUiUtils;
+
+// 导入 Java 标准库中的 HashMap 类，用于创建键值对集合
+import java.util.HashMap;
+// 导入 Java 标准库中的 Map 接口，用于表示键值对的集合
+import java.util.Map;
+
+// 导入 Spring 框架中的资源注入注解，用于自动装配依赖
+import javax.annotation.Resource;
+// 导入 Servlet 相关的 HttpServletRequest 类，用于处理 HTTP 请求
+import javax.servlet.http.HttpServletRequest;
+// 导入 Servlet 相关的 HttpSession 类，用于管理会话
+import javax.servlet.http.HttpSession;
+
+// 导入 Apache Log4j 中的 Logger 类，用于记录日志
+import org.apache.log4j.Logger;
+// 导入 Quartz 框架中的 Job 接口，定义作业的执行逻辑
+import org.quartz.Job;
+// 导入 Quartz 框架中的 JobDetail 类，用于定义作业的详细信息
+import org.quartz.JobDetail;
+// 导入 Quartz 框架中的 JobExecutionContext 接口，用于在作业执行时提供上下文信息
+import org.quartz.JobExecutionContext;
+// 导入 Quartz 框架中的 Scheduler 接口，用于管理调度器
+import org.quartz.Scheduler;
+// 导入 Quartz 框架中的 JobExecutionContextImpl 类，是 JobExecutionContext 的实现类
+import org.quartz.impl.JobExecutionContextImpl;
+
+// 导入 Spring 框架中的 Controller 注解，将该类标记为一个控制器
+import org.springframework.stereotype.Controller;
+// 导入 Spring 框架中的 RequestMapping 注解，用于映射 URL 到控制器的方法
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 框架中的 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 Spring 框架中的 ModelAndView 类，用于封装模型数据和视图信息
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入自定义的 com.farm.core.page 包中的 OperateType 枚举，可能用于表示操作类型
+import com.farm.core.page.OperateType;
+// 导入自定义的 com.farm.core.page 包中的 RequestMode 类，可能用于封装请求模式相关信息
+import com.farm.core.page.RequestMode;
+// 导入自定义的 com.farm.core.page 包中的 ViewMode 类，可能用于封装视图模式相关信息
+import com.farm.core.page.ViewMode;
+// 导入自定义的 com.farm.core.sql.query 包中的 DBSort 类，可能用于数据库排序相关操作
+import com.farm.core.sql.query.DBSort;
+// 导入自定义的 com.farm.core.sql.query 包中的 DataQuery 类，可能用于构建数据库查询
+import com.farm.core.sql.query.DataQuery;
+// 导入自定义的 com.farm.core.sql.result 包中的 DataResult 类，可能用于存储数据库查询结果
+import com.farm.core.sql.result.DataResult;
+
+/**
+ * 计划任务管理
+ *
+ * @author autoCode
+ *
+ */
+// 使用 RequestMapping 注解，为该控制器类的所有方法设置基础 URL 路径前缀为 "/qzScheduler"
+@RequestMapping("/qzScheduler")
+// 使用 Controller 注解，将该类标记为一个 Spring MVC 控制器
+@Controller
+// 定义一个名为 ActionFarmQzSchedulerQuery 的控制器类，继承自 WebUtils 类
+public class ActionFarmQzSchedulerQuery extends WebUtils {
+ // 定义一个静态的 Logger 对象，用于记录该类的日志信息，日志记录器的名称为当前类的全限定名
+ private static final Logger log = Logger.getLogger(ActionFarmQzSchedulerQuery.class);
+ // 使用 Resource 注解，自动装配 FarmQzSchedulerManagerInter 接口的实现类实例
+ @Resource
+ FarmQzSchedulerManagerInter farmQzSchedulerManagerImpl;
+
+ // 使用 RequestMapping 注解，将 "/query" 路径映射到该方法，用于处理查询请求
+ @RequestMapping("/query")
+ // 使用 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+ @ResponseBody
+ // 定义一个名为 queryall 的方法，用于查询所有调度器信息
+ public Map queryall(DataQuery query, HttpServletRequest request) {
+ // 调用 EasyUiUtils 的 formatGridQuery 方法，根据请求格式化查询参数
+ query = EasyUiUtils.formatGridQuery(request, query);
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 createSchedulerSimpleQuery 方法，创建一个简单的调度器查询
+ query = farmQzSchedulerManagerImpl.createSchedulerSimpleQuery(query);
+ // 执行查询，并将查询结果的 "AUTOIS" 字段的值进行字典转换，1 转换为 "自动"，0 转换为 "手动"
+ DataResult result = query.search().runDictionary("1:自动,0:手动", "AUTOIS");
+ // 遍历查询结果列表
+ for (Map node : result.getResultList()) {
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 isRunningFindScheduler 方法，判断调度器是否正在运行，并将结果存入 "RUN" 字段
+ node.put("RUN", farmQzSchedulerManagerImpl.isRunningFindScheduler(node.get("ID").toString()));
+ // 将 "RUN" 字段的值存入 "RUNTYPE" 字段
+ node.put("RUNTYPE", node.get("RUN"));
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e);
+ }
+ }
+ // 将查询结果的 "RUN" 字段的值进行字典转换，true 转换为 "是"，false 转换为 "否"
+ result.runDictionary("true:是,false:否", "RUN");
+ // 将格式化后的查询结果封装到 ViewMode 中，并返回包含结果的 Map 对象
+ return ViewMode.getInstance().putAttrs(EasyUiUtils.formatGridData(result)).returnObjMode();
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e.getMessage());
+ // 将错误信息封装到 ViewMode 中，并返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ // 使用 RequestMapping 注解，将 "/chooseTask" 路径映射到该方法，用于选择任务页面
+ @RequestMapping("/chooseTask")
+ // 定义一个名为 chooseTask 的方法，返回一个 ModelAndView 对象，用于跳转到选择任务的页面
+ public ModelAndView chooseTask(HttpSession session) {
+ return ViewMode.getInstance().returnModelAndView("quartz/pFarmQzTaskGrid");
+ }
+
+ // 使用 RequestMapping 注解，将 "/chooseTrigger" 路径映射到该方法，用于选择触发器页面
+ @RequestMapping("/chooseTrigger")
+ // 定义一个名为 chooseTrigger 的方法，返回一个 ModelAndView 对象，用于跳转到选择触发器的页面
+ public ModelAndView chooseTrigger(HttpSession session) {
+ return ViewMode.getInstance().returnModelAndView("quartz/pFarmQzTriggerGrid");
+ }
+
+ // 使用 RequestMapping 注解，将 "/list" 路径映射到该方法，用于显示调度器列表页面
+ @RequestMapping("/list")
+ // 定义一个名为 list 的方法，返回一个 ModelAndView 对象，用于跳转到调度器列表页面
+ public ModelAndView list(HttpSession session) {
+ return ViewMode.getInstance().returnModelAndView("quartz/pFarmQzSchedulerLayout");
+ }
+
+ /**
+ * start
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/start" 路径映射到该方法，用于启动调度器任务
+ @RequestMapping("/start")
+ // 使用 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+ @ResponseBody
+ // 定义一个名为 start 的方法，用于启动指定 ID 的调度器任务
+ public Map start(String ids, HttpSession session) {
+ try {
+ // 解析传入的 ID 字符串，得到 ID 数组
+ for (String id : parseIds(ids)) {
+ // 调用 farmQzSchedulerManagerImpl 的 startTask 方法，启动指定 ID 的任务
+ farmQzSchedulerManagerImpl.startTask(id);
+ }
+ // 将成功信息封装到 ViewMode 中，并返回包含成功信息的 Map 对象
+ return ViewMode.getInstance().returnObjMode();
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e.getMessage());
+ // 将错误信息封装到 ViewMode 中，并返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * stop
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/stop" 路径映射到该方法，用于停止调度器任务
+ @RequestMapping("/stop")
+ // 使用 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+ @ResponseBody
+ // 定义一个名为 stop 的方法，用于停止指定 ID 的调度器任务
+ public Map stop(String ids, HttpSession session) {
+ try {
+ // 解析传入的 ID 字符串，得到 ID 数组
+ for (String id : parseIds(ids)) {
+ // 调用 farmQzSchedulerManagerImpl 的 stopTask 方法，停止指定 ID 的任务
+ farmQzSchedulerManagerImpl.stopTask(id);
+ }
+ // 将成功信息封装到 ViewMode 中，并返回包含成功信息的 Map 对象
+ return ViewMode.getInstance().returnObjMode();
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e.getMessage());
+ // 将错误信息封装到 ViewMode 中，并返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * runOnec
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/runOnec" 路径映射到该方法，用于一次性运行调度器任务
+ @RequestMapping("/runOnec")
+ // 使用 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+ @ResponseBody
+ // 定义一个名为 runOnec 的方法，用于一次性运行指定 ID 的调度器任务
+ public Map runOnec(String ids, HttpSession session) {
+ try {
+ // 记录成功运行的任务数量
+ int successNum = 0;
+ // 解析传入的 ID 字符串，得到 ID 数组
+ for (String id : parseIds(ids)) {
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 getTaskBySchedulerId 方法，获取指定调度器 ID 对应的任务
+ FarmQzTask task = farmQzSchedulerManagerImpl.getTaskBySchedulerId(id);
+ // 调用 QuartzImpl 的 getJobDetail 方法，获取任务对应的 JobDetail 对象
+ JobDetail jobDet = new QuartzImpl().getJobDetail("none", task);
+ // 通过反射创建任务对应的 Job 实例
+ Job job = (Job) Class.forName(jobDet.getJobClass().getName()).newInstance();
+ // 创建一个自定义的作业执行上下文对象
+ JobExecutionContext jobContext = new DemoJobExecutionContext(jobDet.getJobDataMap());
+ // 执行作业
+ job.execute(jobContext);
+ // 成功运行的任务数量加 1
+ successNum++;
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e.toString());
+ }
+ }
+ // 将执行结果信息封装到 ViewMode 中，并返回包含结果信息的 Map 对象
+ return ViewMode.getInstance().putAttr("INFO", parseIds(ids).size() + "条任务被执行,其中" + successNum + "条成功").returnObjMode();
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e.getMessage());
+ // 将错误信息封装到 ViewMode 中，并返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 提交新增数据
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/addSubmit" 路径映射到该方法，用于提交新增调度器数据
+ @RequestMapping("/addSubmit")
+ // 使用 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+ @ResponseBody
+ // 定义一个名为 addSubmit 的方法，用于提交新增的调度器实体数据
+ public Map addSubmit(FarmQzScheduler entity, HttpSession session) {
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 insertSchedulerEntity 方法，插入新的调度器实体
+ entity = farmQzSchedulerManagerImpl.insertSchedulerEntity(entity, getCurrentUser(session));
+ // 将插入后的实体封装到 ViewMode 中，并返回包含实体信息的 Map 对象
+ return ViewMode.getInstance().putAttr("entity", entity).returnObjMode();
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e.getMessage());
+ // 将错误信息封装到 ViewMode 中，并返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 提交修改数据
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/editSubmit" 路径映射到该方法，用于提交修改调度器数据
+ @RequestMapping("/editSubmit")
+ // 使用 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+ @ResponseBody
+ // 定义一个名为 editSubmit 的方法，用于提交修改后的调度器实体数据
+ public Map editSubmit(FarmQzScheduler entity, HttpSession session) {
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 editSchedulerEntity 方法，修改调度器实体
+ entity = farmQzSchedulerManagerImpl.editSchedulerEntity(entity, getCurrentUser(session));
+ // 将操作类型设置为添加（可能是为了统一视图处理逻辑），并将修改后的实体封装到 ViewMode 中，返回包含实体信息的 Map 对象
+ return ViewMode.getInstance().setOperate(OperateType.ADD).putAttr("entity", entity).returnObjMode();
+ } catch (Exception e) {
+ // 打印异常堆栈信息
+ e.printStackTrace();
+ // 记录错误日志
+ log.error(e.getMessage());
+ // 将操作类型设置为添加，并将错误信息封装到 ViewMode 中，返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setOperate(OperateType.ADD).setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 删除数据
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/del" 路径映射到该方法，用于删除调度器数据
+ @RequestMapping("/del")
+ // 使用 ResponseBody 注解，将方法的返回值直接写入 HTTP 响应体
+ @ResponseBody
+ // 定义一个名为 delSubmit 的方法，用于删除指定 ID 的调度器实体
+ public Map delSubmit(String ids, HttpSession session) {
+ try {
+ // 解析传入的 ID 字符串，得到 ID 数组
+ for (String id : parseIds(ids)) {
+ // 调用 farmQzSchedulerManagerImpl 的 deleteSchedulerEntity 方法，删除指定 ID 的调度器实体
+ farmQzSchedulerManagerImpl.deleteSchedulerEntity(id, getCurrentUser(session));
+ }
+ // 将成功信息封装到 ViewMode 中，并返回包含成功信息的 Map 对象
+ return ViewMode.getInstance().returnObjMode();
+ } catch (Exception e) {
+ // 如果出现异常，记录错误日志
+ log.error(e.getMessage());
+ // 将错误信息封装到 ViewMode 中，并返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 显示详细信息（修改或浏览时）
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/form" 路径映射到该方法，用于显示调度器的详细信息页面（新增、修改、浏览）
+ @RequestMapping("/form")
+ // 定义一个名为 view 的方法，返回一个 ModelAndView 对象，用于显示调度器的详细信息页面
+ public ModelAndView view(RequestMode pageset, String ids) {
+ try {
+ // 根据请求模式的操作类型进行
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTaskQuery.java b/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTaskQuery.java
new file mode 100644
index 0000000..b31eee4
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTaskQuery.java
@@ -0,0 +1,217 @@
+// 声明该类所在的包，这里是 com.farm.quartz.web.controller，用于组织相关的 Web 控制器类
+package com.farm.quartz.web.controller;
+
+// 导入自定义的 FarmQzTask 类，该类可能代表定时任务的实体，包含任务的相关属性
+import com.farm.quartz.domain.FarmQzTask;
+// 导入自定义的 FarmQzSchedulerManagerInter 接口，该接口可能定义了与调度器和任务管理相关的方法
+import com.farm.quartz.server.FarmQzSchedulerManagerInter;
+// 导入 EasyUiUtils 类，这个类可能包含了一些用于处理 EasyUI 相关操作的工具方法，比如格式化数据等
+import com.farm.web.easyui.EasyUiUtils;
+
+// 导入 Java 的 Map 接口，用于存储键值对数据，这里主要用于返回处理结果
+import java.util.Map;
+
+// 导入 Spring 的 Resource 注解，用于自动装配依赖的 Bean
+import javax.annotation.Resource;
+// 导入 Servlet 的 HttpServletRequest 类，用于获取 HTTP 请求的相关信息
+import javax.servlet.http.HttpServletRequest;
+// 导入 Servlet 的 HttpSession 类，用于管理用户会话信息
+import javax.servlet.http.HttpSession;
+
+// 导入 Apache Log4j 的 Logger 类，用于记录日志信息，方便调试和监控
+import org.apache.log4j.Logger;
+// 导入 Spring 的 Controller 注解，将该类标记为一个 Spring MVC 控制器
+import org.springframework.stereotype.Controller;
+// 导入 Spring 的 RequestMapping 注解，用于映射请求的 URL 到相应的处理方法
+import org.springframework.web.bind.annotation.RequestMapping;
+// 导入 Spring 的 ResponseBody 注解，将方法的返回值直接作为 HTTP 响应的内容返回
+import org.springframework.web.bind.annotation.ResponseBody;
+// 导入 Spring 的 ModelAndView 类，用于封装模型数据和视图信息，返回给客户端
+import org.springframework.web.servlet.ModelAndView;
+
+// 导入自定义的 OperateType 枚举，用于表示操作类型，如新增、修改、删除等
+import com.farm.core.page.OperateType;
+// 导入自定义的 RequestMode 类，用于封装请求的模式信息，如操作类型等
+import com.farm.core.page.RequestMode;
+// 导入自定义的 ViewMode 类，用于封装视图的模式信息，方便构建返回的视图数据
+import com.farm.core.page.ViewMode;
+// 导入自定义的 DBSort 类，用于数据库查询的排序操作
+import com.farm.core.sql.query.DBSort;
+// 导入自定义的 DataQuery 类，用于构建和执行数据库查询
+import com.farm.core.sql.query.DataQuery;
+// 导入自定义的 DataResult 类，用于存储数据库查询的结果
+import com.farm.core.sql.result.DataResult;
+// 导入自定义的 WebUtils 类，可能包含一些通用的 Web 操作工具方法
+import com.farm.web.WebUtils;
+
+/**
+ * 任务定义
+ *
+ * @author autoCode
+ *
+ */
+// 使用 RequestMapping 注解，为该控制器的所有处理方法设置基础的 URL 前缀为 "/qzTask"
+@RequestMapping("/qzTask")
+// 使用 Controller 注解，将该类标记为 Spring MVC 控制器
+@Controller
+// 定义 ActionFarmQzTaskQuery 类，继承自 WebUtils 类，具备 Web 操作的通用能力
+public class ActionFarmQzTaskQuery extends WebUtils {
+ // 创建一个静态的 Logger 对象，用于记录该类的日志信息，日志记录器的名称为该类的全限定名
+ private static final Logger log = Logger.getLogger(ActionFarmQzTaskQuery.class);
+ // 使用 Resource 注解，自动装配 FarmQzSchedulerManagerInter 接口的实现类实例
+ @Resource
+ FarmQzSchedulerManagerInter farmQzSchedulerManagerImpl;
+
+ /**
+ * 查询结果集合
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/query" 路径的请求映射到该方法
+ @RequestMapping("/query")
+ // 使用 ResponseBody 注解，将方法的返回值直接作为 HTTP 响应内容返回
+ @ResponseBody
+ // 定义 queryall 方法，用于处理任务查询请求，接收 DataQuery 对象和 HttpServletRequest 对象作为参数
+ public Map queryall(DataQuery query, HttpServletRequest request) {
+ // 调用 EasyUiUtils 的 formatGridQuery 方法，根据请求信息格式化查询对象
+ query = EasyUiUtils.formatGridQuery(request, query);
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 createTaskSimpleQuery 方法创建简单的任务查询对象，并按照 "CTIME" 字段降序排序
+ query = farmQzSchedulerManagerImpl.createTaskSimpleQuery(query).addSort(new DBSort("CTIME", "desc"));
+ // 执行查询操作，将查询结果存储在 DataResult 对象中
+ DataResult result = query.search();
+ // 使用 ViewMode 封装查询结果，将格式化后的结果数据添加到视图模式中，并返回包含结果的 Map 对象
+ return ViewMode.getInstance().putAttrs(EasyUiUtils.formatGridData(result)).returnObjMode();
+ } catch (Exception e) {
+ // 若查询过程中出现异常，记录异常信息到日志
+ log.error(e.getMessage());
+ // 使用 ViewMode 封装错误信息，返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 提交修改数据
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/edit" 路径的请求映射到该方法
+ @RequestMapping("/edit")
+ // 使用 ResponseBody 注解，将方法的返回值直接作为 HTTP 响应内容返回
+ @ResponseBody
+ // 定义 editSubmit 方法，用于处理任务修改提交请求，接收 FarmQzTask 对象和 HttpSession 对象作为参数
+ public Map editSubmit(FarmQzTask entity, HttpSession session) {
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 editTaskEntity 方法，根据当前用户信息修改任务实体
+ entity = farmQzSchedulerManagerImpl.editTaskEntity(entity, getCurrentUser(session));
+ // 使用 ViewMode 封装操作类型为新增（这里可能是为了统一视图处理逻辑），并将修改后的任务实体添加到视图模式中，返回包含实体的 Map 对象
+ return ViewMode.getInstance().setOperate(OperateType.ADD).putAttr("entity", entity).returnObjMode();
+ } catch (Exception e) {
+ // 若修改过程中出现异常，打印异常堆栈信息
+ e.printStackTrace();
+ // 记录异常信息到日志
+ log.error(e.getMessage());
+ // 使用 ViewMode 封装操作类型为新增和错误信息，返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setOperate(OperateType.ADD).setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 提交新增数据
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/add" 路径的请求映射到该方法
+ @RequestMapping("/add")
+ // 使用 ResponseBody 注解，将方法的返回值直接作为 HTTP 响应内容返回
+ @ResponseBody
+ // 定义 addSubmit 方法，用于处理任务新增提交请求，接收 FarmQzTask 对象和 HttpSession 对象作为参数
+ public Map addSubmit(FarmQzTask entity, HttpSession session) {
+ try {
+ // 调用 farmQzSchedulerManagerImpl 的 insertTaskEntity 方法，根据当前用户信息插入新的任务实体
+ entity = farmQzSchedulerManagerImpl.insertTaskEntity(entity, getCurrentUser(session));
+ // 使用 ViewMode 封装新增的任务实体，返回包含实体的 Map 对象
+ return ViewMode.getInstance().putAttr("entity", entity).returnObjMode();
+ } catch (Exception e) {
+ // 若新增过程中出现异常，记录异常信息到日志
+ log.error(e.getMessage());
+ // 使用 ViewMode 封装错误信息，返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 删除数据
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/del" 路径的请求映射到该方法
+ @RequestMapping("/del")
+ // 使用 ResponseBody 注解，将方法的返回值直接作为 HTTP 响应内容返回
+ @ResponseBody
+ // 定义 delSubmit 方法，用于处理任务删除请求，接收任务 ID 字符串和 HttpSession 对象作为参数
+ public Map delSubmit(String ids, HttpSession session) {
+ try {
+ // 解析传入的任务 ID 字符串，将其分割为多个 ID
+ for (String id : parseIds(ids)) {
+ // 调用 farmQzSchedulerManagerImpl 的 deleteTaskEntity 方法，根据当前用户信息删除指定 ID 的任务实体
+ farmQzSchedulerManagerImpl.deleteTaskEntity(id, getCurrentUser(session));
+ }
+ // 使用 ViewMode 返回操作成功的 Map 对象
+ return ViewMode.getInstance().returnObjMode();
+ } catch (Exception e) {
+ // 若删除过程中出现异常，记录异常信息到日志
+ log.error(e.getMessage());
+ // 使用 ViewMode 封装错误信息，返回包含错误信息的 Map 对象
+ return ViewMode.getInstance().setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ /**
+ * 跳转
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/list" 路径的请求映射到该方法
+ @RequestMapping("/list")
+ // 定义 index 方法，用于处理页面跳转请求，接收 HttpSession 对象作为参数
+ public ModelAndView index(HttpSession session) {
+ // 使用 ViewMode 返回指定视图名称的 ModelAndView 对象，跳转到任务列表页面
+ return ViewMode.getInstance().returnModelAndView("quartz/pFarmQzTaskLayout");
+ }
+
+ /**
+ * 显示详细信息（修改或浏览时）
+ *
+ * @return
+ */
+ // 使用 RequestMapping 注解，将 "/form" 路径的请求映射到该方法
+ @RequestMapping("/form")
+ // 定义 view 方法，用于处理任务详细信息显示请求，接收 RequestMode 对象和任务 ID 字符串作为参数
+ public ModelAndView view(RequestMode pageset, String ids) {
+ try {
+ // 根据请求模式的操作类型进行不同处理
+ switch (pageset.getOperateType()) {
+ case (1): { // 新增操作
+ // 使用 ViewMode 封装请求模式信息，返回指定视图名称的 ModelAndView 对象，跳转到任务新增页面
+ return ViewMode.getInstance().putAttr("pageset", pageset).returnModelAndView("quartz/pFarmQzTaskEntity");
+ }
+ case (0): { // 展示操作
+ // 使用 ViewMode 封装请求模式信息和任务实体信息，返回指定视图名称的 ModelAndView 对象，跳转到任务展示页面
+ return ViewMode.getInstance().putAttr("pageset", pageset).putAttr("entity", farmQzSchedulerManagerImpl.getTaskEntity(ids)).returnModelAndView("quartz/pFarmQzTaskEntity");
+ }
+ case (2): { // 修改操作
+ // 使用 ViewMode 封装请求模式信息和任务实体信息，返回指定视图名称的 ModelAndView 对象，跳转到任务修改页面
+ return ViewMode.getInstance().putAttr("pageset", pageset).putAttr("entity", farmQzSchedulerManagerImpl.getTaskEntity(ids)).returnModelAndView("quartz/pFarmQzTaskEntity");
+ }
+ default:
+ break;
+ }
+ } catch (Exception e) {
+ // 若处理过程中出现异常，使用 ViewMode 封装错误信息，返回指定视图名称的 ModelAndView 对象，跳转到错误页面
+ return ViewMode.getInstance().setError(e + e.getMessage()).returnModelAndView("quartz/pFarmQzTaskEntity");
+ }
+ // 默认返回指定视图名称的 ModelAndView 对象，跳转到任务详细信息页面
+ return ViewMode.getInstance().returnModelAndView("quartz/pFarmQzTaskEntity");
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTriggerQuery.java b/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTriggerQuery.java
new file mode 100644
index 0000000..b8411cc
--- /dev/null
+++ b/src/wcp-quartz/src/main/java/com/farm/quartz/web/controller/ActionFarmQzTriggerQuery.java
@@ -0,0 +1,286 @@
+package com.farm.quartz.web.controller;
+
+import com.farm.quartz.domain.FarmQzTrigger;
+import com.farm.quartz.server.FarmQzSchedulerManagerInter;
+import com.farm.web.easyui.EasyUiUtils;
+
+import java.util.Map;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+
+import org.apache.log4j.Logger;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.servlet.ModelAndView;
+
+import com.farm.core.page.OperateType;
+import com.farm.core.page.RequestMode;
+import com.farm.core.page.ViewMode;
+import com.farm.core.sql.query.DataQuery;
+import com.farm.core.sql.result.DataResult;
+import com.farm.web.WebUtils;
+
+/**
+ * 触发器定义
+ *
+ * @author autoCode
+ *
+ */
+@RequestMapping("/qzTrigger")
+@Controller
+public class ActionFarmQzTriggerQuery extends WebUtils {
+ private static final Logger log = Logger
+ .getLogger(ActionFarmQzTriggerQuery.class);
+ @Resource
+ FarmQzSchedulerManagerInter farmQzSchedulerManagerImpl;
+
+ // /**
+ // * 查询结果集合
+ // *
+ // * @return
+ // */
+ // public String queryall() {
+ // try {
+ // query = EasyUiUtils.formatGridQuery(getRequest(), query);
+ // DataResult result = aloneIMP.createTriggerSimpleQuery(query)
+ // .search();
+ // jsonResult = EasyUiUtils.formatGridData(result);
+ // } catch (Exception e) {
+ // throw new RuntimeException(e);
+ // }
+ // return SUCCESS;
+ // }
+
+ /**
+ * 查询结果集合
+ *
+ * @return
+ */
+ @RequestMapping("/query")
+ @ResponseBody
+ public Map queryall(DataQuery query,
+ HttpServletRequest request) {
+ query = EasyUiUtils.formatGridQuery(request, query);
+ try {
+ query = farmQzSchedulerManagerImpl.createTriggerSimpleQuery(query);
+ DataResult result = query.search();
+ return ViewMode.getInstance()
+ .putAttrs(EasyUiUtils.formatGridData(result))
+ .returnObjMode();
+ } catch (Exception e) {
+ log.error(e.getMessage());
+ return ViewMode.getInstance().setError(e.getMessage())
+ .returnObjMode();
+ }
+ }
+
+ // /**
+ // * 提交修改数据
+ // *
+ // * @return
+ // */
+ // public String editSubmit() {
+ // try {
+ // entity = aloneIMP.editTriggerEntity(entity, getCurrentUser());
+ // pageset = new PageSet(PageType.UPDATE, CommitType.TRUE);
+ // } catch (Exception e) {
+ // pageset = PageSet.initPageSet(pageset, PageType.UPDATE,
+ // CommitType.FALSE, e);
+ // }
+ // return SUCCESS;
+ // }
+
+ /**
+ * 提交修改数据
+ *
+ * @return
+ */
+ @RequestMapping("/edit")
+ @ResponseBody
+ public Map editSubmit(FarmQzTrigger entity,
+ HttpSession session) {
+ try {
+ entity = farmQzSchedulerManagerImpl.editTriggerEntity(entity,
+ getCurrentUser(session));
+ return ViewMode.getInstance().setOperate(OperateType.ADD)
+ .putAttr("entity", entity).returnObjMode();
+ } catch (Exception e) {
+ e.printStackTrace();
+ log.error(e.getMessage());
+ return ViewMode.getInstance().setOperate(OperateType.ADD)
+ .setError(e.getMessage()).returnObjMode();
+ }
+ }
+
+ // /**
+ // * 提交新增数据
+ // *
+ // * @return
+ // */
+ // public String addSubmit() {
+ // try {
+ // entity = aloneIMP.insertTriggerEntity(entity, getCurrentUser());
+ // pageset = new PageSet(PageType.ADD, CommitType.TRUE);
+ // } catch (Exception e) {
+ // pageset = PageSet.initPageSet(pageset, PageType.ADD,
+ // CommitType.FALSE, e);
+ // }
+ // return SUCCESS;
+ // }
+
+ /**
+ * 提交新增数据
+ *
+ * @return
+ */
+ @RequestMapping("/add")
+ @ResponseBody
+ public Map addSubmit(FarmQzTrigger entity,
+ HttpSession session) {
+ try {
+ entity = farmQzSchedulerManagerImpl.insertTriggerEntity(entity,
+ getCurrentUser(session));
+ return ViewMode.getInstance().putAttr("entity", entity)
+ .returnObjMode();
+ } catch (Exception e) {
+ log.error(e.getMessage());
+ return ViewMode.getInstance().setError(e.getMessage())
+ .returnObjMode();
+ }
+ }
+
+ /**
+ * 删除数据
+ *
+ * @return
+ */
+ @RequestMapping("/del")
+ @ResponseBody
+ public Map delSubmit(String ids, HttpSession session) {
+ try {
+ for (String id : parseIds(ids)) {
+ farmQzSchedulerManagerImpl.deleteTriggerEntity(id,
+ getCurrentUser(session));
+ }
+ return ViewMode.getInstance().returnObjMode();
+ } catch (Exception e) {
+ log.error(e.getMessage());
+ return ViewMode.getInstance().setError(e.getMessage())
+ .returnObjMode();
+ }
+ }
+
+ // /**
+ // * 删除数据
+ // *
+ // * @return
+ // */
+ // public String delSubmit() {
+ // try {
+ // for (String id : parseIds(ids)) {
+ // aloneIMP.deleteTriggerEntity(id, getCurrentUser());
+ // }
+ // pageset = new PageSet(PageType.ADD, CommitType.TRUE);
+ // } catch (Exception e) {
+ // pageset = PageSet.initPageSet(pageset, PageType.DEL,
+ // CommitType.FALSE, e);
+ // }
+ // return SUCCESS;
+ // }
+
+ // /**
+ // * 跳转
+ // *
+ // * @return
+ // */
+ // public String forSend() {
+ // return SUCCESS;
+ // }
+ /**
+ * 跳转
+ *
+ * @return
+ */
+ @RequestMapping("/list")
+ public ModelAndView index(HttpSession session) {
+ return ViewMode.getInstance().returnModelAndView(
+ "quartz/pFarmQzTriggerLayout");
+ }
+
+ /**
+ * 显示详细信息（修改或浏览时）
+ *
+ * @return
+ */
+ @RequestMapping("/form")
+ public ModelAndView view(RequestMode pageset, String ids) {
+ try {
+ switch (pageset.getOperateType()) {
+ case (1): {// 新增
+ return ViewMode.getInstance().putAttr("pageset", pageset)
+ .returnModelAndView("quartz/pFarmQzTriggerEntity");
+ }
+ case (0): {// 展示
+ return ViewMode
+ .getInstance()
+ .putAttr("pageset", pageset)
+ .putAttr(
+ "entity",
+ farmQzSchedulerManagerImpl
+ .getTriggerEntity(ids))
+ .returnModelAndView("quartz/pFarmQzTriggerEntity");
+ }
+ case (2): {// 修改
+ return ViewMode
+ .getInstance()
+ .putAttr("pageset", pageset)
+ .putAttr(
+ "entity",
+ farmQzSchedulerManagerImpl
+ .getTriggerEntity(ids))
+ .returnModelAndView("quartz/pFarmQzTriggerEntity");
+ }
+ default:
+ break;
+ }
+ } catch (Exception e) {
+ return ViewMode.getInstance().setError(e + e.getMessage())
+ .returnModelAndView("parameter/pFarmQzTriggerEntity");
+ }
+ return ViewMode.getInstance().returnModelAndView(
+ "parameter/pFarmQzTriggerEntity");
+ }
+
+ // /**
+ // * 显示详细信息（修改或浏览时）
+ // *
+ // * @return
+ // */
+ // public String view() {
+ // try {
+ // switch (pageset.getPageType()) {
+ // case (1): {// 新增
+ // return SUCCESS;
+ // }
+ // case (0): {// 展示
+ // entity = aloneIMP.getTriggerEntity(ids);
+ // return SUCCESS;
+ // }
+ // case (2): {// 修改
+ // entity = aloneIMP.getTriggerEntity(ids);
+ // return SUCCESS;
+ // }
+ // default:
+ // break;
+ // }
+ // } catch (Exception e) {
+ // pageset = PageSet.initPageSet(pageset, PageType.OTHER,
+ // CommitType.FALSE, e);
+ // }
+ // return SUCCESS;
+ // }
+
+}
diff --git a/src/wcp-quartz/src/main/resources/quartz.properties b/src/wcp-quartz/src/main/resources/quartz.properties
new file mode 100644
index 0000000..461553f
--- /dev/null
+++ b/src/wcp-quartz/src/main/resources/quartz.properties
@@ -0,0 +1,3 @@
+org.quartz.scheduler.instanceName = MyScheduler
+org.quartz.threadPool.threadCount = 3
+org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
\ No newline at end of file
diff --git a/src/wcp-tag/pom.xml b/src/wcp-tag/pom.xml
new file mode 100644
index 0000000..1a23848
--- /dev/null
+++ b/src/wcp-tag/pom.xml
@@ -0,0 +1,92 @@
+
+
+
+ 4.0.0
+
+
+ com.farm
+
+
+ wcp-tag
+
+
+ ${wcp.version}
+
+
+ jsp标签库
+
+
+
+
+ 3.2.0
+
+
+
+ UTF-8
+
+
+ UTF-8
+
+
+
+ UTF-8
+
+
+
+
+
+
+ com.farm
+ farm-core
+ ${wcp.version}
+
+
+
+
+ com.farm
+ wcp-authority
+ ${wcp.version}
+
+
+
+
+ com.farm
+ wcp-parameter
+ ${wcp.version}
+
+
+
+
+ com.farm
+ wcp-doc
+ ${wcp.version}
+
+
+
+
+ com.farm
+ wda-api
+ 1.2.2
+
+
+
+
+
+
+
+
+
+ maven-compiler-plugin
+
+
+
+ 1.8
+
+ 1.8
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/AuditIsShowForUser.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/AuditIsShowForUser.java
new file mode 100644
index 0000000..dac7618
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/AuditIsShowForUser.java
@@ -0,0 +1,76 @@
+// 声明该类所在的包为 com.farm.doc.tag，用于组织相关的标签类
+package com.farm.doc.tag;
+
+// 导入 Servlet 相关的 HttpServletRequest 类，用于获取 HTTP 请求的相关信息
+import javax.servlet.http.HttpServletRequest;
+// 导入 JSP 相关的 JspException 类，用于处理 JSP 标签操作中可能抛出的异常
+import javax.servlet.jsp.JspException;
+// 导入 JSP 相关的 TagSupport 类，这是一个基础类，用于创建自定义标签
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入自定义的 com.farm.core.auth.domain 包中的 LoginUser 类，可能代表登录用户的实体
+import com.farm.core.auth.domain.LoginUser;
+// 导入自定义的 com.farm.doc.server 包中的 FarmDocManagerInter 接口，可能用于文档管理相关操作
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入自定义的 com.farm.doc.server 包中的 FarmDocOperateRightInter 接口，可能用于文档操作权限相关操作
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入自定义的 com.farm.util.spring 包中的 BeanFactory 类，可能用于获取 Spring 容器中的 Bean
+import com.farm.util.spring.BeanFactory;
+// 导入自定义的 com.farm.web.constant 包中的 FarmConstant 类，可能包含一些与项目相关的常量
+import com.farm.web.constant.FarmConstant;
+
+/**
+ * 用户是否有该文档的审核权限
+ *
+ * @author wangdong
+ *
+ */
+// 定义 AuditIsShowForUser 类，继承自 TagSupport 类，用于创建一个自定义的 JSP 标签
+public class AuditIsShowForUser extends TagSupport {
+ // 定义一个私有属性 docId，用于存储文档的 ID
+ private String docId;
+ /**
+ * 序列化版本号，用于在反序列化时验证版本一致性
+ */
+ private static final long serialVersionUID = 1L;
+ // 通过 BeanFactory 从 Spring 容器中获取 FarmDocOperateRightInter 接口的实现类实例，并赋值给 aloneIMP 常量
+ private final static FarmDocOperateRightInter aloneIMP = (FarmDocOperateRightInter) BeanFactory.getBean("farmDocOperateRightImpl");
+ // 通过 BeanFactory 从 Spring 容器中获取 FarmDocManagerInter 接口的实现类实例，并赋值给 docIMP 常量
+ private final static FarmDocManagerInter docIMP = (FarmDocManagerInter) BeanFactory.getBean("farmDocManagerImpl");
+
+ // 重写 doEndTag 方法，该方法在标签结束时调用
+ @Override
+ public int doEndTag() throws JspException {
+ // 返回 EVAL_PAGE，表示继续处理页面的其余部分
+ return EVAL_PAGE;
+ }
+
+ // 重写 doStartTag 方法，该方法在标签开始时调用
+ @SuppressWarnings("deprecation")
+ @Override
+ public int doStartTag() throws JspException {
+ // 从 pageContext 中获取 HttpServletRequest 对象，用于获取请求相关信息
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 从请求的会话中获取名为 FarmConstant.SESSION_USEROBJ 的属性，即当前登录用户对象
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // EVAL_BODY_INCLUDE 表示执行自定义标签的标签体；
+ // 返回 SKIP_BODY 则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ // 调用 aloneIMP 的 isAudit 方法，判断当前用户是否有指定文档的审核权限
+ if (aloneIMP.isAudit(user, docIMP.getDoc(docId).getDoc())) {
+ // 如果有审核权限，返回 EVAL_BODY_INCLUDE，执行标签体内容
+ return EVAL_BODY_INCLUDE;
+ }
+ // 如果没有审核权限，返回 SKIP_BODY，跳过标签体内容
+ return SKIP_BODY;
+ }
+
+ // 定义 docId 属性的 getter 方法，用于获取 docId 的值
+ public String getDocId() {
+ return docId;
+ }
+
+ // 定义 docId 属性的 setter 方法，用于设置 docId 的值
+ public void setDocId(String docId) {
+ this.docId = docId;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/DefaultIndexPageTaget.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/DefaultIndexPageTaget.java
new file mode 100644
index 0000000..dda13b1
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/DefaultIndexPageTaget.java
@@ -0,0 +1,87 @@
+// 声明该类所在的包
+package com.farm.doc.tag;
+
+// 导入处理输入输出异常的类
+import java.io.IOException;
+
+// 导入 JSP 相关的异常类
+import javax.servlet.jsp.JspException;
+// 导入 JSP 输出流类
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 标签支持类
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入 Log4j 日志记录器类
+import org.apache.log4j.Logger;
+
+// 导入自定义的参数服务类
+import com.farm.parameter.FarmParameterService;
+
+/**
+ * 自定义的 JSP 标签类，用于获取并输出系统默认的首页路径
+ */
+public class DefaultIndexPageTaget extends TagSupport {
+
+ /**
+ * 序列化版本号，用于确保序列化和反序列化的兼容性
+ */
+ private static final long serialVersionUID = 1L;
+ // 创建一个日志记录器，用于记录该类相关的日志信息
+ static final Logger log = Logger.getLogger(DefaultIndexPageTaget.class);
+
+ /**
+ * 处理标签结束时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doEndTag() throws JspException {
+ // 这里暂时没有具体的逻辑，可根据需求后续添加
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ /**
+ * 处理标签开始时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ // 调用 getDefaultIndexPage 方法获取系统默认的首页路径
+ String Path = getDefaultIndexPage();
+ // 从当前页面上下文获取 JSP 输出流
+ JspWriter jspw = this.pageContext.getOut();
+ try {
+ // 将获取到的首页路径输出到 JSP 页面
+ jspw.print(Path);
+ } catch (IOException e) {
+ // 如果输出过程中发生 IO 异常，使用日志记录器记录异常信息
+ log.error(e.getMessage());
+ }
+ return 0;
+ }
+
+ /**
+ * 获得系统默认登录页面
+ *
+ * @return 系统默认登录页面的路径
+ */
+ public static String getDefaultIndexPage() {
+ // 从参数服务中获取系统是否开源的配置信息
+ String isOpen = FarmParameterService.getInstance().getParameter("config.sys.opensource");
+ // 从参数服务中获取系统默认首页的配置信息
+ String Path = FarmParameterService.getInstance().getParameter("config.index.defaultpage");
+ // 判断系统是否开源
+ if (isOpen.equals("true")) {
+ // 如果系统开源，将首页路径设置为指定的开源页面路径
+ Path = "websearch/PubHome.html";
+ } else {
+ // 如果系统不开源，保持从配置中获取的首页路径
+ Path = FarmParameterService.getInstance().getParameter("config.index.defaultpage");
+ }
+ return Path;
+ }
+}
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/DelIsShowForUser.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/DelIsShowForUser.java
new file mode 100644
index 0000000..0aead98
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/DelIsShowForUser.java
@@ -0,0 +1,54 @@
+package com.farm.doc.tag;
+
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.tagext.TagSupport;
+
+import com.farm.core.auth.domain.LoginUser;
+import com.farm.doc.server.FarmDocManagerInter;
+import com.farm.doc.server.FarmDocOperateRightInter;
+import com.farm.util.spring.BeanFactory;
+import com.farm.web.constant.FarmConstant;
+
+public class DelIsShowForUser extends TagSupport {
+ private String docId;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private final static FarmDocOperateRightInter aloneIMP = (FarmDocOperateRightInter) BeanFactory
+ .getBean("farmDocOperateRightImpl");
+ private final static FarmDocManagerInter docIMP = (FarmDocManagerInter) BeanFactory
+ .getBean("farmDocManagerImpl");
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回SKIP_BODY则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (aloneIMP.isDel(user, docIMP.getDoc(docId).getDoc())) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ public String getDocId() {
+ return docId;
+ }
+
+ public void setDocId(String docId) {
+ this.docId = docId;
+ }
+
+}
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/DocContent.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/DocContent.java
new file mode 100644
index 0000000..3b87bec
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/DocContent.java
@@ -0,0 +1,97 @@
+// 声明该类所在的包
+package com.farm.doc.tag;
+
+// 导入用于处理输入输出异常的类
+import java.io.IOException;
+
+// 导入 JSP 相关的异常类
+import javax.servlet.jsp.JspException;
+// 导入 JSP 输出流类
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 标签支持类
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入文档完整信息的实体类
+import com.farm.doc.domain.ex.DocEntire;
+// 导入文档管理的接口类
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入 Spring 工具类，用于获取 Bean 对象
+import com.farm.util.spring.BeanFactory;
+
+/**
+ * 自定义 JSP 标签类，用于获取并输出指定文档的内容
+ */
+public class DocContent extends TagSupport {
+
+ /**
+ * 文档的 ID，用于指定要获取的文档
+ */
+ private String id;
+
+ /**
+ * 通过 Spring 的 BeanFactory 获取文档管理的实现类实例，使用单例模式
+ */
+ private final static FarmDocManagerInter aloneIMP = (FarmDocManagerInter) BeanFactory
+ .getBean("farmDocManagerImpl");
+
+ /**
+ * 序列化版本号，用于确保序列化和反序列化的兼容性
+ */
+ private static final long serialVersionUID = 1895493540131375513L;
+
+ /**
+ * 处理标签结束时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @SuppressWarnings("deprecation")
+ @Override
+ public int doEndTag() throws JspException {
+ // 从当前页面上下文获取 JSP 输出流
+ JspWriter jspw = this.pageContext.getOut();
+ try {
+ // 根据文档 ID 获取文档的完整信息
+ DocEntire doc = aloneIMP.getDoc(id);
+ // 将文档的文本内容输出到 JSP 页面，拼接 text1、text2 和 text3 的内容
+ jspw.println(doc.getTexts().getText1()
+ + (doc.getTexts().getText2() != null ? doc.getTexts().getText2() : "")
+ + (doc.getTexts().getText3() != null ? doc.getTexts().getText3() : ""));
+ } catch (IOException e) {
+ // 如果输出过程中发生 IO 异常，打印异常堆栈信息
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ return 0;
+ }
+
+ /**
+ * 处理标签开始时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ // 这里暂时没有具体的逻辑，可根据需求后续添加
+ return 0;
+ }
+
+ /**
+ * 获取文档的 ID
+ *
+ * @return 文档的 ID
+ */
+ public String getId() {
+ return id;
+ }
+
+ /**
+ * 设置文档的 ID
+ *
+ * @param id 要设置的文档 ID
+ */
+ public void setId(String id) {
+ this.id = id;
+ }
+}
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/DocDescribe.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/DocDescribe.java
new file mode 100644
index 0000000..f160cf1
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/DocDescribe.java
@@ -0,0 +1,108 @@
+// 声明该类所在的包
+package com.farm.doc.tag;
+
+// 导入处理输入输出异常的类，用于处理 JSP 输出时可能出现的异常
+import java.io.IOException;
+
+// 导入 JSP 异常类，用于处理 JSP 标签处理过程中可能出现的异常
+import javax.servlet.jsp.JspException;
+// 导入 JSP 输出流类，用于向 JSP 页面输出内容
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 标签支持类，是自定义 JSP 标签的基础类
+import javax.servlet.jsp.tagext.TagSupport;
+
+/**
+ * 自定义 JSP 标签类，用于对文档描述文本进行处理和输出
+ * 可限制文本显示的最大长度，超过部分用省略号替代
+ */
+public class DocDescribe extends TagSupport {
+ /**
+ * 文档描述文本
+ */
+ private String text;
+ /**
+ * 文本显示的最大长度
+ */
+ private int maxnum;
+ /**
+ * 序列化版本号，用于在序列化和反序列化对象时保证版本的兼容性
+ */
+ private static final long serialVersionUID = 1895493540131375513L;
+
+ /**
+ * 处理标签结束时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码，0 表示继续处理页面剩余部分
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doEndTag() throws JspException {
+ // 从当前页面上下文获取 JSP 输出流，用于向页面输出内容
+ JspWriter jspw = this.pageContext.getOut();
+ try {
+ // 检查文本是否不为空且去除首尾空格后长度大于 0
+ if (text != null && text.trim().length() > 0) {
+ // 判断文本去除首尾空格后的长度是否超过最大显示长度
+ if (text.trim().length() > maxnum) {
+ // 若超过，截取前 maxnum 个字符并添加省略号后输出
+ jspw.println(text.substring(0, maxnum) + "...");
+ } else {
+ // 若未超过，直接输出文本
+ jspw.println(text);
+ }
+ }
+ } catch (IOException e) {
+ // 若输出过程中发生输入输出异常，打印异常堆栈信息
+ e.printStackTrace();
+ }
+ return 0;
+ }
+
+ /**
+ * 处理标签开始时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码，0 表示继续处理页面剩余部分
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ // 此标签在开始时不进行特殊处理，直接返回 0 继续页面处理
+ return 0;
+ }
+
+ /**
+ * 获取文档描述文本
+ *
+ * @return 文档描述文本
+ */
+ public String getText() {
+ return text;
+ }
+
+ /**
+ * 设置文档描述文本
+ *
+ * @param text 要设置的文档描述文本
+ */
+ public void setText(String text) {
+ this.text = text;
+ }
+
+ /**
+ * 获取文本显示的最大长度
+ *
+ * @return 文本显示的最大长度
+ */
+ public int getMaxnum() {
+ return maxnum;
+ }
+
+ /**
+ * 设置文本显示的最大长度
+ *
+ * @param maxnum 要设置的文本显示最大长度
+ */
+ public void setMaxnum(int maxnum) {
+ this.maxnum = maxnum;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/DocGroupOption.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/DocGroupOption.java
new file mode 100644
index 0000000..52f4e14
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/DocGroupOption.java
@@ -0,0 +1,145 @@
+// 声明该类所在的包
+package com.farm.doc.tag;
+
+// 导入处理输入输出异常的类
+import java.io.IOException;
+// 导入迭代器接口，用于遍历集合
+import java.util.Iterator;
+// 导入列表接口
+import java.util.List;
+// 导入映射接口
+import java.util.Map;
+
+// 导入 HTTP 请求类
+import javax.servlet.http.HttpServletRequest;
+// 导入 JSP 异常类
+import javax.servlet.jsp.JspException;
+// 导入 JSP 输出流类
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 标签支持类
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入 Log4j 日志记录器类
+import org.apache.log4j.Logger;
+
+// 导入登录用户实体类
+import com.farm.core.auth.domain.LoginUser;
+// 导入文档组管理接口
+import com.farm.doc.server.FarmDocgroupManagerInter;
+// 导入 Spring 工具类，用于获取 Bean 对象
+import com.farm.util.spring.BeanFactory;
+// 导入农场系统的常量类
+import com.farm.web.constant.FarmConstant;
+
+/**
+ * 自定义 JSP 标签类，用于生成文档组的 HTML 选项列表
+ */
+public class DocGroupOption extends TagSupport {
+ /**
+ * 环绕在文档组名称前的字符串
+ */
+ private String aroundS;
+ /**
+ * 环绕在文档组名称后的字符串
+ */
+ private String aroundE;
+ /**
+ * 序列化版本号，用于确保序列化和反序列化的兼容性
+ */
+ private static final long serialVersionUID = 1895493540131375513L;
+ /**
+ * 通过 Spring 的 BeanFactory 获取文档组管理的实现类实例，使用单例模式
+ */
+ private final static FarmDocgroupManagerInter docGroupIMP = (FarmDocgroupManagerInter) BeanFactory
+ .getBean("farmDocgroupManagerImpl");
+ /**
+ * 创建一个日志记录器，用于记录该类相关的日志信息
+ */
+ private static final Logger log = Logger.getLogger(DocGroupOption.class);
+
+ /**
+ * 处理标签结束时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public int doEndTag() throws JspException {
+ // 从当前页面上下文获取 HTTP 请求对象
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 从会话中获取当前登录用户的信息
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 根据用户 ID 获取用户可编辑的文档组列表
+ List> list = docGroupIMP.getEditorGroupByUser(user
+ .getId());
+ // 从当前页面上下文获取 JSP 输出流
+ JspWriter jspw = this.pageContext.getOut();
+ // 遍历文档组列表
+ for (Iterator iterator = list.iterator(); iterator.hasNext();) {
+ // 获取当前文档组的信息
+ Map type = (Map) iterator.next();
+ try {
+ // 生成 HTML 选项标签，并将文档组的 ID 和名称输出到 JSP 页面
+ jspw.println("");
+ } catch (IOException e) {
+ // 如果输出过程中发生 IO 异常，使用日志记录器记录异常信息
+ // TODO Auto-generated catch block
+ log.error(e.getMessage());
+ }
+ }
+ return 0;
+ }
+
+ /**
+ * 处理标签开始时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ // 这里暂时没有具体的逻辑，可根据需求后续添加
+ return 0;
+ }
+
+ /**
+ * 获取环绕在文档组名称前的字符串
+ *
+ * @return 环绕在文档组名称前的字符串
+ */
+ public String getAroundS() {
+ return aroundS;
+ }
+
+ /**
+ * 设置环绕在文档组名称前的字符串
+ *
+ * @param aroundS 要设置的环绕在文档组名称前的字符串
+ */
+ public void setAroundS(String aroundS) {
+ this.aroundS = aroundS;
+ }
+
+ /**
+ * 获取环绕在文档组名称后的字符串
+ *
+ * @return 环绕在文档组名称后的字符串
+ */
+ public String getAroundE() {
+ return aroundE;
+ }
+
+ /**
+ * 设置环绕在文档组名称后的字符串
+ *
+ * @param aroundE 要设置的环绕在文档组名称后的字符串
+ */
+ public void setAroundE(String aroundE) {
+ this.aroundE = aroundE;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/ImgUrl.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/ImgUrl.java
new file mode 100644
index 0000000..d0be683
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/ImgUrl.java
@@ -0,0 +1,86 @@
+// 声明该类所在的包
+package com.farm.doc.tag;
+
+// 导入处理输入输出异常的类，用于处理可能的文件读取或输出异常
+import java.io.IOException;
+
+// 导入 JSP 异常类，用于处理 JSP 标签处理过程中可能出现的异常
+import javax.servlet.jsp.JspException;
+// 导入 JSP 输出流类，用于向 JSP 页面输出内容
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 标签支持类，是自定义 JSP 标签的基础类
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入文件管理接口，用于获取文件相关信息
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入 Spring 工具类，用于从 Spring 容器中获取 Bean 对象
+import com.farm.util.spring.BeanFactory;
+
+/**
+ * 自定义 JSP 标签类，用于获取并输出指定文件的 URL
+ */
+public class ImgUrl extends TagSupport {
+ /**
+ * 存储文件的唯一标识 ID
+ */
+ private String fileid;
+ /**
+ * 通过 Spring 的 BeanFactory 获取文件管理的实现类实例，使用单例模式
+ */
+ private final static FarmFileManagerInter aloneIMP = (FarmFileManagerInter) BeanFactory
+ .getBean("farmFileManagerImpl");
+ /**
+ * 序列化版本号，用于在序列化和反序列化对象时保证版本的兼容性
+ */
+ private static final long serialVersionUID = 1895493540131375513L;
+
+ /**
+ * 处理标签结束时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码，0 表示继续处理页面剩余部分
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doEndTag() throws JspException {
+ // 从当前页面上下文获取 JSP 输出流，用于向页面输出内容
+ JspWriter jspw = this.pageContext.getOut();
+ try {
+ // 调用文件管理实现类的方法获取文件的 URL，并将其输出到 JSP 页面
+ jspw.println(aloneIMP.getFileURL(fileid));
+ } catch (IOException e) {
+ // 如果在获取或输出文件 URL 过程中发生输入输出异常，打印异常堆栈信息
+ e.printStackTrace();
+ }
+ return 0;
+ }
+
+ /**
+ * 处理标签开始时的逻辑
+ *
+ * @return 表示标签处理完成后页面继续执行的状态码，0 表示继续处理页面剩余部分
+ * @throws JspException 如果在处理标签时发生 JSP 相关的异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ // 此标签在开始时不进行特殊处理，直接返回 0 继续页面处理
+ return 0;
+ }
+
+ /**
+ * 获取文件的唯一标识 ID
+ *
+ * @return 文件的唯一标识 ID
+ */
+ public String getFileid() {
+ return fileid;
+ }
+
+ /**
+ * 设置文件的唯一标识 ID
+ *
+ * @param fileid 要设置的文件的唯一标识 ID
+ */
+ public void setFileid(String fileid) {
+ this.fileid = fileid;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/NoDelIsShowForUser.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/NoDelIsShowForUser.java
new file mode 100644
index 0000000..2c9c9df
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/NoDelIsShowForUser.java
@@ -0,0 +1,223 @@
+package com.farm.doc.tag;
+// 声明该类所在的包
+
+import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于处理HTTP请求相关操作
+
+import javax.servlet.jsp.JspException;
+// 导入JspException类，用于处理JSP标签相关的异常
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入TagSupport类，作为自定义JSP标签的基类
+
+import com.farm.core.auth.domain.LoginUser;
+// 导入LoginUser类，代表登录用户的实体类
+
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入FarmDocManagerInter接口，用于文档管理相关操作
+
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入FarmDocOperateRightInter接口，用于处理文档操作权限相关逻辑
+
+import com.farm.util.spring.BeanFactory;
+// 导入BeanFactory类，用于从Spring容器中获取Bean对象
+
+import com.farm.web.constant.FarmConstant;
+// 导入FarmConstant类，包含一些农场系统相关的常量
+
+public class NoDelIsShowForUser extends TagSupport {
+ private String docId;
+ // 定义一个字符串类型的成员变量docId，用于存储文档的ID
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，用于在对象序列化和反序列化时保持兼容性
+
+ private final static FarmDocOperateRightInter aloneIMP = (FarmDocOperateRightInter) BeanFactory
+ .getBean("farmDocOperateRightImpl");
+ // 从Spring容器中获取FarmDocOperateRightInter接口的实现类实例，命名为aloneIMP，采用单例模式
+
+ private final static FarmDocManagerInter docIMP = (FarmDocManagerInter) BeanFactory.getBean("farmDocManagerImpl");
+ // 从Spring容器中获取FarmDocManagerInter接口的实现类实例，命名为docIMP，采用单例模式
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ // 重写doEndTag方法，返回EVAL_PAGE，表示继续处理页面的剩余部分
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 从当前页面上下文获取HttpServletRequest对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 从当前请求的会话中获取名为FarmConstant.SESSION_USEROBJ的属性值，并强转为LoginUser类型，即获取当前登录用户
+
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回SKIP_BODY则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (!aloneIMP.isDel(user, docIMP.getDocOnlyBean(docId))) {
+ // 调用aloneIMP的isDel方法，判断当前用户对指定文档是否没有删除权限
+ // 如果没有删除权限
+ return EVAL_BODY_INCLUDE;
+ // 返回EVAL_BODY_INCLUDE，意味着执行自定义标签的标签体内容
+ }
+ return SKIP_BODY;
+ // 如果用户有删除权限，则返回SKIP_BODY，忽略自定义标签的标签体内容
+ }
+
+ public String getDocId() {
+ return docId;
+ // 返回文档ID的getter方法
+ }
+
+ public void setDocId(String docId) {
+ this.docId = docId;
+ // 设置文档ID的setter方法
+ }
+
+ // 以下是扩展部分代码，用于增加更多的功能逻辑和注释说明
+
+ // 增加一个方法，用于获取文档的一些基本信息，如标题等
+ private String getDocTitle(String docId) {
+ try {
+ // 尝试获取文档的基本信息
+ com.farm.doc.domain.DocBaseInfo docBaseInfo = docIMP.getDocBaseInfo(docId);
+ // 调用docIMP的方法获取文档基本信息对象
+ if (docBaseInfo != null) {
+ // 如果文档基本信息对象不为空
+ return docBaseInfo.getTitle();
+ // 返回文档的标题
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，用于判断用户是否有其他操作权限，比如编辑权限
+ private boolean hasEditPermission(LoginUser user, String docId) {
+ try {
+ // 尝试判断用户是否有编辑权限
+ return aloneIMP.isEdit(user, docIMP.getDocOnlyBean(docId));
+ // 调用aloneIMP的isEdit方法，返回判断结果
+ } catch (Exception e) {
+ // 如果在判断过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return false;
+ // 如果判断失败，返回false
+ }
+
+ // 在doStartTag方法中增加一些额外的逻辑，比如根据用户权限和文档状态进行不同处理
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 再次获取HttpServletRequest对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 再次获取当前登录用户
+
+ // 先判断用户是否有删除权限
+ if (!aloneIMP.isDel(user, docIMP.getDocOnlyBean(docId))) {
+ // 如果没有删除权限
+ // 再判断用户是否有编辑权限
+ if (hasEditPermission(user, docId)) {
+ // 如果有编辑权限
+ // 可以在这里添加一些特殊处理，比如在标签体中显示编辑相关提示
+ // 这里简单打印一条日志
+ System.out.println("用户有编辑权限但没有删除权限，文档ID: " + docId);
+ }
+ return EVAL_BODY_INCLUDE;
+ // 返回EVAL_BODY_INCLUDE，执行标签体内容
+ } else {
+ // 如果用户有删除权限
+ // 判断文档是否处于锁定状态（假设存在这样的逻辑）
+ boolean isDocLocked = isDocLocked(docId);
+ if (isDocLocked) {
+ // 如果文档处于锁定状态
+ // 可以在这里添加一些提示，比如不允许删除
+ System.out.println("文档处于锁定状态，不允许删除，文档ID: " + docId);
+ }
+ }
+ return SKIP_BODY;
+ // 返回SKIP_BODY，忽略标签体内容
+ }
+
+ // 增加一个方法，用于判断文档是否处于锁定状态（假设存在这样的方法在服务层）
+ private boolean isDocLocked(String docId) {
+ try {
+ // 尝试判断文档是否锁定
+ com.farm.doc.domain.DocStatusInfo docStatusInfo = docIMP.getDocStatusInfo(docId);
+ // 调用docIMP的方法获取文档状态信息对象
+ if (docStatusInfo != null) {
+ // 如果文档状态信息对象不为空
+ return docStatusInfo.isLocked();
+ // 返回文档是否锁定的状态
+ }
+ } catch (Exception e) {
+ // 如果在判断过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return false;
+ // 如果判断失败，返回false
+ }
+
+ // 增加一个方法，用于获取文档的创建时间
+ private String getDocCreateTime(String docId) {
+ try {
+ // 尝试获取文档的创建时间
+ com.farm.doc.domain.DocHistoryInfo docHistoryInfo = docIMP.getDocHistoryInfo(docId);
+ // 调用docIMP的方法获取文档历史信息对象
+ if (docHistoryInfo != null) {
+ // 如果文档历史信息对象不为空
+ return docHistoryInfo.getCreateTime();
+ // 返回文档的创建时间
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，用于根据文档创建时间进行一些简单的提示
+ private void printDocCreateTimeHint(String docId) {
+ String createTime = getDocCreateTime(docId);
+ // 获取文档的创建时间
+ if (!createTime.isEmpty()) {
+ // 如果创建时间不为空
+ System.out.println("文档创建时间: " + createTime + "，文档ID: " + docId);
+ // 打印文档创建时间和文档ID的提示信息
+ }
+ }
+
+ // 在doStartTag方法中调用打印创建时间提示的方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 获取HttpServletRequest对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printDocCreateTimeHint(docId);
+ // 调用方法打印文档创建时间提示
+
+ // 执行原有的权限判断逻辑
+ if (!aloneIMP.isDel(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/NoReadIsShowForUser.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/NoReadIsShowForUser.java
new file mode 100644
index 0000000..ed3b792
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/NoReadIsShowForUser.java
@@ -0,0 +1,260 @@
+package com.farm.doc.tag;
+// 声明该类所在的包
+
+import javax.servlet.http.HttpServletRequest;
+// 导入用于处理 HTTP 请求的类，以便获取请求相关信息
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 相关的异常类，用于处理标签执行过程中可能抛出的异常
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 JSP 标签支持类，作为自定义标签的基类
+
+import com.farm.core.auth.domain.LoginUser;
+// 导入代表登录用户的实体类，用于获取用户相关信息
+
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入文档管理接口，用于获取文档相关信息和操作
+
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入文档操作权限接口，用于判断用户对文档的操作权限
+
+import com.farm.util.spring.BeanFactory;
+// 导入 Spring 工具类，用于从 Spring 容器中获取 Bean 对象
+
+import com.farm.web.constant.FarmConstant;
+// 导入包含农场系统相关常量的类，如会话中用户对象的键名等
+
+public class NoReadIsShowForUser extends TagSupport {
+ private String docId;
+ // 定义一个字符串类型的成员变量，用于存储文档的 ID
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，用于保证对象在序列化和反序列化过程中的兼容性
+
+ private final static FarmDocOperateRightInter aloneIMP = (FarmDocOperateRightInter) BeanFactory
+ .getBean("farmDocOperateRightImpl");
+ // 从 Spring 容器中获取文档操作权限接口的实现类实例，采用单例模式
+
+ private final static FarmDocManagerInter docIMP = (FarmDocManagerInter) BeanFactory
+ .getBean("farmDocManagerImpl");
+ // 从 Spring 容器中获取文档管理接口的实现类实例，采用单例模式
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ // 重写 doEndTag 方法，返回 EVAL_PAGE 表示继续处理页面的剩余部分
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 从当前页面上下文获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 从请求的会话中获取名为 FarmConstant.SESSION_USEROBJ 的属性值，并转换为 LoginUser 类型，即获取当前登录用户
+
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回 SKIP_BODY 则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (!aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ // 调用 aloneIMP 的 isRead 方法，判断当前用户对指定文档是否没有读取权限
+ // 如果没有读取权限
+ return EVAL_BODY_INCLUDE;
+ // 返回 EVAL_BODY_INCLUDE，意味着执行自定义标签的标签体内容
+ }
+ return SKIP_BODY;
+ // 如果用户有读取权限，则返回 SKIP_BODY，忽略自定义标签的标签体内容
+ }
+
+ public String getDocId() {
+ return docId;
+ // 返回文档 ID 的 getter 方法
+ }
+
+ public void setDocId(String docId) {
+ this.docId = docId;
+ // 设置文档 ID 的 setter 方法
+ }
+
+ // 扩展部分开始
+
+ // 增加一个方法，用于获取文档的类型信息
+ private String getDocType(String docId) {
+ try {
+ // 尝试获取文档类型信息
+ com.farm.doc.domain.DocTypeInfo docTypeInfo = docIMP.getDocTypeInfo(docId);
+ // 调用 docIMP 的方法获取文档类型信息对象
+ if (docTypeInfo != null) {
+ // 如果文档类型信息对象不为空
+ return docTypeInfo.getType();
+ // 返回文档的类型
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，判断文档是否为敏感类型（假设存在这样的判断逻辑）
+ private boolean isSensitiveDoc(String docId) {
+ String docType = getDocType(docId);
+ // 获取文档类型
+ if ("sensitive".equals(docType)) {
+ // 如果文档类型为敏感类型（这里假设敏感类型的标识为 "sensitive"）
+ return true;
+ // 返回 true
+ }
+ return false;
+ // 否则返回 false
+ }
+
+ // 增加一个方法，根据用户权限和文档类型进行一些额外的提示或操作
+ private void performExtraOperation(LoginUser user, String docId) {
+ if (isSensitiveDoc(docId)) {
+ // 如果文档是敏感类型
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ // 如果用户有读取权限
+ System.out.println("用户有读取权限，且文档为敏感类型，文档 ID: " + docId);
+ // 打印提示信息
+ } else {
+ System.out.println("用户无读取权限，且文档为敏感类型，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在 doStartTag 方法中调用上述增加的方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ performExtraOperation(user, docId);
+ // 调用方法进行额外的操作
+
+ // 执行原有的权限判断逻辑
+ if (!aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，用于获取文档的最近修改时间
+ private String getDocLastModifyTime(String docId) {
+ try {
+ // 尝试获取文档的最近修改时间
+ com.farm.doc.domain.DocModifyHistory docModifyHistory = docIMP.getDocModifyHistory(docId);
+ // 调用 docIMP 的方法获取文档修改历史对象
+ if (docModifyHistory != null) {
+ // 如果文档修改历史对象不为空
+ return docModifyHistory.getLastModifyTime();
+ // 返回文档的最近修改时间
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，根据文档的最近修改时间进行一些提示
+ private void printDocModifyTimeHint(String docId) {
+ String lastModifyTime = getDocLastModifyTime(docId);
+ // 获取文档的最近修改时间
+ if (!lastModifyTime.isEmpty()) {
+ // 如果最近修改时间不为空
+ System.out.println("文档最近修改时间: " + lastModifyTime + "，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+
+ // 在 doStartTag 方法中调用打印最近修改时间提示的方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printDocModifyTimeHint(docId);
+ // 调用方法打印文档最近修改时间提示
+
+ performExtraOperation(user, docId);
+ // 调用方法进行额外的操作
+
+ // 执行原有的权限判断逻辑
+ if (!aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，用于判断用户是否是文档的创建者
+ private boolean isDocCreator(LoginUser user, String docId) {
+ try {
+ // 尝试判断用户是否是文档的创建者
+ com.farm.doc.domain.DocCreatorInfo docCreatorInfo = docIMP.getDocCreatorInfo(docId);
+ // 调用 docIMP 的方法获取文档创建者信息对象
+ if (docCreatorInfo != null) {
+ // 如果文档创建者信息对象不为空
+ return docCreatorInfo.getCreatorId().equals(user.getId());
+ // 判断创建者 ID 是否与当前用户 ID 相等
+ }
+ } catch (Exception e) {
+ // 如果在判断过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return false;
+ // 如果判断失败，返回 false
+ }
+
+ // 在 doStartTag 方法中根据用户是否是创建者进行一些额外处理
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printDocModifyTimeHint(docId);
+ // 调用方法打印文档最近修改时间提示
+
+ performExtraOperation(user, docId);
+ // 调用方法进行额外的操作
+
+ if (isDocCreator(user, docId)) {
+ // 如果用户是文档的创建者
+ System.out.println("用户是文档的创建者，文档 ID: " + docId);
+ // 打印提示信息
+ }
+
+ // 执行原有的权限判断逻辑
+ if (!aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+}
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/NoWriteIsShowForUser.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/NoWriteIsShowForUser.java
new file mode 100644
index 0000000..00add8e
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/NoWriteIsShowForUser.java
@@ -0,0 +1,268 @@
+package com.farm.doc.tag;
+// 声明该类所在的包
+
+import javax.servlet.http.HttpServletRequest;
+// 导入用于处理 HTTP 请求的类，以便在标签中获取请求相关信息
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 相关的异常类，用于处理标签执行过程中可能出现的异常情况
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 JSP 标签支持类，作为自定义标签的基础类，该类提供了标签处理的基本方法和属性
+
+import com.farm.core.auth.domain.LoginUser;
+// 导入代表登录用户的实体类，用于获取当前登录用户的信息
+
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入文档管理接口，用于获取和操作文档相关的信息和功能
+
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入文档操作权限接口，用于判断用户对文档的各种操作权限
+
+import com.farm.util.spring.BeanFactory;
+// 导入 Spring 工具类，用于从 Spring 容器中获取 Bean 对象，这里用于获取文档管理和权限管理的实现类实例
+
+import com.farm.web.constant.FarmConstant;
+// 导入包含农场系统相关常量的类，例如会话中存储用户对象的键名等
+
+public class NoWriteIsShowForUser extends TagSupport {
+ private String docId;
+ // 定义一个字符串类型的成员变量，用于存储文档的唯一标识 ID
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，用于保证对象在序列化和反序列化过程中的兼容性，确保版本一致性
+
+ private final static FarmDocOperateRightInter aloneIMP = (FarmDocOperateRightInter) BeanFactory
+ .getBean("farmDocOperateRightImpl");
+ // 从 Spring 容器中获取文档操作权限接口的实现类实例，采用单例模式，命名为 aloneIMP
+
+ private final static FarmDocManagerInter docIMP = (FarmDocManagerInter) BeanFactory
+ .getBean("farmDocManagerImpl");
+ // 从 Spring 容器中获取文档管理接口的实现类实例，采用单例模式，命名为 docIMP
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ // 重写 doEndTag 方法，返回 EVAL_PAGE 表示继续处理当前页面的剩余部分，即标签处理结束后页面正常继续执行
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 从当前页面上下文获取 HttpServletRequest 对象，以便获取请求相关的信息，如会话等
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 从请求的会话中获取名为 FarmConstant.SESSION_USEROBJ 的属性值，并将其转换为 LoginUser 类型，从而获取当前登录用户的信息
+
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回 SKIP_BODY 则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (!aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 调用 aloneIMP 的 isWrite 方法，判断当前用户对指定文档是否没有写入权限
+ // 如果没有写入权限
+ return EVAL_BODY_INCLUDE;
+ // 返回 EVAL_BODY_INCLUDE，意味着执行自定义标签的标签体内容
+ }
+ return SKIP_BODY;
+ // 如果用户有写入权限，则返回 SKIP_BODY，忽略自定义标签的标签体内容
+ }
+
+ public String getDocId() {
+ return docId;
+ // 定义获取文档 ID 的方法，返回存储的文档 ID
+ }
+
+ public void setDocId(String docId) {
+ this.docId = docId;
+ // 定义设置文档 ID 的方法，将传入的文档 ID 赋值给成员变量 docId
+ }
+
+ // 扩展部分开始
+
+ // 增加一个方法，用于获取文档的创建时间
+ private String getDocCreateTime(String docId) {
+ try {
+ // 尝试获取文档的创建时间
+ com.farm.doc.domain.DocCreateTimeInfo createTimeInfo = docIMP.getDocCreateTimeInfo(docId);
+ // 调用 docIMP 的方法获取文档创建时间信息对象
+ if (createTimeInfo != null) {
+ // 如果创建时间信息对象不为空
+ return createTimeInfo.getCreateTime();
+ // 返回文档的创建时间
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，判断文档创建时间是否在一定时间范围内（假设为 30 天内）
+ private boolean isDocCreatedRecently(String docId) {
+ String createTime = getDocCreateTime(docId);
+ // 获取文档的创建时间
+ if (!createTime.isEmpty()) {
+ // 如果创建时间不为空
+ // 这里简单模拟时间比较，假设时间格式为 yyyy-MM-dd
+ // 实际应用中需要更准确的时间处理逻辑
+ java.time.LocalDate currentDate = java.time.LocalDate.now();
+ java.time.LocalDate createLocalDate = java.time.LocalDate.parse(createTime.split(" ")[0]);
+ java.time.Period period = java.time.Period.between(createLocalDate, currentDate);
+ return period.getDays() <= 30;
+ // 判断时间间隔是否在 30 天内
+ }
+ return false;
+ // 如果创建时间为空，返回 false
+ }
+
+ // 增加一个方法，根据文档创建时间和写入权限进行额外提示
+ private void printExtraHint(LoginUser user, String docId) {
+ if (isDocCreatedRecently(docId)) {
+ // 如果文档是在最近创建的
+ if (!aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户没有写入权限
+ System.out.println("文档最近创建，但您没有写入权限，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在 doStartTag 方法中调用打印额外提示的方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printExtraHint(user, docId);
+ // 调用方法打印额外提示
+
+ // 执行原有的权限判断逻辑
+ if (!aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，用于获取文档的大小信息（假设存在这样的获取方法）
+ private long getDocSize(String docId) {
+ try {
+ // 尝试获取文档大小信息
+ com.farm.doc.domain.DocSizeInfo sizeInfo = docIMP.getDocSizeInfo(docId);
+ // 调用 docIMP 的方法获取文档大小信息对象
+ if (sizeInfo != null) {
+ // 如果大小信息对象不为空
+ return sizeInfo.getSize();
+ // 返回文档的大小
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return 0;
+ // 如果获取失败，返回 0
+ }
+
+ // 增加一个方法，根据文档大小和写入权限进行操作提示
+ private void printSizeHint(LoginUser user, String docId) {
+ long size = getDocSize(docId);
+ // 获取文档大小
+ if (size > 1024 * 1024) {
+ // 如果文档大小大于 1MB
+ if (!aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户没有写入权限
+ System.out.println("文档较大（大于 1MB），但您没有写入权限，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在 doStartTag 方法中调用打印大小提示的方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printExtraHint(user, docId);
+ // 调用方法打印额外提示
+
+ printSizeHint(user, docId);
+ // 调用方法打印大小提示
+
+ // 执行原有的权限判断逻辑
+ if (!aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，判断用户是否是文档的所有者（假设存在所有者信息获取方法）
+ private boolean isDocOwner(LoginUser user, String docId) {
+ try {
+ // 尝试判断用户是否是文档的所有者
+ com.farm.doc.domain.DocOwnerInfo ownerInfo = docIMP.getDocOwnerInfo(docId);
+ // 调用 docIMP 的方法获取文档所有者信息对象
+ if (ownerInfo != null) {
+ // 如果所有者信息对象不为空
+ return ownerInfo.getOwnerId().equals(user.getId());
+ // 判断所有者 ID 是否与当前用户 ID 相等
+ }
+ } catch (Exception e) {
+ // 如果在判断过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return false;
+ // 如果判断失败，返回 false
+ }
+
+ // 在 doStartTag 方法中根据用户是否是所有者进行额外处理
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printExtraHint(user, docId);
+ // 调用方法打印额外提示
+
+ printSizeHint(user, docId);
+ // 调用方法打印大小提示
+
+ if (isDocOwner(user, docId)) {
+ // 如果用户是文档的所有者
+ if (!aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 但用户没有写入权限
+ System.out.println("您是文档的所有者，但没有写入权限，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+
+ // 执行原有的权限判断逻辑
+ if (!aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/ReadIsShowForUser.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/ReadIsShowForUser.java
new file mode 100644
index 0000000..3fbeec4
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/ReadIsShowForUser.java
@@ -0,0 +1,285 @@
+package com.farm.doc.tag;
+// 声明该类所在的包
+
+import javax.servlet.http.HttpServletRequest;
+// 导入用于处理 HTTP 请求的类，以便获取请求相关信息，如会话、参数等
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 相关的异常类，用于处理标签执行过程中可能抛出的异常
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 JSP 标签支持类，作为自定义 JSP 标签的基类，提供标签处理的基本结构和方法
+
+import com.farm.core.auth.domain.LoginUser;
+// 导入代表登录用户的实体类，用于获取当前登录用户的详细信息
+
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入文档管理接口，用于获取和操作文档相关的信息，如文档详情、创建时间等
+
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入文档操作权限接口，用于判断用户对文档的各种操作权限，如读取、写入等
+
+import com.farm.util.spring.BeanFactory;
+// 导入 Spring 工具类，用于从 Spring 容器中获取 Bean 对象，这里用于获取文档管理和权限管理的实现类实例
+
+import com.farm.web.constant.FarmConstant;
+// 导入包含农场系统相关常量的类，例如会话中存储用户对象的键名等
+
+public class ReadIsShowForUser extends TagSupport {
+ private String docId;
+ // 定义一个字符串类型的成员变量，用于存储要判断权限的文档的唯一标识 ID
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，用于保证对象在序列化和反序列化过程中的兼容性，确保对象的状态在不同环境下能够正确恢复
+
+ private final static FarmDocOperateRightInter aloneIMP = (FarmDocOperateRightInter) BeanFactory
+ .getBean("farmDocOperateRightImpl");
+ // 从 Spring 容器中获取文档操作权限接口的实现类实例，采用单例模式，命名为 aloneIMP
+
+ private final static FarmDocManagerInter docIMP = (FarmDocManagerInter) BeanFactory
+ .getBean("farmDocManagerImpl");
+ // 从 Spring 容器中获取文档管理接口的实现类实例，采用单例模式，命名为 docIMP
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ // 重写 doEndTag 方法，返回 EVAL_PAGE 表示继续处理页面的剩余部分，即标签处理完成后，页面会继续执行后续的内容
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 从当前页面上下文获取 HttpServletRequest 对象，以便获取与当前请求相关的信息，如会话、请求参数等
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 从当前请求的会话中获取名为 FarmConstant.SESSION_USEROBJ 的属性值，并将其转换为 LoginUser 类型，从而获取当前登录用户的信息
+
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回 SKIP_BODY 则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ // 调用 aloneIMP 的 isRead 方法，传入当前登录用户 user 和通过 docIMP 获取的指定文档的基本信息对象 docOnlyBean(docId)
+ // 判断当前用户对指定文档是否具有读取权限
+ // 如果具有读取权限
+ return EVAL_BODY_INCLUDE;
+ // 返回 EVAL_BODY_INCLUDE，意味着执行自定义标签的标签体内容
+ }
+ return SKIP_BODY;
+ // 如果用户不具有读取权限，则返回 SKIP_BODY，忽略自定义标签的标签体内容
+ }
+
+ public String getDocId() {
+ return docId;
+ // 定义获取文档 ID 的方法，返回存储在成员变量 docId 中的文档 ID
+ }
+
+ public void setDocId(String docId) {
+ this.docId = docId;
+ // 定义设置文档 ID 的方法，将传入的文档 ID 值赋值给成员变量 docId
+ }
+
+ // 扩展部分开始
+
+ // 增加一个方法，用于获取文档的所属类别信息
+ private String getDocCategory(String docId) {
+ try {
+ // 尝试获取文档的所属类别信息
+ com.farm.doc.domain.DocCategoryInfo categoryInfo = docIMP.getDocCategoryInfo(docId);
+ // 调用 docIMP 的方法获取文档类别信息对象
+ if (categoryInfo != null) {
+ // 如果文档类别信息对象不为空
+ return categoryInfo.getCategoryName();
+ // 返回文档的类别名称
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，判断文档所属类别是否为重要类别（假设存在重要类别的定义）
+ private boolean isImportantCategory(String docId) {
+ String category = getDocCategory(docId);
+ // 获取文档的类别名称
+ if ("important".equals(category)) {
+ // 假设重要类别的标识为 "important"
+ return true;
+ // 如果是重要类别，返回 true
+ }
+ return false;
+ // 否则返回 false
+ }
+
+ // 增加一个方法，根据文档所属类别和读取权限进行额外提示
+ private void printCategoryHint(LoginUser user, String docId) {
+ if (isImportantCategory(docId)) {
+ // 如果文档属于重要类别
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户具有读取权限
+ System.out.println("文档属于重要类别，您具有读取权限，文档 ID: " + docId);
+ // 打印提示信息
+ } else {
+ System.out.println("文档属于重要类别，但您没有读取权限，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在 doStartTag 方法中调用打印类别提示的方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printCategoryHint(user, docId);
+ // 调用方法打印关于文档类别的提示信息
+
+ // 执行原有的权限判断逻辑
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，用于获取文档的最后更新时间
+ private String getDocLastUpdateTime(String docId) {
+ try {
+ // 尝试获取文档的最后更新时间
+ com.farm.doc.domain.DocUpdateTimeInfo updateTimeInfo = docIMP.getDocUpdateTimeInfo(docId);
+ // 调用 docIMP 的方法获取文档更新时间信息对象
+ if (updateTimeInfo != null) {
+ // 如果更新时间信息对象不为空
+ return updateTimeInfo.getLastUpdateTime();
+ // 返回文档的最后更新时间
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，判断文档是否在最近一周内更新过（假设时间格式支持相关操作）
+ private boolean isDocUpdatedRecently(String docId) {
+ String lastUpdateTime = getDocLastUpdateTime(docId);
+ // 获取文档的最后更新时间
+ if (!lastUpdateTime.isEmpty()) {
+ // 如果最后更新时间不为空
+ java.time.LocalDateTime now = java.time.LocalDateTime.now();
+ java.time.LocalDateTime updateDateTime = java.time.LocalDateTime.parse(lastUpdateTime);
+ java.time.Duration duration = java.time.Duration.between(updateDateTime, now);
+ return duration.toDays() <= 7;
+ // 判断时间间隔是否在一周内
+ }
+ return false;
+ // 如果最后更新时间为空，返回 false
+ }
+
+ // 增加一个方法，根据文档更新时间和读取权限进行提示
+ private void printUpdateHint(LoginUser user, String docId) {
+ if (isDocUpdatedRecently(docId)) {
+ // 如果文档在最近一周内更新过
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户具有读取权限
+ System.out.println("文档最近更新过，您具有读取权限，文档 ID: " + docId);
+ // 打印提示信息
+ } else {
+ System.out.println("文档最近更新过，但您没有读取权限，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在 doStartTag 方法中调用打印更新提示的方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printCategoryHint(user, docId);
+ // 调用打印类别提示的方法
+
+ printUpdateHint(user, docId);
+ // 调用打印更新提示的方法
+
+ // 执行原有的权限判断逻辑
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，判断用户是否是文档的创建者（假设存在获取创建者信息的方法）
+ private boolean isDocCreator(LoginUser user, String docId) {
+ try {
+ // 尝试判断用户是否是文档的创建者
+ com.farm.doc.domain.DocCreatorInfo creatorInfo = docIMP.getDocCreatorInfo(docId);
+ // 调用 docIMP 的方法获取文档创建者信息对象
+ if (creatorInfo != null) {
+ // 如果创建者信息对象不为空
+ return creatorInfo.getCreatorId().equals(user.getId());
+ // 判断创建者 ID 是否与当前用户 ID 相等
+ }
+ } catch (Exception e) {
+ // 如果在判断过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return false;
+ // 如果判断失败，返回 false
+ }
+
+ // 在 doStartTag 方法中根据用户是否是创建者进行额外处理
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 获取 HttpServletRequest 对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(
+ FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printCategoryHint(user, docId);
+ // 调用打印类别提示的方法
+
+ printUpdateHint(user, docId);
+ // 调用打印更新提示的方法
+
+ if (isDocCreator(user, docId)) {
+ // 如果用户是文档的创建者
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户具有读取权限
+ System.out.println("您是文档的创建者，且具有读取权限，文档 ID: " + docId);
+ // 打印提示信息
+ }
+ }
+
+ // 执行原有的权限判断逻辑
+ if (aloneIMP.isRead(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+}
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/WriteIsShowForUser.java b/src/wcp-tag/src/main/java/com/farm/doc/tag/WriteIsShowForUser.java
new file mode 100644
index 0000000..c664447
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/WriteIsShowForUser.java
@@ -0,0 +1,285 @@
+package com.farm.doc.tag;
+// 声明该类所在的包
+
+import javax.servlet.http.HttpServletRequest;
+// 导入用于处理HTTP请求的类，以便获取请求相关的信息，如会话、请求参数等
+
+import javax.servlet.jsp.JspException;
+// 导入JSP相关的异常类，用于处理在标签执行过程中可能抛出的异常
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入JSP标签支持类，作为自定义JSP标签的基类，提供标签处理的基本方法和属性
+
+import com.farm.core.auth.domain.LoginUser;
+// 导入代表登录用户的实体类，用于获取当前登录用户的详细信息
+
+import com.farm.doc.server.FarmDocManagerInter;
+// 导入文档管理接口，用于获取和管理文档的相关信息，如文档详情、创建时间等
+
+import com.farm.doc.server.FarmDocOperateRightInter;
+// 导入文档操作权限接口，用于判断用户对文档的各种操作权限，如写入、读取等
+
+import com.farm.util.spring.BeanFactory;
+// 导入Spring工具类，用于从Spring容器中获取Bean对象，这里用于获取文档管理和权限管理的实现类实例
+
+import com.farm.web.constant.FarmConstant;
+// 导入包含农场系统相关常量的类，例如会话中存储用户对象的键名等
+
+public class WriteIsShowForUser extends TagSupport {
+ private String docId;
+ // 定义一个字符串类型的成员变量，用于存储要判断写入权限的文档的唯一标识ID
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，用于保证对象在序列化和反序列化过程中的兼容性
+
+ private final static FarmDocOperateRightInter aloneIMP = (FarmDocOperateRightInter) BeanFactory
+ .getBean("farmDocOperateRightImpl");
+ // 从Spring容器中获取文档操作权限接口的实现类实例，采用单例模式，命名为aloneIMP
+
+ private final static FarmDocManagerInter docIMP = (FarmDocManagerInter) BeanFactory.getBean("farmDocManagerImpl");
+ // 从Spring容器中获取文档管理接口的实现类实例，采用单例模式，命名为docIMP
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ // 重写doEndTag方法，返回EVAL_PAGE表示继续处理页面的剩余部分，即标签处理结束后页面会继续执行后续内容
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 从当前页面上下文获取HttpServletRequest对象，以便获取与请求相关的信息
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 从当前请求的会话中获取名为FarmConstant.SESSION_USEROBJ的属性值，并将其转换为LoginUser类型，获取当前登录用户的信息
+
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回SKIP_BODY则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 调用aloneIMP的isWrite方法，传入当前登录用户user和通过docIMP获取的指定文档的基本信息对象docOnlyBean(docId)
+ // 判断当前用户对指定文档是否具有写入权限
+ // 如果具有写入权限
+ return EVAL_BODY_INCLUDE;
+ // 返回EVAL_BODY_INCLUDE，意味着执行自定义标签的标签体内容
+ }
+ return SKIP_BODY;
+ // 如果用户不具有写入权限，则返回SKIP_BODY，忽略自定义标签的标签体内容
+ }
+
+ public String getDocId() {
+ return docId;
+ // 定义获取文档ID的方法，返回存储在成员变量docId中的文档ID
+ }
+
+ public void setDocId(String docId) {
+ this.docId = docId;
+ // 定义设置文档ID的方法，将传入的文档ID值赋值给成员变量docId
+ }
+
+ // 扩展部分开始
+
+ // 增加一个方法，用于获取文档的创建者信息
+ private String getDocCreatorName(String docId) {
+ try {
+ // 尝试获取文档的创建者信息
+ com.farm.doc.domain.DocCreatorInfo creatorInfo = docIMP.getDocCreatorInfo(docId);
+ // 调用docIMP的方法获取文档创建者信息对象
+ if (creatorInfo != null) {
+ // 如果创建者信息对象不为空
+ return creatorInfo.getCreatorName();
+ // 返回文档创建者的名字
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，判断当前用户是否是文档的创建者
+ private boolean isDocCreator(LoginUser user, String docId) {
+ String creatorId = getDocCreatorId(docId);
+ // 获取文档创建者的ID
+ if (!creatorId.isEmpty()) {
+ // 如果创建者ID不为空
+ return creatorId.equals(user.getId());
+ // 判断创建者ID是否与当前用户ID相等
+ }
+ return false;
+ // 如果创建者ID为空，返回false
+ }
+
+ // 辅助方法，用于获取文档创建者的ID
+ private String getDocCreatorId(String docId) {
+ try {
+ // 尝试获取文档创建者的ID
+ com.farm.doc.domain.DocCreatorInfo creatorInfo = docIMP.getDocCreatorInfo(docId);
+ // 调用docIMP的方法获取文档创建者信息对象
+ if (creatorInfo != null) {
+ // 如果创建者信息对象不为空
+ return creatorInfo.getCreatorId();
+ // 返回文档创建者的ID
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，根据用户是否是创建者和写入权限进行提示
+ private void printCreatorHint(LoginUser user, String docId) {
+ if (isDocCreator(user, docId)) {
+ // 如果用户是文档的创建者
+ if (aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户具有写入权限
+ System.out.println("您是文档的创建者，且具有写入权限，文档ID: " + docId);
+ // 打印提示信息
+ } else {
+ System.out.println("您是文档的创建者，但没有写入权限，文档ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 增加一个方法，用于获取文档的修改次数信息
+ private int getDocModifyCount(String docId) {
+ try {
+ // 尝试获取文档的修改次数信息
+ com.farm.doc.domain.DocModifyRecordInfo modifyRecordInfo = docIMP.getDocModifyRecordInfo(docId);
+ // 调用docIMP的方法获取文档修改记录信息对象
+ if (modifyRecordInfo != null) {
+ // 如果修改记录信息对象不为空
+ return modifyRecordInfo.getModifyCount();
+ // 返回文档的修改次数
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return 0;
+ // 如果获取失败，返回0
+ }
+
+ // 增加一个方法，根据文档修改次数和写入权限进行提示
+ private void printModifyCountHint(LoginUser user, String docId) {
+ int modifyCount = getDocModifyCount(docId);
+ // 获取文档的修改次数
+ if (modifyCount > 5) {
+ // 如果文档修改次数大于5
+ if (aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户具有写入权限
+ System.out.println("文档修改次数较多（大于5次），您具有写入权限，文档ID: " + docId);
+ // 打印提示信息
+ } else {
+ System.out.println("文档修改次数较多（大于5次），但您没有写入权限，文档ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在doStartTag方法中调用新增的提示方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 获取HttpServletRequest对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printCreatorHint(user, docId);
+ // 调用方法打印关于用户是否是创建者的提示信息
+
+ printModifyCountHint(user, docId);
+ // 调用方法打印关于文档修改次数的提示信息
+
+ // 执行原有的权限判断逻辑
+ if (aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，用于获取文档的所属项目信息
+ private String getDocProject(String docId) {
+ try {
+ // 尝试获取文档的所属项目信息
+ com.farm.doc.domain.DocProjectInfo projectInfo = docIMP.getDocProjectInfo(docId);
+ // 调用docIMP的方法获取文档所属项目信息对象
+ if (projectInfo != null) {
+ // 如果所属项目信息对象不为空
+ return projectInfo.getProjectName();
+ // 返回文档所属项目的名称
+ }
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，判断文档所属项目是否为关键项目（假设存在关键项目的定义）
+ private boolean isKeyProject(String docId) {
+ String project = getDocProject(docId);
+ // 获取文档所属项目的名称
+ if ("key_project".equals(project)) {
+ // 假设关键项目的标识为"key_project"
+ return true;
+ // 如果是关键项目，返回true
+ }
+ return false;
+ // 否则返回false
+ }
+
+ // 增加一个方法，根据文档所属项目和写入权限进行提示
+ private void printProjectHint(LoginUser user, String docId) {
+ if (isKeyProject(docId)) {
+ // 如果文档属于关键项目
+ if (aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ // 且用户具有写入权限
+ System.out.println("文档属于关键项目，您具有写入权限，文档ID: " + docId);
+ // 打印提示信息
+ } else {
+ System.out.println("文档属于关键项目，但您没有写入权限，文档ID: " + docId);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在doStartTag方法中调用关于项目的提示方法
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 获取HttpServletRequest对象
+
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 获取当前登录用户
+
+ printCreatorHint(user, docId);
+ // 调用打印关于用户是否是创建者的提示信息
+
+ printModifyCountHint(user, docId);
+ // 调用打印关于文档修改次数的提示信息
+
+ printProjectHint(user, docId);
+ // 调用打印关于文档所属项目的提示信息
+
+ // 执行原有的权限判断逻辑
+ if (aloneIMP.isWrite(user, docIMP.getDocOnlyBean(docId))) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+}
diff --git a/src/wcp-tag/src/main/java/com/farm/doc/tag/farmdoc.tld b/src/wcp-tag/src/main/java/com/farm/doc/tag/farmdoc.tld
new file mode 100644
index 0000000..5d139f4
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/doc/tag/farmdoc.tld
@@ -0,0 +1,216 @@
+
+
+
+
+
+ 1.0
+
+ 1.2
+
+ 文档功能标签
+
+ /hellotag
+
+
+ Describe
+
+ com.farm.doc.tag.DocDescribe
+
+ jsp
+
+
+ text
+
+ true
+
+ true
+
+
+
+ maxnum
+
+ true
+
+ true
+
+
+
+
+ defaultIndexPage
+
+ com.farm.doc.tag.DefaultIndexPageTaget
+
+ empty
+
+
+
+ canWriteIsShow
+
+ com.farm.doc.tag.WriteIsShowForUser
+
+ jsp
+
+
+ docId
+
+ true
+
+ true
+
+
+
+
+ canNoWriteIsShow
+
+ com.farm.doc.tag.NoWriteIsShowForUser
+
+ jsp
+
+
+ docId
+
+ true
+
+ true
+
+
+
+
+ canAuditIsShow
+
+ com.farm.doc.tag.AuditIsShowForUser
+
+ jsp
+
+
+ docId
+
+ true
+
+ true
+
+
+
+
+ canDelIsShow
+
+ com.farm.doc.tag.DelIsShowForUser
+
+ jsp
+
+
+ docId
+
+ true
+
+ true
+
+
+
+
+ canNoDelIsShow
+
+ com.farm.doc.tag.NoDelIsShowForUser
+
+ jsp
+
+
+ docId
+
+ true
+
+ true
+
+
+
+
+ canReadsShow
+
+ com.farm.doc.tag.ReadIsShowForUser
+
+ jsp
+
+
+ docId
+
+ true
+
+ true
+
+
+
+
+ canNoReadsShow
+
+ com.farm.doc.tag.NoReadIsShowForUserr
+
+ jsp
+
+
+ docId
+
+ true
+
+ true
+
+
+
+
+ docGroupOption
+
+ com.farm.doc.tag.DocGroupOption
+
+ empty
+
+
+ aroundS
+
+ false
+
+ false
+
+
+
+ aroundE
+
+ false
+
+ false
+
+
+
+
+ docContent
+
+ com.farm.doc.tag.DocContent
+
+ empty
+
+
+ id
+
+ true
+
+ true
+
+
+
+
+ ImgUrl
+
+ com.farm.doc.tag.ImgUrl
+
+ empty
+
+
+ fileid
+
+ true
+
+ true
+
+
+
+
diff --git a/src/wcp-tag/src/main/java/com/farm/wda/tag/DocWebViewUrl.java b/src/wcp-tag/src/main/java/com/farm/wda/tag/DocWebViewUrl.java
new file mode 100644
index 0000000..7dde6b8
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/wda/tag/DocWebViewUrl.java
@@ -0,0 +1,268 @@
+package com.farm.wda.tag;
+// 声明该类所在的包
+
+import java.io.IOException;
+// 导入处理输入输出异常的类，用于处理可能的文件读取或网络请求异常
+
+import java.util.Set;
+// 导入Set接口，用于处理不重复元素的集合
+
+import javax.servlet.jsp.JspException;
+// 导入JSP异常类，用于处理JSP标签处理过程中可能出现的异常
+
+import javax.servlet.jsp.JspWriter;
+// 导入JSP输出流类，用于向JSP页面输出内容
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入JSP标签支持类，作为自定义JSP标签的基础类
+
+import com.farm.doc.domain.FarmDocfile;
+// 导入代表文档文件的实体类，用于存储文档文件的相关信息
+
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入文件管理接口，用于获取和管理文档文件的相关操作
+
+import com.farm.parameter.FarmParameterService;
+// 导入参数服务类，用于获取系统参数
+
+import com.farm.util.spring.BeanFactory;
+// 导入Spring工具类，用于从Spring容器中获取Bean对象
+
+import com.farm.wda.exception.ErrorTypeException;
+// 导入自定义的异常类，用于处理特定类型的错误
+
+public class DocWebViewUrl extends TagSupport {
+ /**
+ *
+ */
+ private String fileid;
+ // 定义一个字符串类型的成员变量，用于存储文件的唯一标识ID
+
+ private String docid;
+ // 定义一个字符串类型的成员变量，用于存储文档的唯一标识ID
+
+ private final static FarmFileManagerInter aloneIMP = (FarmFileManagerInter) BeanFactory
+ .getBean("farmFileManagerImpl");
+ // 从Spring容器中获取文件管理接口的实现类实例，采用单例模式，命名为aloneIMP
+
+ private static final long serialVersionUID = 1895493540131375513L;
+ // 定义序列化版本号，用于保证对象在序列化和反序列化过程中的兼容性
+
+ @Override
+ public int doEndTag() throws JspException {
+ JspWriter jspw = this.pageContext.getOut();
+ // 从当前页面上下文获取JSP输出流，用于向页面输出内容
+
+ try {
+ FarmDocfile file = aloneIMP.getFile(fileid);
+ // 调用aloneIMP的getFile方法，根据文件ID获取对应的文档文件对象
+
+ String typename = null;
+ // 定义一个字符串变量，用于存储文件的扩展名（去除点号）
+
+ if (file.getExname() != null && !file.getExname().isEmpty()) {
+ // 如果文件的扩展名不为空
+ typename = file.getExname().replace(".", "");
+ // 去除扩展名中的点号
+ }
+
+ Set types = RmiServer.getInstance().getSupportTypes();
+ // 获取RmiServer实例支持的文件类型集合
+
+ if (types.contains(typename)) {
+ // 如果支持的文件类型集合包含当前文件的扩展名
+ if (!RmiServer.getInstance().isLoged(file.getId())) {
+ // 如果当前文件未被标记为已处理（假设isLoged方法表示此含义）
+ RmiServer.getInstance().generateDoc(file.getId(), file.getFile(), typename, file.getName(), docid);
+ // 调用RmiServer的generateDoc方法生成文档相关内容
+ }
+ jspw.println(FarmParameterService.getInstance().getParameter("config.wda.view.url")
+ .replaceAll("PARA_KEY", fileid));
+ // 获取系统参数中指定的文档查看URL，并将其中的占位符"PARA_KEY"替换为文件ID，然后输出到JSP页面
+ } else {
+ jspw.println("");
+ // 如果文件类型不被支持，输出空字符串
+ }
+ } catch (IOException | ErrorTypeException e) {
+ // 如果在上述操作过程中出现IOException或ErrorTypeException异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return 0;
+ // 返回0，表示标签处理结束
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ return 0;
+ // 重写doStartTag方法，返回0，表示标签开始时不进行特殊处理，继续页面的正常处理流程
+ }
+
+ public String getFileid() {
+ return fileid;
+ // 获取文件ID的方法，返回成员变量fileid的值
+ }
+
+ public void setFileid(String fileid) {
+ this.fileid = fileid;
+ // 设置文件ID的方法，将传入的文件ID赋值给成员变量fileid
+ }
+
+ public String getDocid() {
+ return docid;
+ // 获取文档ID的方法，返回成员变量docid的值
+ }
+
+ public void setDocid(String docid) {
+ this.docid = docid;
+ // 设置文档ID的方法，将传入的文档ID赋值给成员变量docid
+ }
+
+ // 扩展部分开始
+
+ // 增加一个方法，用于获取文件的大小信息
+ private long getFileSize(FarmDocfile file) {
+ try {
+ // 尝试获取文件大小
+ return file.getFileSize();
+ // 返回文件的大小（假设FarmDocfile类中有getFileSize方法获取文件大小）
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return 0;
+ // 如果获取失败，返回0
+ }
+
+ // 增加一个方法，根据文件大小进行一些提示或操作
+ private void handleFileSize(FarmDocfile file) {
+ long size = getFileSize(file);
+ // 获取文件大小
+ if (size > 1024 * 1024) {
+ // 如果文件大小大于1MB
+ System.out.println("文件较大，大小为: " + size + " 字节，文件ID: " + file.getId());
+ // 打印提示信息
+ }
+ }
+
+ // 增加一个方法，用于获取文件的创建时间信息
+ private String getFileCreateTime(FarmDocfile file) {
+ try {
+ // 尝试获取文件创建时间
+ return file.getCreateTime();
+ // 返回文件的创建时间（假设FarmDocfile类中有getCreateTime方法获取创建时间）
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息
+ }
+ return "";
+ // 如果获取失败，返回空字符串
+ }
+
+ // 增加一个方法，根据文件创建时间进行一些提示或操作
+ private void handleFileCreateTime(FarmDocfile file) {
+ String createTime = getFileCreateTime(file);
+ // 获取文件创建时间
+ if (!createTime.isEmpty()) {
+ // 如果创建时间不为空
+ java.time.LocalDateTime now = java.time.LocalDateTime.now();
+ java.time.LocalDateTime fileCreateTime = java.time.LocalDateTime.parse(createTime);
+ java.time.Duration duration = java.time.Duration.between(fileCreateTime, now);
+ if (duration.toDays() > 30) {
+ // 如果文件创建时间超过30天
+ System.out.println("文件创建时间较久，距今: " + duration.toDays() + " 天，文件ID: " + file.getId());
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在doEndTag方法中调用上述增加的方法
+ @Override
+ public int doEndTag() throws JspException {
+ JspWriter jspw = this.pageContext.getOut();
+
+ try {
+ FarmDocfile file = aloneIMP.getFile(fileid);
+
+ String typename = null;
+ if (file.getExname() != null && !file.getExname().isEmpty()) {
+ typename = file.getExname().replace(".", "");
+ }
+
+ Set types = RmiServer.getInstance().getSupportTypes();
+ if (types.contains(typename)) {
+ if (!RmiServer.getInstance().isLoged(file.getId())) {
+ RmiServer.getInstance().generateDoc(file.getId(), file.getFile(), typename, file.getName(), docid);
+ }
+
+ handleFileSize(file);
+ // 调用处理文件大小的方法
+ handleFileCreateTime(file);
+ // 调用处理文件创建时间的方法
+
+ jspw.println(FarmParameterService.getInstance().getParameter("config.wda.view.url")
+ .replaceAll("PARA_KEY", fileid));
+ } else {
+ jspw.println("");
+ }
+ } catch (IOException | ErrorTypeException e) {
+ e.printStackTrace();
+ }
+ return 0;
+ }
+
+ // 增加一个方法，用于判断文件是否为重要文件（假设存在判断逻辑）
+ private boolean isImportantFile(FarmDocfile file) {
+ // 这里假设根据文件大小和创建时间综合判断
+ long size = getFileSize(file);
+ String createTime = getFileCreateTime(file);
+ if (size > 5 * 1024 * 1024 && java.time.Duration.between(java.time.LocalDateTime.parse(createTime), java.time.LocalDateTime.now()).toDays() < 10) {
+ return true;
+ }
+ return false;
+ }
+
+ // 增加一个方法，根据文件是否重要进行提示
+ private void handleImportantFile(FarmDocfile file) {
+ if (isImportantFile(file)) {
+ System.out.println("该文件为重要文件，文件ID: " + file.getId());
+ }
+ }
+
+ // 在doEndTag方法中调用判断和处理重要文件的方法
+ @Override
+ public int doEndTag() throws JspException {
+ JspWriter jspw = this.pageContext.getOut();
+
+ try {
+ FarmDocfile file = aloneIMP.getFile(fileid);
+
+ String typename = null;
+ if (file.getExname() != null && !file.getExname().isEmpty()) {
+ typename = file.getExname().replace(".", "");
+ }
+
+ Set types = RmiServer.getInstance().getSupportTypes();
+ if (types.contains(typename)) {
+ if (!RmiServer.getInstance().isLoged(file.getId())) {
+ RmiServer.getInstance().generateDoc(file.getId(), file.getFile(), typename, file.getName(), docid);
+ }
+
+ handleFileSize(file);
+ handleFileCreateTime(file);
+ handleImportantFile(file);
+ // 调用判断和处理重要文件的方法
+
+ jspw.println(FarmParameterService.getInstance().getParameter("config.wda.view.url")
+ .replaceAll("PARA_KEY", fileid));
+ } else {
+ jspw.println("");
+ }
+ } catch (IOException | ErrorTypeException e) {
+ e.printStackTrace();
+ }
+ return 0;
+ }
+}
diff --git a/src/wcp-tag/src/main/java/com/farm/wda/tag/IsSupport.java b/src/wcp-tag/src/main/java/com/farm/wda/tag/IsSupport.java
new file mode 100644
index 0000000..ff917b9
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/wda/tag/IsSupport.java
@@ -0,0 +1,330 @@
+package com.farm.wda.tag;
+// 声明该类所在的包
+
+import java.util.Set;
+// 导入Set接口，用于处理不重复元素的集合，这里可能用于存储支持的文件类型等
+
+import javax.servlet.jsp.JspException;
+// 导入JSP异常类，用于处理在标签处理过程中可能出现的异常情况
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入JSP标签支持类，作为自定义JSP标签的基类，提供标签处理的基本方法和结构
+
+import org.apache.log4j.Logger;
+// 导入Log4j的Logger类，用于记录日志信息，方便调试和监控程序运行情况
+
+import com.farm.doc.domain.FarmDocfile;
+// 导入代表农场文档文件的实体类，用于存储文档文件的相关信息，如文件名、扩展名等
+
+import com.farm.doc.server.FarmFileManagerInter;
+// 导入文件管理接口，用于获取和管理农场文档文件，例如获取文件详细信息等操作
+
+import com.farm.parameter.FarmParameterService;
+// 导入农场参数服务类，用于获取系统配置参数，比如获取与WDA相关的配置参数
+
+import com.farm.util.spring.BeanFactory;
+// 导入Spring工具类，用于从Spring容器中获取Bean对象，这里用于获取文件管理接口的实现类实例
+
+public class IsSupport extends TagSupport {
+ private String fileid;
+ // 定义一个字符串类型的成员变量，用于存储要检查支持情况的文件的唯一标识ID
+
+ static final Logger log = Logger.getLogger(IsSupport.class);
+ // 创建一个Logger实例，用于记录当前类（IsSupport）相关的日志信息
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，用于保证对象在序列化和反序列化过程中的兼容性，确保对象在不同环境下能正确恢复
+
+ private final static FarmFileManagerInter aloneIMP = (FarmFileManagerInter) BeanFactory
+ .getBean("farmFileManagerImpl");
+ // 从Spring容器中获取文件管理接口的实现类实例，采用单例模式，命名为aloneIMP，
+ // 以便后续通过该实例调用文件管理相关的方法
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ // 重写doEndTag方法，返回EVAL_PAGE表示继续处理页面的剩余部分，
+ // 即标签处理结束后，页面会继续执行后续的其他内容
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回SKIP_BODY则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (!FarmParameterService.getInstance().getParameter("config.wda.rmi.state").equals("true")) {
+ // 获取系统参数中名为"config.wda.rmi.state"的参数值，
+ // 并判断其是否不等于"true"。如果不等于"true"，
+ // 说明RMI相关的状态可能不满足要求，直接忽略标签体
+ return SKIP_BODY;
+ }
+
+ FarmDocfile file = aloneIMP.getFile(fileid);
+ // 调用aloneIMP的getFile方法，传入之前设置的文件ID（fileid），
+ // 获取对应的农场文档文件对象，用于后续获取文件的详细信息
+
+ String typename = null;
+ // 定义一个字符串变量，用于存储文件的扩展名（去除点号后的形式）
+
+ if (file.getExname() != null && !file.getExname().isEmpty()) {
+ // 判断获取到的文件对象的扩展名（exname）是否不为空且不为空字符串
+ typename = file.getExname().replace(".", "");
+ // 如果满足条件，将扩展名中的点号去除，并赋值给typename变量
+ }
+
+ Set types = null;
+ // 定义一个Set类型的变量，用于存储支持的文件类型集合
+
+ try {
+ types = RmiServer.getInstance().getSupportTypes();
+ // 尝试调用RmiServer的getInstance方法获取单例实例，
+ // 并通过该实例调用getSupportTypes方法获取支持的文件类型集合，
+ // 将结果赋值给types变量
+ } catch (Exception e) {
+ log.error(e.getMessage());
+ // 如果在获取支持的文件类型集合过程中出现异常，
+ // 使用Logger记录异常信息（异常消息）
+ return SKIP_BODY;
+ // 出现异常时，忽略标签体，直接继续页面后续处理
+ }
+
+ if (types.contains(typename)) {
+ // 判断支持的文件类型集合（types）是否包含当前文件的扩展名（typename）
+ return EVAL_BODY_INCLUDE;
+ // 如果包含，说明文件类型是支持的，执行自定义标签的标签体内容
+ } else {
+ return SKIP_BODY;
+ // 如果不包含，说明文件类型不被支持，忽略自定义标签的标签体内容
+ }
+ }
+
+ public String getFileid() {
+ return fileid;
+ // 定义获取文件ID的方法，返回存储文件ID的成员变量fileid的值
+ }
+
+ public void setFileid(String fileid) {
+ this.fileid = fileid;
+ // 定义设置文件ID的方法，将传入的文件ID值赋值给成员变量fileid
+ }
+
+ // 扩展部分开始
+
+ // 增加一个方法，用于获取文件的大小信息
+ private long getFileSize(FarmDocfile file) {
+ try {
+ // 尝试获取文件的大小
+ return file.getFileSize();
+ // 假设FarmDocfile类中有getFileSize方法，调用该方法获取文件大小并返回
+ } catch (Exception e) {
+ // 如果在获取文件大小过程中出现异常
+ log.error("获取文件大小出错，文件ID：" + file.getId() + "，错误信息：" + e.getMessage());
+ // 使用Logger记录错误信息，包括文件ID和异常消息
+ return -1;
+ // 返回-1表示获取文件大小失败
+ }
+ }
+
+ // 增加一个方法，根据文件大小进行一些提示或操作
+ private void handleFileSizeBasedOnSupport(FarmDocfile file, boolean isSupported) {
+ long size = getFileSize(file);
+ // 调用getFileSize方法获取文件大小
+
+ if (isSupported) {
+ // 如果文件类型是支持的
+ if (size > 1024 * 1024) {
+ // 如果文件大小大于1MB
+ log.info("支持的文件较大，大小为: " + size + " 字节，文件ID: " + file.getId());
+ // 使用Logger记录提示信息，说明文件较大及相关文件ID和大小
+ }
+ } else {
+ // 如果文件类型不被支持
+ if (size > 512 * 1024) {
+ // 如果文件大小大于512KB
+ log.warn("不支持的文件较大，大小为: " + size + " 字节，文件ID: " + file.getId());
+ // 使用Logger记录警告信息，说明不支持的文件较大及相关文件ID和大小
+ }
+ }
+ }
+
+ // 增加一个方法，用于获取文件的创建时间信息
+ private String getFileCreateTime(FarmDocfile file) {
+ try {
+ // 尝试获取文件的创建时间
+ return file.getCreateTime();
+ // 假设FarmDocfile类中有getCreateTime方法，调用该方法获取创建时间并返回
+ } catch (Exception e) {
+ // 如果在获取创建时间过程中出现异常
+ log.error("获取文件创建时间出错，文件ID：" + file.getId() + "，错误信息：" + e.getMessage());
+ // 使用Logger记录错误信息，包括文件ID和异常消息
+ return "";
+ // 返回空字符串表示获取创建时间失败
+ }
+ }
+
+ // 增加一个方法，根据文件创建时间进行一些提示或操作
+ private void handleFileCreateTimeBasedOnSupport(FarmDocfile file, boolean isSupported) {
+ String createTime = getFileCreateTime(file);
+ // 调用getFileCreateTime方法获取文件的创建时间
+
+ if (!createTime.isEmpty()) {
+ // 如果创建时间不为空
+ java.time.LocalDateTime now = java.time.LocalDateTime.now();
+ // 获取当前时间
+
+ java.time.LocalDateTime fileCreateTime = java.time.LocalDateTime.parse(createTime);
+ // 将获取到的创建时间字符串解析为LocalDateTime类型
+
+ java.time.Duration duration = java.time.Duration.between(fileCreateTime, now);
+ // 计算文件创建时间与当前时间的时间间隔
+
+ if (isSupported) {
+ // 如果文件类型是支持的
+ if (duration.toDays() > 30) {
+ // 如果文件创建时间超过30天
+ log.info("支持的文件创建时间较久，距今: " + duration.toDays() + " 天，文件ID: " + file.getId());
+ // 使用Logger记录提示信息，说明支持的文件创建时间较久及相关信息
+ }
+ } else {
+ // 如果文件类型不被支持
+ if (duration.toDays() > 10) {
+ // 如果文件创建时间超过10天
+ log.warn("不支持的文件创建时间较久，距今: " + duration.toDays() + " 天，文件ID: " + file.getId());
+ // 使用Logger记录警告信息，说明不支持的文件创建时间较久及相关信息
+ }
+ }
+ }
+ }
+
+ // 在doStartTag方法中调用上述增加的方法
+ @Override
+ public int doStartTag() throws JspException {
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回SKIP_BODY则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (!FarmParameterService.getInstance().getParameter("config.wda.rmi.state").equals("true")) {
+ return SKIP_BODY;
+ }
+
+ FarmDocfile file = aloneIMP.getFile(fileid);
+
+ String typename = null;
+ if (file.getExname() != null && !file.getExname().isEmpty()) {
+ typename = file.getExname().replace(".", "");
+ }
+
+ Set types = null;
+ try {
+ types = RmiServer.getInstance().getSupportTypes();
+ } catch (Exception e) {
+ log.error(e.getMessage());
+ return SKIP_BODY;
+ }
+
+ boolean isSupported = types.contains(typename);
+ // 判断文件类型是否被支持，并将结果存储在isSupported变量中
+
+ handleFileSizeBasedOnSupport(file, isSupported);
+ // 调用根据文件大小进行提示或操作的方法
+
+ handleFileCreateTimeBasedOnSupport(file, isSupported);
+ // 调用根据文件创建时间进行提示或操作的方法
+
+ if (isSupported) {
+ return EVAL_BODY_INCLUDE;
+ } else {
+ return SKIP_BODY;
+ }
+ }
+
+ // 增加一个方法，用于获取文件的修改时间信息
+ private String getFileModifyTime(FarmDocfile file) {
+ try {
+ // 尝试获取文件的修改时间
+ return file.getModifyTime();
+ // 假设FarmDocfile类中有getModifyTime方法，调用该方法获取修改时间并返回
+ } catch (Exception e) {
+ // 如果在获取修改时间过程中出现异常
+ log.error("获取文件修改时间出错，文件ID：" + file.getId() + "，错误信息：" + e.getMessage());
+ // 使用Logger记录错误信息，包括文件ID和异常消息
+ return "";
+ // 返回空字符串表示获取修改时间失败
+ }
+ }
+
+ // 增加一个方法，根据文件修改时间进行一些提示或操作
+ private void handleFileModifyTimeBasedOnSupport(FarmDocfile file, boolean isSupported) {
+ String modifyTime = getFileModifyTime(file);
+ // 调用getFileModifyTime方法获取文件的修改时间
+
+ if (!modifyTime.isEmpty()) {
+ // 如果修改时间不为空
+ java.time.LocalDateTime now = java.time.LocalDateTime.now();
+ // 获取当前时间
+
+ java.time.LocalDateTime fileModifyTime = java.time.LocalDateTime.parse(modifyTime);
+ // 将获取到的修改时间字符串解析为LocalDateTime类型
+
+ java.time.Duration duration = java.time.Duration.between(fileModifyTime, now);
+ // 计算文件修改时间与当前时间的时间间隔
+
+ if (isSupported) {
+ // 如果文件类型是支持的
+ if (duration.toDays() < 1) {
+ // 如果文件在1天内被修改
+ log.info("支持的文件近期被修改，距今: " + duration.toDays() + " 天，文件ID: " + file.getId());
+ // 使用Logger记录提示信息，说明支持的文件近期被修改及相关信息
+ }
+ } else {
+ // 如果文件类型不被支持
+ if (duration.toDays() < 3) {
+ // 如果文件在3天内被修改
+ log.warn("不支持的文件近期被修改，距今: " + duration.toDays() + " 天，文件ID: " + file.getId());
+ // 使用Logger记录警告信息，说明不支持的文件近期被修改及相关信息
+ }
+ }
+ }
+ }
+
+ // 在doStartTag方法中调用根据文件修改时间进行提示或操作的方法
+ @Override
+ public int doStartTag() throws JspException {
+ // EVAL_BODY_INCLUDE
+ // 则执行自定义标签的标签体；
+ // 返回SKIP_BODY则忽略自定义标签的标签体，直接解释执行自定义标签的结果标记。
+ if (!FarmParameterService.getInstance().getParameter("config.wda.rmi.state").equals("true")) {
+ return SKIP_BODY;
+ }
+
+ FarmDocfile file = aloneIMP.getFile(fileid);
+
+ String typename = null;
+ if (file.getExname() != null && !file.getExname().isEmpty()) {
+ typename = file.getExname().replace(".", "");
+ }
+
+ Set types = null;
+ try {
+ types = RmiServer.getInstance().getSupportTypes();
+ } catch (Exception e) {
+ log.error(e.getMessage());
+ return SKIP_BODY;
+ }
+
+ boolean isSupported = types.contains(typename);
+
+ handleFileSizeBasedOnSupport(file, isSupported);
+ handleFileCreateTimeBasedOnSupport(file, isSupported);
+ handleFileModifyTimeBasedOnSupport(file, isSupported);
+ // 调用根据文件修改时间进行提示或操作的方法
+
+ if (isSupported) {
+ return EVAL_BODY_INCLUDE;
+ } else {
+ return SKIP_BODY;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/wda/tag/RmiServer.java b/src/wcp-tag/src/main/java/com/farm/wda/tag/RmiServer.java
new file mode 100644
index 0000000..ccc44de
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/wda/tag/RmiServer.java
@@ -0,0 +1,264 @@
+package com.farm.wda.tag;
+// 声明该类所在的包，此包用于农场WDA（可能是某种文档处理或应用系统）相关的标签操作
+
+import java.rmi.Naming;
+// 导入Java RMI（远程方法调用）的Naming类，该类用于在RMI注册表中查找和注册远程对象
+// RMI允许在不同的Java虚拟机之间进行远程方法调用，是实现分布式系统的重要技术
+
+import com.farm.parameter.FarmParameterService;
+// 导入农场参数服务类，该类用于获取农场系统中配置的各种参数
+// 例如这里可能会获取RMI服务的URL等配置信息
+
+import com.farm.wda.inter.WdaAppInter;
+// 导入WDA应用接口，该接口定义了WDA应用提供的远程方法
+// 通过RMI可以调用实现了该接口的远程对象的方法
+
+public class RmiServer {
+ // 定义一个私有的静态变量，用于存储WdaAppInter接口的实例
+ // 静态变量属于类，而不是类的实例，因此在整个应用程序中只有一个副本
+ private static WdaAppInter personService = null;
+
+ /**
+ * 获取WdaAppInter接口的单例实例
+ * 如果实例尚未创建，则通过RMI查找远程对象并进行初始化
+ * @return WdaAppInter接口的实例
+ */
+ public static WdaAppInter getInstance() {
+ try {
+ // 检查personService实例是否为空
+ // 如果为空，说明还没有创建该实例，需要进行初始化
+ if (personService == null) {
+ // 从农场参数服务中获取RMI服务的URL配置
+ // FarmParameterService.getInstance()用于获取农场参数服务的单例实例
+ // getParameter("config.wda.rmi.url")用于获取名为"config.wda.rmi.url"的配置参数
+ String rmiUrl = FarmParameterService.getInstance().getParameter("config.wda.rmi.url");
+
+ // 打印日志，记录正在查找的RMI服务URL
+ System.out.println("正在查找RMI服务，URL: " + rmiUrl);
+
+ // 使用Naming类的lookup方法在RMI注册表中查找指定URL的远程对象
+ // 并将其强制转换为WdaAppInter接口类型
+ personService = (WdaAppInter) Naming.lookup(rmiUrl);
+
+ // 打印日志，记录RMI服务查找成功
+ System.out.println("RMI服务查找成功，URL: " + rmiUrl);
+ } else {
+ // 如果实例已经存在，打印日志，记录使用已有的RMI服务实例
+ System.out.println("使用已有的RMI服务实例");
+ }
+ } catch (java.net.MalformedURLException e) {
+ // 捕获RMI服务URL格式错误的异常
+ // 当配置的RMI服务URL格式不正确时，会抛出该异常
+ System.err.println("RMI服务URL格式错误: " + e.getMessage());
+ // 打印错误信息，提示URL格式错误及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ } catch (java.rmi.NotBoundException e) {
+ // 捕获RMI服务未绑定的异常
+ // 当指定的RMI服务URL在注册表中没有对应的远程对象时，会抛出该异常
+ System.err.println("RMI服务未绑定: " + e.getMessage());
+ // 打印错误信息，提示服务未绑定及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ } catch (java.rmi.RemoteException e) {
+ // 捕获RMI远程调用异常
+ // 当与RMI服务进行通信时出现网络问题或服务端异常时，会抛出该异常
+ System.err.println("RMI远程调用异常: " + e.getMessage());
+ // 打印错误信息，提示远程调用异常及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ } catch (Exception ex) {
+ // 捕获其他未知异常
+ // 当出现上述特定异常之外的其他异常时，会进入该捕获块
+ System.err.println("发生未知异常: " + ex.getMessage());
+ // 打印错误信息，提示发生未知异常及具体的错误消息
+ ex.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ }
+
+ // 打印日志，记录返回的RMI服务实例
+ System.out.println("返回RMI服务实例: " + personService);
+
+ // 返回WdaAppInter接口的实例
+ return personService;
+ }
+
+ /**
+ * 检查RMI服务是否可用
+ * 通过尝试调用RMI服务的一个简单方法来检查服务是否正常工作
+ * @return 如果服务可用返回true，否则返回false
+ */
+ public static boolean isServiceAvailable() {
+ try {
+ // 获取WdaAppInter接口的实例
+ WdaAppInter service = getInstance();
+
+ // 检查实例是否为空
+ if (service != null) {
+ // 调用服务的一个简单方法来检查服务是否可用
+ // 这里假设WdaAppInter接口有一个名为ping的方法，用于检查服务状态
+ service.ping();
+
+ // 如果方法调用成功，说明服务可用
+ System.out.println("RMI服务可用");
+ return true;
+ } else {
+ // 如果实例为空，说明服务不可用
+ System.err.println("RMI服务实例为空，服务不可用");
+ return false;
+ }
+ } catch (Exception e) {
+ // 捕获调用服务方法时出现的异常
+ // 当调用服务方法出现异常时，说明服务可能不可用
+ System.err.println("RMI服务不可用: " + e.getMessage());
+ // 打印错误信息，提示服务不可用及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ return false;
+ }
+ }
+
+ /**
+ * 重新初始化RMI服务实例
+ * 当服务出现异常或需要重新连接时，可以调用该方法重新初始化服务实例
+ */
+ public static void reinitializeService() {
+ try {
+ // 将personService实例置为null
+ personService = null;
+
+ // 打印日志，记录正在重新初始化RMI服务
+ System.out.println("正在重新初始化RMI服务");
+
+ // 调用getInstance方法重新获取服务实例
+ personService = getInstance();
+
+ // 打印日志，记录RMI服务重新初始化完成
+ System.out.println("RMI服务重新初始化完成");
+ } catch (Exception e) {
+ // 捕获重新初始化过程中出现的异常
+ System.err.println("RMI服务重新初始化失败: " + e.getMessage());
+ // 打印错误信息，提示重新初始化失败及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ }
+ }
+
+ /**
+ * 获取RMI服务的状态信息
+ * 返回一个包含服务状态描述的字符串
+ * @return 服务状态信息字符串
+ */
+ public static String getServiceStatus() {
+ try {
+ // 获取WdaAppInter接口的实例
+ WdaAppInter service = getInstance();
+
+ // 检查实例是否为空
+ if (service != null) {
+ // 调用服务的一个方法获取服务状态信息
+ // 这里假设WdaAppInter接口有一个名为getStatus的方法，用于获取服务状态
+ return service.getStatus();
+ } else {
+ // 如果实例为空，返回服务未初始化的信息
+ return "RMI服务未初始化";
+ }
+ } catch (Exception e) {
+ // 捕获获取服务状态信息时出现的异常
+ System.err.println("获取RMI服务状态信息失败: " + e.getMessage());
+ // 打印错误信息，提示获取状态信息失败及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ return "获取RMI服务状态信息失败";
+ }
+ }
+
+ /**
+ * 打印RMI服务的配置信息
+ * 包括RMI服务的URL等配置信息
+ */
+ public static void printServiceConfig() {
+ try {
+ // 从农场参数服务中获取RMI服务的URL配置
+ String rmiUrl = FarmParameterService.getInstance().getParameter("config.wda.rmi.url");
+
+ // 打印RMI服务的URL配置信息
+ System.out.println("RMI服务配置信息:");
+ System.out.println("RMI服务URL: " + rmiUrl);
+ } catch (Exception e) {
+ // 捕获获取配置信息时出现的异常
+ System.err.println("获取RMI服务配置信息失败: " + e.getMessage());
+ // 打印错误信息，提示获取配置信息失败及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ }
+ }
+
+ /**
+ * 测试RMI服务的性能
+ * 通过多次调用服务的方法来测试服务的响应时间和性能
+ * @param testCount 测试调用的次数
+ */
+ public static void testServicePerformance(int testCount) {
+ try {
+ // 获取WdaAppInter接口的实例
+ WdaAppInter service = getInstance();
+
+ // 检查实例是否为空
+ if (service != null) {
+ // 记录测试开始时间
+ long startTime = System.currentTimeMillis();
+
+ // 循环调用服务的方法进行测试
+ for (int i = 0; i < testCount; i++) {
+ // 调用服务的一个简单方法进行测试
+ // 这里假设WdaAppInter接口有一个名为test的方法，用于性能测试
+ service.test();
+ }
+
+ // 记录测试结束时间
+ long endTime = System.currentTimeMillis();
+
+ // 计算测试总时间
+ long totalTime = endTime - startTime;
+
+ // 计算平均响应时间
+ double averageTime = (double) totalTime / testCount;
+
+ // 打印性能测试结果
+ System.out.println("RMI服务性能测试结果:");
+ System.out.println("测试调用次数: " + testCount);
+ System.out.println("总时间: " + totalTime + " 毫秒");
+ System.out.println("平均响应时间: " + averageTime + " 毫秒");
+ } else {
+ // 如果实例为空，提示服务不可用，无法进行性能测试
+ System.err.println("RMI服务不可用，无法进行性能测试");
+ }
+ } catch (Exception e) {
+ // 捕获性能测试过程中出现的异常
+ System.err.println("RMI服务性能测试失败: " + e.getMessage());
+ // 打印错误信息，提示性能测试失败及具体的错误消息
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ }
+ }
+
+ public static void main(String[] args) {
+ // 打印RMI服务的配置信息
+ printServiceConfig();
+
+ // 检查RMI服务是否可用
+ boolean isAvailable = isServiceAvailable();
+ System.out.println("RMI服务是否可用: " + isAvailable);
+
+ // 重新初始化RMI服务实例
+ reinitializeService();
+
+ // 获取RMI服务的状态信息
+ String status = getServiceStatus();
+ System.out.println("RMI服务状态信息: " + status);
+
+ // 测试RMI服务的性能，测试调用次数为100次
+ testServicePerformance(100);
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/wda/tag/wda.tld b/src/wcp-tag/src/main/java/com/farm/wda/tag/wda.tld
new file mode 100644
index 0000000..8334f6a
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/wda/tag/wda.tld
@@ -0,0 +1,237 @@
+
+
+
+
+
+
+
+
+
+ 1.0
+
+
+ 1.2
+
+
+ 在线预览功能标签库
+
+
+ /hellotag
+
+
+
+
+
+ DocWebViewUrl
+
+
+ com.farm.wda.tag.DocWebViewUrl
+
+
+ jsp
+
+
+
+
+
+ fileid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
+ docid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
+
+
+ IsSupport
+
+
+ com.farm.wda.tag.IsSupport
+
+
+ jsp
+
+
+
+
+
+ fileid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
+
+
+ GetDocEditPermission
+
+
+ com.farm.wda.tag.GetDocEditPermissionTag
+
+
+ jsp
+
+
+
+ docid
+
+
+ true
+
+
+ true
+
+
+
+
+
+ userid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
+
+
+ GetDocCreateTime
+
+
+ com.farm.wda.tag.GetDocCreateTimeTag
+
+
+ jsp
+
+
+
+ docid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
+
+
+ IsDocImportant
+
+
+ com.farm.wda.tag.IsDocImportantTag
+
+
+ jsp
+
+
+
+ docid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
+
+
+ GetDocAttachmentCount
+
+
+ com.farm.wda.tag.GetDocAttachmentCountTag
+
+
+ jsp
+
+
+
+ docid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
+
+
+ GetDocVersionInfo
+
+
+ com.farm.wda.tag.GetDocVersionInfoTag
+
+
+ jsp
+
+
+
+ docid
+
+
+ true
+
+
+ true
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/AuthorityForUser.java b/src/wcp-tag/src/main/java/com/farm/web/tag/AuthorityForUser.java
new file mode 100644
index 0000000..41ba57f
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/AuthorityForUser.java
@@ -0,0 +1,236 @@
+package com.farm.web.tag;
+// 声明该类所在的包，表明该类属于com.farm.web.tag包，可能与农场系统的Web相关标签功能有关
+
+import java.util.Set;
+// 导入Set接口，Set是一种不包含重复元素的集合类型，这里可能用于存储用户的操作权限集合等
+
+import javax.servlet.http.HttpServletRequest;
+// 导入HttpServletRequest类，用于处理HTTP请求，获取请求相关的信息，如会话、参数等
+
+import javax.servlet.jsp.JspException;
+// 导入JspException类，用于处理JSP标签执行过程中可能抛出的异常情况
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入TagSupport类，它是JSP标签支持类，为自定义JSP标签提供了基础的结构和方法
+
+import com.farm.authority.FarmAuthorityService;
+// 导入农场权限服务类，用于处理与权限相关的业务逻辑，比如获取权限信息、判断权限等
+
+import com.farm.core.AuthorityService;
+// 导入核心权限服务接口，可能定义了权限相关的通用方法，FarmAuthorityService可能实现了该接口
+
+import com.farm.core.auth.domain.AuthKey;
+// 导入权限键实体类，用于表示权限相关的信息，如权限名称、是否检查、是否可用等
+
+import com.farm.util.spring.BeanFactory;
+// 导入Spring工具类，用于从Spring容器中获取Bean对象，这里可能用于获取权限服务相关的Bean
+
+import com.farm.web.constant.FarmConstant;
+// 导入农场Web相关的常量类，用于存储一些固定的常量值，如会话中存储用户操作权限的键名等
+
+public class AuthorityForUser extends TagSupport {
+ private String actionName;
+ // 定义一个字符串类型的成员变量，用于存储要检查权限的操作名称
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，用于保证对象在序列化和反序列化过程中的兼容性，确保对象在不同环境下能正确恢复
+
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ // 重写doEndTag方法，返回EVAL_PAGE表示继续处理页面的剩余部分，
+ // 即标签处理结束后，页面会继续执行后续的其他内容
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+ // 从当前页面上下文获取HttpServletRequest对象，以便后续获取请求相关的信息，如会话等
+
+ Set usraction = ((Set) request.getSession()
+ .getAttribute(FarmConstant.SESSION_USERACTION));
+ // 从请求的会话中获取名为FarmConstant.SESSION_USERACTION的属性值，并将其转换为Set类型
+ // 这个属性值可能存储了当前用户拥有的操作权限集合
+
+ AuthorityService farmAuthService = FarmAuthorityService.getInstance();
+ // 获取农场权限服务的单例实例，通过该实例调用权限相关的方法
+
+ AuthKey authKey = farmAuthService.getAuthKey(actionName);
+ // 调用农场权限服务的getAuthKey方法，传入要检查权限的操作名称actionName，获取对应的权限键对象
+
+ // 权限未注册或用户有权限或权限不检查
+ if (authKey == null || !authKey.isCheck()
+ || (usraction.contains(actionName) && authKey.isUseAble())) {
+ // 判断权限是否未注册（authKey为null），或者权限不检查（!authKey.isCheck()），
+ // 或者用户拥有该操作权限（usraction包含actionName）并且权限可用（authKey.isUseAble()）
+ return EVAL_BODY_INCLUDE;
+ // 如果满足上述条件，说明用户对该操作有权限，返回EVAL_BODY_INCLUDE，执行自定义标签的标签体内容
+ }
+ return SKIP_BODY;
+ // 如果不满足上述条件，说明用户对该操作没有权限，返回SKIP_BODY，忽略自定义标签的标签体内容
+ }
+
+ public String getActionName() {
+ return actionName;
+ // 定义获取操作名称的方法，返回存储操作名称的成员变量actionName的值
+ }
+
+ public void setActionName(String actionName) {
+ this.actionName = actionName;
+ // 定义设置操作名称的方法，将传入的操作名称值赋值给成员变量actionName
+ }
+
+ // 扩展部分开始
+
+ // 增加一个方法，用于获取用户的角色信息
+ private Set getUserRoles(HttpServletRequest request) {
+ try {
+ // 尝试获取用户的角色信息
+ return (Set) request.getSession().getAttribute(FarmConstant.SESSION_USERROLES);
+ // 从会话中获取名为FarmConstant.SESSION_USERROLES的属性值，并转换为Set类型返回
+ // 假设该属性存储了用户的角色集合
+ } catch (Exception e) {
+ // 如果在获取过程中出现异常
+ e.printStackTrace();
+ // 打印异常堆栈信息，方便调试
+ return null;
+ // 如果获取失败，返回null
+ }
+ }
+
+ // 增加一个方法，根据用户角色和操作权限进行额外的提示或操作
+ private void handleUserRoleAndPermission(Set userRoles, Set usraction, AuthKey authKey) {
+ if (userRoles != null) {
+ // 如果用户角色集合不为空
+ for (String role : userRoles) {
+ // 遍历用户的角色集合
+ if ("admin".equals(role)) {
+ // 如果用户角色是管理员（假设管理员角色标识为"admin"）
+ if (!usraction.contains(actionName) && authKey != null && authKey.isCheck()) {
+ // 并且用户没有该操作权限，且权限已注册并且需要检查
+ System.out.println("用户是管理员，但没有权限执行操作: " + actionName);
+ // 打印提示信息
+ }
+ }
+ }
+ }
+ }
+
+ // 增加一个方法，用于获取权限的详细描述信息
+ private String getAuthKeyDescription(AuthKey authKey) {
+ if (authKey != null) {
+ // 如果权限键对象不为空
+ return authKey.getDescription();
+ // 返回权限的详细描述信息（假设AuthKey类有getDescription方法获取描述）
+ }
+ return "";
+ // 如果权限键对象为空，返回空字符串
+ }
+
+ // 增加一个方法，根据权限描述信息进行提示
+ private void handleAuthKeyDescription(String description, Set usraction, String actionName) {
+ if (!description.isEmpty()) {
+ // 如果权限描述信息不为空
+ if (!usraction.contains(actionName)) {
+ // 并且用户没有该操作权限
+ System.out.println("权限描述: " + description + "，但用户没有权限执行操作: " + actionName);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在doStartTag方法中调用上述增加的方法
+ @SuppressWarnings("unchecked")
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+
+ Set usraction = ((Set) request.getSession()
+ .getAttribute(FarmConstant.SESSION_USERACTION));
+
+ AuthorityService farmAuthService = FarmAuthorityService.getInstance();
+
+ AuthKey authKey = farmAuthService.getAuthKey(actionName);
+
+ Set userRoles = getUserRoles(request);
+ // 调用获取用户角色的方法
+
+ handleUserRoleAndPermission(userRoles, usraction, authKey);
+ // 调用根据用户角色和操作权限进行提示或操作的方法
+
+ String description = getAuthKeyDescription(authKey);
+ // 调用获取权限详细描述信息的方法
+
+ handleAuthKeyDescription(description, usraction, actionName);
+ // 调用根据权限描述信息进行提示的方法
+
+ // 权限未注册或用户有权限或权限不检查
+ if (authKey == null || !authKey.isCheck()
+ || (usraction.contains(actionName) && authKey.isUseAble())) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+
+ // 增加一个方法，用于判断权限是否为特殊权限（假设存在判断逻辑）
+ private boolean isSpecialAuthKey(AuthKey authKey) {
+ if (authKey != null) {
+ // 如果权限键对象不为空
+ // 这里假设特殊权限的判断条件是权限名称以"special_"开头
+ return authKey.getAuthName().startsWith("special_");
+ }
+ return false;
+ // 如果权限键对象为空，返回false
+ }
+
+ // 增加一个方法，根据特殊权限进行提示
+ private void handleSpecialAuthKey(AuthKey authKey, Set usraction, String actionName) {
+ if (isSpecialAuthKey(authKey)) {
+ // 如果权限是特殊权限
+ if (!usraction.contains(actionName)) {
+ // 并且用户没有该操作权限
+ System.out.println("该操作权限为特殊权限，用户没有权限执行操作: " + actionName);
+ // 打印提示信息
+ }
+ }
+ }
+
+ // 在doStartTag方法中调用判断和处理特殊权限的方法
+ @SuppressWarnings("unchecked")
+ @Override
+ public int doStartTag() throws JspException {
+ HttpServletRequest request = (HttpServletRequest) super.pageContext
+ .getRequest();
+
+ Set usraction = ((Set) request.getSession()
+ .getAttribute(FarmConstant.SESSION_USERACTION));
+
+ AuthorityService farmAuthService = FarmAuthorityService.getInstance();
+
+ AuthKey authKey = farmAuthService.getAuthKey(actionName);
+
+ Set userRoles = getUserRoles(request);
+
+ handleUserRoleAndPermission(userRoles, usraction, authKey);
+
+ String description = getAuthKeyDescription(authKey);
+
+ handleAuthKeyDescription(description, usraction, actionName);
+
+ handleSpecialAuthKey(authKey, usraction, actionName);
+ // 调用判断和处理特殊权限的方法
+
+ // 权限未注册或用户有权限或权限不检查
+ if (authKey == null || !authKey.isCheck()
+ || (usraction.contains(actionName) && authKey.isUseAble())) {
+ return EVAL_BODY_INCLUDE;
+ }
+ return SKIP_BODY;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/BasePathTaget.java b/src/wcp-tag/src/main/java/com/farm/web/tag/BasePathTaget.java
new file mode 100644
index 0000000..1830eaf
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/BasePathTaget.java
@@ -0,0 +1,257 @@
+package com.farm.web.tag;
+
+import java.io.IOException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.jsp.JspException;
+import javax.servlet.jsp.JspWriter;
+import javax.servlet.jsp.tagext.TagSupport;
+import org.apache.log4j.Logger;
+
+/**
+ * 自定义标签类：生成应用基础路径（BasePath）
+ * 功能扩展：支持HTTPS检测、路径缓存、配置参数等
+ */
+public class BasePathTag extends TagSupport {
+
+ //------------------------- 静态常量定义 -------------------------
+
+ /** 序列化版本号，用于对象持久化兼容性校验 */
+ private static final long serialVersionUID = 1L;
+
+ /** 日志记录器，用于记录运行时异常 */
+ private static final Logger log = Logger.getLogger(BasePathTag.class);
+
+ /** 默认HTTP协议端口 */
+ private static final int DEFAULT_HTTP_PORT = 80;
+
+ /** 默认HTTPS协议端口 */
+ private static final int DEFAULT_HTTPS_PORT = 443;
+
+ /** 是否启用路径缓存（减少重复计算） */
+ private boolean cacheEnabled = true;
+
+ /** 缓存的基础路径值 */
+ private String cachedBasePath = null;
+
+ //------------------------- 成员变量 -------------------------
+
+ /** 是否强制使用HTTPS（配置参数，通过标签属性设置） */
+ private boolean forceHttps = false;
+
+ /** 自定义端口号（配置参数，优先级高于请求端口） */
+ private Integer customPort = null;
+
+ /** 是否包含上下文路径（默认包含） */
+ private boolean includeContextPath = true;
+
+ //------------------------- 标签生命周期方法 -------------------------
+
+ /**
+ * 标签开始处理逻辑
+ * @return 返回值决定是否处理标签体内容（SKIP_BODY表示不处理）
+ * @throws JspException 处理过程中可能抛出的异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ try {
+ // 获取JSP内置输出流对象
+ JspWriter jspWriter = pageContext.getOut();
+
+ // 生成基础路径字符串
+ String basePath = generateBasePath();
+
+ // 将生成的基础路径写入响应
+ jspWriter.print(basePath);
+ } catch (IOException e) {
+ // 捕获并记录输出流异常
+ log.error("BasePath输出失败: " + e.getMessage(), e);
+ throw new JspException("BasePath输出异常", e);
+ }
+ return SKIP_BODY; // 跳过标签体内容处理
+ }
+
+ /**
+ * 标签结束处理逻辑
+ * @return 返回值决定是否继续处理页面后续内容（EVAL_PAGE为继续）
+ */
+ @Override
+ public int doEndTag() throws JspException {
+ // 清理可能存在的临时资源
+ clearTempResources();
+ return EVAL_PAGE; // 继续处理页面后续内容
+ }
+
+ //------------------------- 核心路径生成方法 -------------------------
+
+ /**
+ * 生成应用基础路径
+ * @return 完整的基础路径字符串
+ */
+ private String generateBasePath() {
+ // 如果启用缓存且已有缓存值，直接返回
+ if (cacheEnabled && cachedBasePath != null) {
+ return cachedBasePath;
+ }
+
+ // 获取HTTP请求对象
+ HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
+
+ // 确定使用的协议（HTTP/HTTPS）
+ String protocol = determineProtocol(request);
+
+ // 获取服务器名称
+ String serverName = request.getServerName();
+
+ // 确定使用的端口号
+ int port = determinePort(request, protocol);
+
+ // 获取上下文路径（根据配置决定是否包含）
+ String contextPath = includeContextPath ? request.getContextPath() : "";
+
+ // 构建基础路径
+ StringBuilder pathBuilder = new StringBuilder();
+ pathBuilder.append(protocol).append("://")
+ .append(serverName);
+
+ // 添加端口号（非默认端口时）
+ if (!isDefaultPort(protocol, port)) {
+ pathBuilder.append(":").append(port);
+ }
+
+ pathBuilder.append(contextPath).append("/");
+
+ // 缓存结果（如果启用）
+ if (cacheEnabled) {
+ cachedBasePath = pathBuilder.toString();
+ }
+
+ return pathBuilder.toString();
+ }
+
+ //------------------------- 协议处理方法 -------------------------
+
+ /**
+ * 确定使用的协议类型
+ * @param request HTTP请求对象
+ * @return "http" 或 "https"
+ */
+ private String determineProtocol(HttpServletRequest request) {
+ // 优先检查强制HTTPS配置
+ if (forceHttps) {
+ return "https";
+ }
+
+ // 获取请求中的协议信息
+ String protocol = request.getScheme();
+
+ // 自动检测HTTPS头（适用于反向代理场景）
+ String forwardedProto = request.getHeader("X-Forwarded-Proto");
+ if (forwardedProto != null) {
+ protocol = forwardedProto.toLowerCase();
+ }
+
+ return protocol;
+ }
+
+ //------------------------- 端口处理方法 -------------------------
+
+ /**
+ * 确定使用的端口号
+ * @param request HTTP请求对象
+ * @param protocol 当前使用的协议
+ * @return 最终使用的端口号
+ */
+ private int determinePort(HttpServletRequest request, String protocol) {
+ // 优先使用自定义端口配置
+ if (customPort != null) {
+ return customPort;
+ }
+
+ // 获取请求中的端口号
+ int requestPort = request.getServerPort();
+
+ // 根据协议调整默认端口
+ if ("https".equalsIgnoreCase(protocol)) {
+ return requestPort == DEFAULT_HTTP_PORT ? DEFAULT_HTTPS_PORT : requestPort;
+ } else {
+ return requestPort == DEFAULT_HTTPS_PORT ? DEFAULT_HTTP_PORT : requestPort;
+ }
+ }
+
+ /**
+ * 判断是否为协议默认端口
+ * @param protocol 协议类型
+ * @param port 端口号
+ * @return 是否为默认端口
+ */
+ private boolean isDefaultPort(String protocol, int port) {
+ if ("https".equalsIgnoreCase(protocol)) {
+ return port == DEFAULT_HTTPS_PORT;
+ }
+ return port == DEFAULT_HTTP_PORT;
+ }
+
+ //------------------------- 配置参数方法 -------------------------
+
+ /**
+ * 设置是否强制使用HTTPS
+ * @param forceHttps 是否强制HTTPS
+ */
+ public void setForceHttps(boolean forceHttps) {
+ this.forceHttps = forceHttps;
+ clearCache(); // 配置变更时清除缓存
+ }
+
+ /**
+ * 设置自定义端口号
+ * @param customPort 端口号（1-65535）
+ */
+ public void setCustomPort(Integer customPort) {
+ if (customPort != null && (customPort < 1 || customPort > 65535)) {
+ throw new IllegalArgumentException("无效端口号: " + customPort);
+ }
+ this.customPort = customPort;
+ clearCache(); // 配置变更时清除缓存
+ }
+
+ //------------------------- 缓存管理方法 -------------------------
+
+ /**
+ * 清除缓存的基础路径
+ */
+ private void clearCache() {
+ cachedBasePath = null;
+ }
+
+ /**
+ * 清理临时资源（可扩展）
+ */
+ private void clearTempResources() {
+ // 当前版本暂无需要清理的资源
+ // 保留方法用于未来扩展
+ }
+
+ //------------------------- Getter/Setter -------------------------
+
+ /** 获取缓存启用状态 */
+ public boolean isCacheEnabled() {
+ return cacheEnabled;
+ }
+
+ /** 设置缓存启用状态 */
+ public void setCacheEnabled(boolean cacheEnabled) {
+ this.cacheEnabled = cacheEnabled;
+ clearCache(); // 配置变更时清除缓存
+ }
+
+ /** 获取上下文路径包含状态 */
+ public boolean isIncludeContextPath() {
+ return includeContextPath;
+ }
+
+ /** 设置是否包含上下文路径 */
+ public void setIncludeContextPath(boolean includeContextPath) {
+ this.includeContextPath = includeContextPath;
+ clearCache(); // 配置变更时清除缓存
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryHandle.java b/src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryHandle.java
new file mode 100644
index 0000000..425ac5f
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryHandle.java
@@ -0,0 +1,104 @@
+// 声明该类所属的包路径，属于 farm 项目的 web 标签组件
+package com.farm.web.tag;
+
+// 导入所需的Java IO类（用于处理输入输出异常）
+import java.io.IOException;
+// 导入HashMap类，用于创建键值对集合
+import java.util.HashMap;
+// 导入List接口，用于处理有序集合
+import java.util.List;
+// 导入Map接口，用于处理键值对映射
+import java.util.Map;
+// 导入Map.Entry接口，用于遍历Map条目
+import java.util.Map.Entry;
+
+// 导入JSP标签相关的异常类
+import javax.servlet.jsp.JspException;
+// 导入SimpleTagSupport类，简化自定义标签开发
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+
+// 导入Log4j日志记录类
+import org.apache.log4j.Logger;
+
+// 导入项目自定义的参数服务类，用于获取字典数据
+import com.farm.parameter.FarmParameterService;
+
+/**
+ * 自定义JSP标签处理器：用于遍历字典数据并渲染标签体内容
+ * 功能：通过字典键（key）获取键值对列表，逐条暴露给JSP页面
+ */
+public class DictionaryHandle extends SimpleTagSupport {
+ // 定义标签属性var，用于在JSP页面中访问当前字典条目的变量名
+ private String var;
+ // 定义标签属性key，用于指定要获取的字典标识
+ private String key;
+ // 日志记录器，类初始化时加载（但当前代码中未实际使用）
+ private static final Logger log = Logger.getLogger(DictionaryHandle.class);
+
+ /**
+ * 标签处理的核心方法，由JSP容器自动调用
+ * @throws JspException JSP处理过程中的异常
+ * @throws IOException 输入输出异常
+ */
+ @Override
+ public void doTag() throws JspException, IOException {
+ // 初始化字典条目列表
+ List> list = null;
+ // 通过参数服务获取指定字典键对应的条目列表
+ list = FarmParameterService.getInstance().getDictionaryList(key);
+
+ // 遍历字典条目列表
+ for (Entry node : list) {
+ // 创建临时Map存储当前条目的键值信息
+ Map nodeMap = new HashMap<>();
+ // 添加小写键名（兼容性设计）
+ nodeMap.put("key", node.getKey());
+ // 添加大写键名（适应不同命名习惯）
+ nodeMap.put("KEY", node.getKey());
+ // 添加小写值名
+ nodeMap.put("value", node.getValue());
+ // 添加大写值名
+ nodeMap.put("VALUE", node.getValue());
+
+ // 将当前条目Map存入JSP上下文，供标签内使用
+ getJspContext().setAttribute(var, nodeMap);
+
+ // 执行标签体内容（例如：在JSP中渲染标签内的HTML）
+ getJspBody().invoke(null);
+ }
+ }
+
+ //------------------------- Getter & Setter -------------------------
+
+ /**
+ * 获取JSP页面中使用的变量名
+ * @return 变量名
+ */
+ public String getVar() {
+ return var;
+ }
+
+ /**
+ * 设置JSP页面中使用的变量名
+ * @param var 变量名（通过标签属性注入）
+ */
+ public void setVar(String var) {
+ this.var = var;
+ }
+
+ /**
+ * 获取字典标识键
+ * @return 字典键
+ */
+ public String getKey() {
+ return key;
+ }
+
+ /**
+ * 设置字典标识键
+ * @param key 字典键（通过标签属性注入）
+ */
+ public void setKey(String key) {
+ this.key = key;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryOptionTaget.java b/src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryOptionTaget.java
new file mode 100644
index 0000000..bc460dc
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/DictionaryOptionTaget.java
@@ -0,0 +1,93 @@
+// 声明包名，此包名为 com.farm.web.tag
+package com.farm.web.tag;
+
+// 导入用于处理输入输出异常的类
+import java.io.IOException;
+// 导入列表接口，用于存储字典项
+import java.util.List;
+// 导入 Map 中的 Entry 类，用于表示键值对
+import java.util.Map.Entry;
+
+// 导入 JSP 标签异常处理类
+import javax.servlet.jsp.JspException;
+// 导入 JSP 输出流类，用于向客户端输出内容
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 标签支持类，作为自定义标签的基类
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入日志记录器类，用于记录日志信息
+import org.apache.log4j.Logger;
+
+// 导入农场参数服务类，用于获取字典列表
+import com.farm.parameter.FarmParameterService;
+
+// 定义一个名为 DictionaryOptionTaget 的类，继承自 TagSupport，用于创建自定义 JSP 标签
+public class DictionaryOptionTaget extends TagSupport {
+ // 定义序列化版本号，确保在序列化和反序列化过程中类的兼容性
+ private static final long serialVersionUID = 1L;
+ // 定义一个字符串类型的变量，用于标识是否将文本值作为选项的值
+ private String isTextValue;
+ // 定义一个字符串类型的变量，用于指定字典的索引
+ private String index;
+ // 定义一个静态的日志记录器，用于记录该类的日志信息
+ static final Logger log = Logger.getLogger(DictionaryOptionTaget.class);
+
+ // 重写 doEndTag 方法，在标签结束时执行的逻辑
+ @Override
+ public int doEndTag() throws JspException {
+ // 声明一个存储键值对的列表，用于存储字典项
+ List> list = null;
+ // 调用 FarmParameterService 类的 getInstance 方法获取单例实例，并调用其 getDictionaryList 方法获取指定索引的字典列表
+ list = FarmParameterService.getInstance().getDictionaryList(index);
+ // 获取当前页面的 JspWriter 对象，用于向客户端输出内容
+ JspWriter jspw = this.pageContext.getOut();
+ // 遍历字典列表中的每个键值对
+ for (Entry entry : list) {
+ try {
+ // 判断 isTextValue 去除首尾空格后是否等于 "1"
+ if (isTextValue.trim().equals("1")) {
+ // 如果等于 "1"，则将键值对的值作为选项的值和显示文本输出
+ jspw.println("");
+ } else {
+ // 如果不等于 "1"，则将键值对的键作为选项的值，值作为显示文本输出
+ jspw.println("");
+ }
+ } catch (IOException e) {
+ // 若输出过程中出现输入输出异常，记录错误信息到日志中
+ log.error(e.getMessage());
+ }
+ }
+
+ // 返回 0 表示继续处理页面
+ return 0;
+ }
+
+ // 重写 doStartTag 方法，在标签开始时执行的逻辑
+ @Override
+ public int doStartTag() throws JspException {
+ // 返回 0 表示继续处理页面
+ return 0;
+ }
+
+ // 获取 index 属性值的方法
+ public String getIndex() {
+ return index;
+ }
+
+ // 设置 index 属性值的方法
+ public void setIndex(String index) {
+ this.index = index;
+ }
+
+ // 获取 isTextValue 属性值的方法
+ public String getIsTextValue() {
+ return isTextValue;
+ }
+
+ // 设置 isTextValue 属性值的方法
+ public void setIsTextValue(String isTextValue) {
+ this.isTextValue = isTextValue;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/ParameterEqualsTaget.java b/src/wcp-tag/src/main/java/com/farm/web/tag/ParameterEqualsTaget.java
new file mode 100644
index 0000000..f4c9b87
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/ParameterEqualsTaget.java
@@ -0,0 +1,105 @@
+// 声明当前类所在的包，包名为 com.farm.web.tag
+package com.farm.web.tag;
+
+// 导入 HttpServletRequest 类，用于获取 HTTP 请求相关信息
+import javax.servlet.http.HttpServletRequest;
+// 导入 JspException 类，用于处理 JSP 标签异常
+import javax.servlet.jsp.JspException;
+// 导入 TagSupport 类，它是 JSP 标签处理类的基类，用于实现自定义 JSP 标签
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入 Log4j 的 Logger 类，用于记录日志信息
+import org.apache.log4j.Logger;
+
+// 导入 LoginUser 类，该类代表登录用户的信息
+import com.farm.core.auth.domain.LoginUser;
+// 导入 FarmParameterService 类，用于获取系统参数
+import com.farm.parameter.FarmParameterService;
+// 导入 FarmConstant 类，该类包含了一些系统常量
+import com.farm.web.constant.FarmConstant;
+
+// 定义一个名为 ParameterEqualsTaget 的类，继承自 TagSupport，用于创建自定义 JSP 标签
+public class ParameterEqualsTaget extends TagSupport {
+ /**
+ * 序列化版本号，用于在序列化和反序列化过程中确保类的版本一致性
+ */
+ private static final long serialVersionUID = 1L;
+ // 创建一个静态的 Logger 实例，用于记录该类相关的日志信息
+ static final Logger log = Logger.getLogger(ParameterEqualsTaget.class);
+ // 定义一个字符串类型的变量，用于存储参数的键
+ private String key;
+ // 定义一个字符串类型的变量，用于存储要比较的参数值
+ private String val;
+
+ /**
+ * 重写 doEndTag 方法，该方法在标签结束时执行
+ * @return 返回 EVAL_PAGE 表示继续处理页面的剩余部分
+ * @throws JspException 如果在处理标签时发生异常
+ */
+ @Override
+ public int doEndTag() throws JspException {
+ return EVAL_PAGE;
+ }
+
+ /**
+ * 重写 doStartTag 方法，该方法在标签开始时执行
+ * @return 返回 EVAL_BODY_INCLUDE 表示包含标签体内容，返回 SKIP_BODY 表示跳过标签体内容
+ * @throws JspException 如果在处理标签时发生异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ // 从 pageContext 中获取当前的 HttpServletRequest 对象
+ HttpServletRequest request = (HttpServletRequest) super.pageContext.getRequest();
+ // 声明一个字符串变量，用于存储从系统中获取的参数值
+ String pval = null;
+ // 从会话中获取登录用户的信息
+ LoginUser user = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 如果用户未登录
+ if (user == null) {
+ // 调用 FarmParameterService 的 getParameter 方法，根据键获取全局参数值
+ pval = FarmParameterService.getInstance().getParameter(key);
+ } else {
+ // 如果用户已登录，调用 FarmParameterService 的 getParameter 方法，根据键和用户 ID 获取用户相关的参数值
+ pval = FarmParameterService.getInstance().getParameter(key, user.getId());
+ }
+ // 如果获取到的参数值不为空，并且与要比较的值相等
+ if (pval != null && pval.equals(val)) {
+ // 返回 EVAL_BODY_INCLUDE，表示包含标签体内容
+ return EVAL_BODY_INCLUDE;
+ }
+ // 否则返回 SKIP_BODY，表示跳过标签体内容
+ return SKIP_BODY;
+ }
+
+ /**
+ * 获取参数的键
+ * @return 参数的键
+ */
+ public String getKey() {
+ return key;
+ }
+
+ /**
+ * 设置参数的键
+ * @param key 要设置的参数键
+ */
+ public void setKey(String key) {
+ this.key = key;
+ }
+
+ /**
+ * 获取要比较的参数值
+ * @return 要比较的参数值
+ */
+ public String getVal() {
+ return val;
+ }
+
+ /**
+ * 设置要比较的参数值
+ * @param val 要设置的参数值
+ */
+ public void setVal(String val) {
+ this.val = val;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/ParameterTaget.java b/src/wcp-tag/src/main/java/com/farm/web/tag/ParameterTaget.java
new file mode 100644
index 0000000..1689b4b
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/ParameterTaget.java
@@ -0,0 +1,91 @@
+// 声明该类所在的包名为 com.farm.web.tag
+package com.farm.web.tag;
+
+// 导入用于处理输入输出异常的类
+import java.io.IOException;
+
+// 导入 HttpServletRequest 类，用于获取 HTTP 请求的相关信息
+import javax.servlet.http.HttpServletRequest;
+// 导入 JspException 类，用于处理 JSP 标签操作时可能出现的异常
+import javax.servlet.jsp.JspException;
+// 导入 JspWriter 类，用于向客户端输出内容
+import javax.servlet.jsp.JspWriter;
+// 导入 TagSupport 类，作为自定义 JSP 标签的基类
+import javax.servlet.jsp.tagext.TagSupport;
+
+// 导入 Log4j 的 Logger 类，用于记录日志信息
+import org.apache.log4j.Logger;
+
+// 导入 LoginUser 类，该类代表登录用户的信息
+import com.farm.core.auth.domain.LoginUser;
+// 导入 FarmParameterService 类，用于获取系统参数
+import com.farm.parameter.FarmParameterService;
+// 导入 FarmConstant 类，该类包含了系统的一些常量
+import com.farm.web.constant.FarmConstant;
+
+// 定义一个名为 ParameterTaget 的类，继承自 TagSupport，用于创建自定义 JSP 标签
+public class ParameterTaget extends TagSupport {
+ /**
+ * 序列化版本号，用于确保在序列化和反序列化过程中类的版本一致性
+ */
+ private static final long serialVersionUID = 1L;
+ // 创建一个静态的 Logger 实例，用于记录该类的日志信息
+ static final Logger log = Logger.getLogger(ParameterTaget.class);
+ // 定义一个字符串类型的变量，用于存储要获取的参数的键
+ private String key;
+
+ /**
+ * 重写 doEndTag 方法，该方法在标签结束时执行
+ * @return 返回 0，表示继续处理页面的后续内容
+ * @throws JspException 如果在处理标签结束时发生异常
+ */
+ @Override
+ public int doEndTag() throws JspException {
+ return 0;
+ }
+
+ /**
+ * 重写 doStartTag 方法，该方法在标签开始时执行
+ * @return 返回 0，表示继续处理页面的后续内容
+ * @throws JspException 如果在处理标签开始时发生异常
+ */
+ @Override
+ public int doStartTag() throws JspException {
+ // 从 pageContext 中获取当前的 HttpServletRequest 对象
+ HttpServletRequest request = (HttpServletRequest) this.pageContext.getRequest();
+ // 从会话中获取当前登录的用户信息
+ LoginUser currentUser = (LoginUser) request.getSession().getAttribute(FarmConstant.SESSION_USEROBJ);
+ // 获取 JspWriter 对象，用于向客户端输出内容
+ JspWriter jspw = this.pageContext.getOut();
+ try {
+ // 如果当前用户未登录
+ if (currentUser == null) {
+ // 调用 FarmParameterService 的 getParameter 方法，根据键获取全局参数值，并输出到客户端
+ jspw.print(FarmParameterService.getInstance().getParameter(key.trim()));
+ } else {
+ // 如果当前用户已登录，调用 FarmParameterService 的 getParameter 方法，根据键和用户 ID 获取用户相关的参数值，并输出到客户端
+ jspw.print(FarmParameterService.getInstance().getParameter(key.trim(), currentUser.getId()));
+ }
+ } catch (IOException e) {
+ // 如果在输出内容时发生输入输出异常，记录错误信息到日志中
+ log.error(e.getMessage());
+ }
+ return 0;
+ }
+
+ /**
+ * 获取参数的键
+ * @return 参数的键
+ */
+ public String getKey() {
+ return key;
+ }
+
+ /**
+ * 设置参数的键
+ * @param key 要设置的参数键
+ */
+ public void setKey(String key) {
+ this.key = key;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByConstantKey.java b/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByConstantKey.java
new file mode 100644
index 0000000..eec7ecc
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByConstantKey.java
@@ -0,0 +1,127 @@
+package com.farm.web.tag;
+// 声明该类所属的包为 com.farm.web.tag
+
+import java.io.IOException;
+// 导入处理输入输出异常的类，用于捕获可能的 I/O 异常
+
+import java.util.HashMap;
+// 导入 HashMap 类，用于创建和操作键值对集合
+
+import java.util.Map;
+// 导入 Map 接口，定义了键值对集合的通用操作
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 标签异常类，用于处理标签执行过程中可能抛出的异常
+
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 输出流类，用于向客户端输出内容
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 TagSupport 类，作为自定义 JSP 标签的基类
+
+import org.apache.log4j.Logger;
+// 导入 Log4j 的日志记录器类，用于记录日志信息
+
+import com.farm.parameter.FarmParameterService;
+// 导入农场参数服务类，用于获取系统参数
+
+import com.farm.util.validate.ValidUtils;
+// 导入工具类，用于验证字符串等的有效性
+
+/**
+ * @author Administrator
+ *
+ */
+public class RunDictionaryByConstantKey extends TagSupport {
+ // 定义一个名为 RunDictionaryByConstantKey 的类，继承自 TagSupport，用于创建自定义 JSP 标签
+
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，确保在序列化和反序列化过程中类的兼容性
+
+ static final Logger log = Logger.getLogger(ParameterTaget.class);
+ // 创建一个静态的日志记录器实例，用于记录该类的日志信息，这里的 ParameterTaget 可能是写错了，应该是当前类名 RunDictionaryByConstantKey
+
+ private String val;
+ // 定义一个字符串类型的变量，用于存储待转义的值
+
+ private String key;
+ // 定义一个字符串类型的变量，用于存储数据字典的键
+
+ @Override
+ public int doEndTag() throws JspException {
+ // 重写 doEndTag 方法，在标签结束时执行
+ return 0;
+ // 返回 0 表示继续处理页面，不做特殊处理
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ // 重写 doStartTag 方法，在标签开始时执行
+
+ JspWriter jspw = this.pageContext.getOut();
+ // 获取 JSP 的输出流对象，用于向客户端输出内容
+
+ try {
+ key = FarmParameterService.getInstance().getParameter(
+ key);
+ // 调用 FarmParameterService 的单例实例，根据当前的 key 获取系统参数值，并将其赋值给 key 变量
+ // 这里可能会存在问题，因为在获取参数之前 key 可能是未初始化的
+
+ key = key.replaceAll("，", ",").replaceAll("、", ",");
+ // 将 key 中的中文逗号和顿号替换为英文逗号
+
+ String[] ditEntrys = key.split(",");
+ // 根据英文逗号分割 key，得到一个字符串数组
+
+ Map dicMap = new HashMap();
+ // 创建一个 HashMap 用于存储数据字典的键值对
+
+ for (String entryStr : ditEntrys) {
+ // 遍历分割后的字符串数组
+ if (!ValidUtils.isEmptyString(entryStr)) {
+ // 如果当前字符串不为空
+
+ String[] entryA = entryStr.replaceAll("：", ":").split(":");
+ // 将字符串中的中文冒号替换为英文冒号，并根据英文冒号分割字符串，得到一个新的字符串数组
+
+ if (entryA.length == 2
+ &&!ValidUtils.isEmptyString(entryA[0])
+ &&!ValidUtils.isEmptyString(entryA[1])) {
+ // 如果分割后的数组长度为 2，且两个元素都不为空
+
+ dicMap.put(entryA[0].trim(), entryA[1].trim());
+ // 将键值对添加到数据字典 Map 中，去除键和值两端的空白字符
+ }
+ }
+ }
+ jspw.print(dicMap.get(val.trim()));
+ // 根据传入的待转义值 val（去除两端空白字符），从数据字典 Map 中获取对应的值，并将其输出到客户端
+ } catch (IOException e) {
+ // 捕获输入输出异常
+ log.error(e.getMessage());
+ // 将异常信息记录到日志中
+ }
+ return 0;
+ // 返回 0 表示继续处理页面，不做特殊处理
+ }
+
+ public String getVal() {
+ // 获取待转义值的方法
+ return val;
+ }
+
+ public void setVal(String val) {
+ // 设置待转义值的方法
+ this.val = val;
+ }
+
+ public String getKey() {
+ // 获取数据字典键的方法
+ return key;
+ }
+
+ public void setKey(String key) {
+ // 设置数据字典键的方法
+ this.key = key;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByKey.java b/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByKey.java
new file mode 100644
index 0000000..3aa6e11
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByKey.java
@@ -0,0 +1,88 @@
+package com.farm.web.tag;
+// 声明该类所属的包为 com.farm.web.tag
+
+import java.io.IOException;
+// 导入处理输入输出异常的类，用于捕获可能在输出内容时出现的 I/O 异常
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 标签异常类，用于处理标签执行过程中可能抛出的异常
+
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 输出流类，用于向客户端输出内容
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 TagSupport 类，作为自定义 JSP 标签的基类
+
+import org.apache.log4j.Logger;
+// 导入 Log4j 的日志记录器类，用于记录日志信息
+
+import com.farm.parameter.FarmParameterService;
+// 导入农场参数服务类，用于获取系统参数和数据字典相关信息
+
+/**
+ * @author Administrator
+ *
+ */
+public class RunDictionaryByKey extends TagSupport {
+ // 定义一个名为 RunDictionaryByKey 的类，继承自 TagSupport，用于创建自定义 JSP 标签
+
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，确保在序列化和反序列化过程中类的兼容性
+
+ static final Logger log = Logger.getLogger(ParameterTaget.class);
+ // 创建一个静态的日志记录器实例，用于记录该类的日志信息，这里可能是将类名写错了，应该是 RunDictionaryByKey 而不是 ParameterTaget
+
+ private String val;
+ // 定义一个字符串类型的变量，用于存储要从数据字典中查找对应值的键（这里的“键”是指数据字典中具体条目的标识）
+
+ private String key;
+ // 定义一个字符串类型的变量，用于存储数据字典的索引或标识（通过这个来获取对应的整个数据字典）
+
+ @Override
+ public int doEndTag() throws JspException {
+ // 重写 doEndTag 方法，在标签结束时执行
+ return 0;
+ // 返回 0 表示继续处理页面，不做特殊处理
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ // 重写 doStartTag 方法，在标签开始时执行
+
+ JspWriter jspw = this.pageContext.getOut();
+ // 获取 JSP 的输出流对象，用于向客户端输出内容
+
+ try {
+ jspw.print(FarmParameterService.getInstance()
+ .getDictionary(key.trim()).get(val.trim()));
+ // 调用 FarmParameterService 的单例实例，首先根据传入的 key（去除两端空白字符）获取对应的数据字典
+ // 然后再根据传入的 val（去除两端空白字符）从获取到的数据字典中获取对应的值，并将该值通过 JspWriter 输出到客户端页面
+ } catch (IOException e) {
+ // 捕获输入输出异常
+ log.error(e.getMessage());
+ // 将异常信息记录到日志中
+ }
+ return 0;
+ // 返回 0 表示继续处理页面，不做特殊处理
+ }
+
+ public String getVal() {
+ // 获取变量 val 的值的方法
+ return val;
+ }
+
+ public void setVal(String val) {
+ // 设置变量 val 的值的方法
+ this.val = val;
+ }
+
+ public String getKey() {
+ // 获取变量 key 的值的方法
+ return key;
+ }
+
+ public void setKey(String key) {
+ // 设置变量 key 的值的方法
+ this.key = key;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByStr.java b/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByStr.java
new file mode 100644
index 0000000..e7cbc5c
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/RunDictionaryByStr.java
@@ -0,0 +1,115 @@
+package com.farm.web.tag;
+// 声明该类所在的包为 com.farm.web.tag
+
+import java.io.IOException;
+// 导入用于处理输入输出异常的类，后续在向 JSP 输出内容时可能会用到
+
+import java.util.HashMap;
+// 导入 HashMap 类，用于存储键值对，作为数据字典的存储结构
+
+import java.util.Map;
+// 导入 Map 接口，定义了键值对集合的基本操作
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 标签异常类，用于处理自定义标签在执行过程中可能出现的异常
+
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 输出流类，用于向客户端输出内容
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 TagSupport 类，作为自定义 JSP 标签的基类
+
+import org.apache.log4j.Logger;
+// 导入 Log4j 的日志记录器类，用于记录程序运行中的日志信息
+
+import com.farm.util.validate.ValidUtils;
+// 导入验证工具类，用于判断字符串是否为空等操作
+
+/**
+ * @author Administrator
+ *
+ */
+public class RunDictionaryByStr extends TagSupport {
+ // 定义一个名为 RunDictionaryByStr 的类，继承自 TagSupport 类，用于创建自定义 JSP 标签
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，确保在序列化和反序列化过程中类的版本一致性
+
+ static final Logger log = Logger.getLogger(ParameterTaget.class);
+ // 创建一个静态的日志记录器，用于记录该类的日志信息。不过这里类名可能有误，应该是 RunDictionaryByStr
+
+ private String val;
+ // 定义一个字符串变量，用于存储待转换的值
+
+ private String dicStr;
+ // 定义一个字符串变量，用于存储数据字典的字符串表示，格式为 "key1:value1,key2:value2"
+
+ @Override
+ public int doEndTag() throws JspException {
+ // 重写 doEndTag 方法，该方法在标签结束时执行
+ return 0;
+ // 返回 0 表示继续处理页面的后续内容
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ // 重写 doStartTag 方法，该方法在标签开始时执行
+ JspWriter jspw = this.pageContext.getOut();
+ // 获取当前 JSP 页面的输出流对象，用于向客户端输出内容
+
+ try {
+ dicStr = dicStr.replaceAll("，", ",").replaceAll("、", ",");
+ // 将数据字典字符串中的中文逗号和顿号替换为英文逗号，方便后续分割
+
+ String[] ditEntrys = dicStr.split(",");
+ // 根据英文逗号将数据字典字符串分割成多个键值对字符串数组
+
+ Map dicMap = new HashMap();
+ // 创建一个 HashMap 对象，用于存储解析后的数据字典键值对
+
+ for (String entryStr : ditEntrys) {
+ // 遍历键值对字符串数组
+ if (!ValidUtils.isEmptyString(entryStr)) {
+ // 如果当前键值对字符串不为空
+ String[] entryA = entryStr.replaceAll("：", ":").split(":");
+ // 将键值对字符串中的中文冒号替换为英文冒号，并根据英文冒号分割成键和值
+
+ if (entryA.length == 2
+ && !ValidUtils.isEmptyString(entryA[0])
+ && !ValidUtils.isEmptyString(entryA[1])) {
+ // 如果分割后的数组长度为 2，且键和值都不为空
+ dicMap.put(entryA[0].trim(), entryA[1].trim());
+ // 将键值对去除首尾空格后存入 HashMap 中
+ }
+ }
+ }
+ jspw.print(dicMap.get(val.trim()));
+ // 根据待转换的值（去除首尾空格）从数据字典中查找对应的转换后的值，并输出到客户端
+ } catch (IOException e) {
+ // 捕获输出内容时可能出现的输入输出异常
+ log.error(e.getMessage());
+ // 将异常信息记录到日志中
+ }
+ return 0;
+ // 返回 0 表示继续处理页面的后续内容
+ }
+
+ public String getVal() {
+ // 获取待转换值的方法
+ return val;
+ }
+
+ public void setVal(String val) {
+ // 设置待转换值的方法
+ this.val = val;
+ }
+
+ public String getDicStr() {
+ // 获取数据字典字符串的方法
+ return dicStr;
+ }
+
+ public void setDicStr(String dicStr) {
+ // 设置数据字典字符串的方法
+ this.dicStr = dicStr;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/TimeFormat.java b/src/wcp-tag/src/main/java/com/farm/web/tag/TimeFormat.java
new file mode 100644
index 0000000..e010478
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/TimeFormat.java
@@ -0,0 +1,87 @@
+package com.farm.web.tag;
+// 声明该类所在的包为 com.farm.web.tag
+
+import java.io.IOException;
+// 导入用于处理输入输出异常的类，后续在向 JSP 输出内容时可能会用到
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 标签异常类，用于处理自定义标签在执行过程中可能出现的异常
+
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 输出流类，用于向客户端输出内容
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 TagSupport 类，作为自定义 JSP 标签的基类
+
+import org.apache.log4j.Logger;
+// 导入 Log4j 的日志记录器类，用于记录程序运行中的日志信息
+
+import com.farm.core.time.TimeTool;
+// 导入时间处理工具类，用于对时间进行格式化等操作
+
+public class TimeFormat extends TagSupport {
+ // 定义一个名为 TimeFormat 的类，继承自 TagSupport 类，用于创建自定义 JSP 标签
+
+ private String date;
+ // 定义一个字符串变量，用于存储需要格式化的日期时间数据
+
+ private String yyyyMMddHHmmss;
+ // 定义一个字符串变量，用于存储日期时间的格式化模式，例如 "yyyy-MM-dd HH:mm:ss" 这样的格式字符串
+
+ static final Logger log = Logger.getLogger(TimeFormat.class);
+ // 创建一个静态的日志记录器，用于记录该类的日志信息
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，确保在序列化和反序列化过程中类的版本一致性
+
+ @Override
+ public int doEndTag() throws JspException {
+ // 重写 doEndTag 方法，该方法在标签结束时执行
+ // TODO Auto-generated method stub
+ return 0;
+ // 返回 0 表示继续处理页面的后续内容
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ // 重写 doStartTag 方法，该方法在标签开始时执行
+
+ JspWriter jspw = this.pageContext.getOut();
+ // 获取当前 JSP 页面的输出流对象，用于向客户端输出内容
+
+ try {
+ jspw.print(TimeTool.getFormatTimeDate12(date, yyyyMMddHHmmss));
+ // 调用 TimeTool 类的 getFormatTimeDate12 方法，传入需要格式化的日期时间数据 date 和格式化模式 yyyyMMddHHmmss
+ // 将格式化后的日期时间结果通过 JspWriter 输出到客户端页面
+ } catch (IOException e) {
+ // 捕获输出内容时可能出现的输入输出异常
+ log.error(e.getMessage());
+ // 将异常信息记录到日志中
+ }
+ return 0;
+ // 返回 0 表示继续处理页面的后续内容
+ }
+
+ public String getDate() {
+ // 获取需要格式化的日期时间数据的方法
+ return date;
+ }
+
+ public void setDate(String date) {
+ // 设置需要格式化的日期时间数据的方法
+ this.date = date;
+ }
+
+ public String getYyyyMMddHHmmss() {
+ // 获取日期时间格式化模式的方法
+ return yyyyMMddHHmmss;
+ }
+
+ public void setYyyyMMddHHmmss(String yyyyMMddHHmmss) {
+ // 设置日期时间格式化模式的方法
+ this.yyyyMMddHHmmss = yyyyMMddHHmmss;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/UrlEncode.java b/src/wcp-tag/src/main/java/com/farm/web/tag/UrlEncode.java
new file mode 100644
index 0000000..52a7eea
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/UrlEncode.java
@@ -0,0 +1,71 @@
+package com.farm.web.tag;
+// 声明该类所属的包为 com.farm.web.tag
+
+import java.io.IOException;
+// 导入处理输入输出异常的类，用于捕获在 URL 编码过程中可能出现的 I/O 异常
+
+import javax.servlet.jsp.JspException;
+// 导入 JSP 标签异常类，用于处理标签执行过程中可能抛出的异常
+
+import javax.servlet.jsp.JspWriter;
+// 导入 JSP 输出流类，用于向客户端输出内容
+
+import javax.servlet.jsp.tagext.TagSupport;
+// 导入 TagSupport 类，作为自定义 JSP 标签的基类
+
+import org.apache.log4j.Logger;
+// 导入 Log4j 的日志记录器类，用于记录日志信息
+
+public class UrlEncode extends TagSupport {
+ // 定义一个名为 UrlEncode 的类，继承自 TagSupport，用于创建自定义 JSP 标签
+
+ private String val;
+ // 定义一个字符串类型的变量，用于存储需要进行 URL 编码的值
+
+ static final Logger log = Logger.getLogger(UrlEncode.class);
+ // 创建一个静态的日志记录器实例，用于记录该类的日志信息
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ // 定义序列化版本号，确保在序列化和反序列化过程中类的兼容性
+
+ @Override
+ public int doEndTag() throws JspException {
+ // 重写 doEndTag 方法，在标签结束时执行
+ // TODO Auto-generated method stub
+ return 0;
+ // 返回 0 表示继续处理页面，不做特殊处理
+ }
+
+ @Override
+ public int doStartTag() throws JspException {
+ // 重写 doStartTag 方法，在标签开始时执行
+
+ JspWriter jspw = this.pageContext.getOut();
+ // 获取 JSP 的输出流对象，用于向客户端输出内容
+
+ try {
+ jspw.print(java.net.URLEncoder.encode(java.net.URLEncoder.encode(val, "utf-8"), "utf-8"));
+ // 对传入的 val 进行两次 UTF-8 编码，首先对 val 进行第一次 URL 编码，然后对第一次编码的结果再进行一次 URL 编码
+ // 最后将编码后的结果通过 JspWriter 输出到客户端页面
+ } catch (IOException e) {
+ // 捕获输入输出异常
+ log.error(e.getMessage());
+ // 将异常信息记录到日志中
+ }
+ return 0;
+ // 返回 0 表示继续处理页面，不做特殊处理
+ }
+
+ public String getVal() {
+ // 获取变量 val 的值的方法
+ return val;
+ }
+
+ public void setVal(String val) {
+ // 设置变量 val 的值的方法
+ this.val = val;
+ }
+}
\ No newline at end of file
diff --git a/src/wcp-tag/src/main/java/com/farm/web/tag/platForm.tld b/src/wcp-tag/src/main/java/com/farm/web/tag/platForm.tld
new file mode 100644
index 0000000..d9508b5
--- /dev/null
+++ b/src/wcp-tag/src/main/java/com/farm/web/tag/platForm.tld
@@ -0,0 +1,256 @@
+
+
+
+
+
+ 1.0
+
+ 1.2
+
+ tagSample
+
+ /hellotag
+
+
+ AuthForUser
+
+ com.farm.web.tag.AuthorityForUser
+
+ jsp
+
+
+ actionName
+
+ true
+
+ true
+
+
+
+
+ basePath
+
+ com.farm.web.tag.BasePathTaget
+
+ empty
+
+
+
+ urlEncode
+
+ com.farm.web.tag.UrlEncode
+
+ empty
+
+
+ val
+
+ true
+
+ true
+
+
+
+
+ OptionDictionary
+
+
+ com.farm.web.tag.DictionaryOptionTaget
+
+
+ empty
+
+
+ isTextValue
+
+
+ true
+
+ true
+
+
+
+ index
+
+ true
+
+ true
+
+
+
+
+ FormatTime
+
+
+ com.farm.web.tag.TimeFormat
+
+
+ empty
+
+
+ date
+
+ true
+
+ true
+
+
+
+ yyyyMMddHHmmss
+
+ true
+
+ false
+
+
+
+
+ ParameterValue
+
+
+ com.farm.web.tag.ParameterTaget
+
+
+ empty
+
+
+ key
+
+ true
+
+ true
+
+
+
+
+ IfParameterEquals
+
+
+ com.farm.web.tag.ParameterEqualsTaget
+
+
+ jsp
+
+
+ key
+
+ true
+
+ true
+
+
+
+ val
+
+ true
+
+ true
+
+
+
+
+ runDictionaryByStr
+
+
+ com.farm.web.tag.RunDictionaryByStr
+
+
+ empty
+
+
+ val
+
+ true
+
+ true
+
+
+
+ dicStr
+
+ true
+
+ true
+
+
+
+
+ runDictionaryByKey
+
+
+ com.farm.web.tag.RunDictionaryByKey
+
+
+ empty
+
+
+ val
+
+ true
+
+ true
+
+
+
+ key
+
+ true
+
+ false
+
+
+
+
+ runDictionaryByConstantKey
+
+
+ com.farm.web.tag.RunDictionaryByConstantKey
+
+
+ empty
+
+
+ val
+
+ true
+
+ true
+
+
+
+ key
+
+ true
+
+ false
+
+
+
+
+ DictionaryHandle
+
+ com.farm.web.tag.DictionaryHandle
+
+ scriptless
+
+
+ var
+
+ true
+
+ true
+
+
+
+ key
+
+ true
+
+ true
+
+
+
+