src

src/wcp-quartz/pom.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 根元素 project，声明了 Maven 项目对象模型（POM）的 XML 命名空间和 XML 模式实例位置 -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<!-- 模型版本，固定为 4.0.0，代表 Maven POM 的版本 -->
+	<modelVersion>4.0.0</modelVersion>
+	<!-- 项目的组 ID，用于唯一标识项目的组织或公司，这里是 com.farm -->
+	<groupId>com.farm</groupId>
+	<!-- 项目的工件 ID，用于唯一标识项目本身，这里是 wcp-quartz -->
+	<artifactId>wcp-quartz</artifactId>
+	<!-- 项目的版本，使用了属性 ${wcp.version}，具体版本在 properties 标签中定义 -->
+	<version>${wcp.version}</version>
+	<!-- 定义项目的属性，这些属性可以在 POM 的其他部分引用 -->
+	<properties>
+		<!-- 定义 wcp.version 属性，值为 3.2.0，用于指定项目的版本 -->
+		<wcp.version>3.2.0</wcp.version>
+		<!-- 文件拷贝时的编码，设置为 UTF-8 -->
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<!-- 项目报告输出时的编码，设置为 UTF-8 -->
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+		<!-- 编译时的编码，设置为 UTF-8 -->
+		<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+	</properties>
+	<!-- 项目的依赖配置，用于声明项目运行和测试时所依赖的其他库和项目 -->
+	<dependencies>
+		<!-- 依赖项：引入 com.farm 组下的 farm-core 工件，版本为 ${wcp.version} -->
+		<dependency>
+			<groupId>com.farm</groupId>
+			<artifactId>farm-core</artifactId>
+			<version>${wcp.version}</version>
+			<!-- 排除依赖项：排除 javax.servlet.jsp 组下的 jsp-api 工件，防止冲突或不必要的依赖 -->
+			<exclusions>
+				<exclusion>
+					<groupId>javax.servlet.jsp</groupId>
+					<artifactId>jsp-api</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<!-- 依赖项：引入 junit 组下的 junit 工件，版本为 3.8.1，作用域为 test，仅在测试时使用 -->
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>3.8.1</version>
+			<scope>test</scope>
+		</dependency>
+		<!-- 依赖项：引入 org.quartz-scheduler 组下的 quartz 工件，版本为 2.2.1，用于实现定时任务相关功能 -->
+		<dependency>
+			<groupId>org.quartz-scheduler</groupId>
+			<artifactId>quartz</artifactId>
+			<version>2.2.1</version>
+		</dependency>
+	</dependencies>
+	<!-- 项目的构建配置，用于定义构建过程中使用的插件和相关设置 -->
+	<build>
+		<!-- 插件配置列表 -->
+		<plugins>
+			<!-- 插件：maven-compiler-plugin，用于编译 Java 源代码 -->
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<!-- 插件配置 -->
+				<configuration>
+					<!-- 编译使用的 Java 版本源，设置为 1.8 -->
+					<source>1.8</source>
+					<!-- 编译生成的目标 Java 版本，设置为 1.8 -->
+					<target>1.8</target>
+				</configuration>
+			</plugin>
+			<!-- 插件：org.apache.maven.plugins 组下的 maven-jar-plugin，用于创建 JAR 包 -->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-jar-plugin</artifactId>
+				<version>2.1</version>
+				<!-- 插件配置 -->
+				<configuration>
+					<!-- 归档配置，用于设置 JAR 包的元数据等信息 -->
+					<archive>
+						<!-- 清单文件配置，自动添加默认的实现项条目 -->
+						<manifest>
+							<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+							<!-- 清单文件配置，自动添加默认的规范项条目 -->
+							<addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+						</manifest>
+					</archive>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>

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<String> options;
+	// 存储要处理的 Java 文件对象
+	private final Iterable<? extends JavaFileObject> fileObjects;
+	// 存储当前使用的语言环境
+	private Locale locale;
+	// 存储要添加的模块名称列表
+	private final List<String> addModules = new ArrayList<>();
+
+	/**
+	 * 构造函数，初始化 Javadoc 任务的相关属性。
+	 *
+	 * @param context      编译上下文
+	 * @param docletClass  文档生成器的类对象
+	 * @param options      传递给 javadoc 的选项
+	 * @param fileObjects  要处理的 Java 文件对象
+	 */
+	public JavadocTaskImpl(Context context,
+						   Class<?> docletClass,
+						   Iterable<String> options,
+						   Iterable<? extends JavaFileObject> 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<String> 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 <T>   可迭代对象中元素的类型
+	 * @return 检查后的可迭代对象
+	 * @throws NullPointerException 如果可迭代对象中有 null 值
+	 */
+	private static <T> Iterable<T> nullCheck(Iterable<T> items) {
+		// 遍历可迭代对象中的元素
+		for (T item : items) {
+			// 如果元素为 null，抛出空指针异常
+			if (item == null)
+				throw new NullPointerException();
+		}
+		// 返回检查后的可迭代对象
+		return items;
+	}
+}

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<DBRule> rules);
+
+	/**
+	 * 条件查询实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+	 * 
+	 * @param rules
+	 *            查询条件
+	 * @return
+	 */
+	public List<FarmQzScheduler> selectEntitys(List<DBRule> rules);
+
+	/**
+	 * 条件修改实体，依据对象字段值(一般不建议使用该方法)
+	 * 
+	 * @param values
+	 *            被修改的键值对
+	 * @param rules
+	 *            修改条件
+	 */
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules);
+	/**
+	 * 获得所有需要自动启动的计划任务
+	 */
+	public List<FarmQzScheduler> getAutoSchedulers();
+}

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<DBRule> rules);
+
+	/**
+	 * 条件查询实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+	 * 
+	 * @param rules
+	 *            查询条件
+	 * @return
+	 */
+	public List<FarmQzTask> selectEntitys(List<DBRule> rules);
+
+	/**
+	 * 条件修改实体，依据对象字段值(一般不建议使用该方法)
+	 * 
+	 * @param values
+	 *            被修改的键值对
+	 * @param rules
+	 *            修改条件
+	 */
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules);
+}

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<DBRule> rules);
+
+	/**
+	 * 条件查询实体，依据对象字段值,当rules为空时查询全部(一般不建议使用该方法)
+	 * 
+	 * @param rules
+	 *            查询条件
+	 * @return
+	 */
+	public List<FarmQzTrigger> selectEntitys(List<DBRule> rules);
+
+	/**
+	 * 条件修改实体，依据对象字段值(一般不建议使用该方法)
+	 * 
+	 * @param values
+	 *            被修改的键值对
+	 * @param rules
+	 *            修改条件
+	 */
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules);
+}

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<FarmQzScheduler>
+		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<DBRule> rules) {
+		// 调用父类的 deleteSqlFromFunction 方法，传入当前 Session 对象和规则列表执行删除操作
+		deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	// 根据规则查询实体列表的方法
+	@Override
+	public List<FarmQzScheduler> selectEntitys(List<DBRule> rules) {
+		// 调用父类的 selectSqlFromFunction 方法，传入当前 Session 对象和规则列表执行查询，并返回查询结果列表
+		return selectSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	// 根据规则更新实体的方法
+	@Override
+	public void updataEntitys(Map<String, Object> values, List<DBRule> 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<FarmQzScheduler> 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;
+	}
+}

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<FarmQzTask> 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<DBRule> rules) {
+		// 调用父类的 deleteSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行删除操作
+		deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	// 根据规则查询多个任务实体的方法
+	@Override
+	public List<FarmQzTask> selectEntitys(List<DBRule> rules) {
+		// 调用父类的 selectSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行查询操作并返回查询结果列表
+		return selectSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	// 根据规则更新多个任务实体的方法
+	@Override
+	public void updataEntitys(Map<String, Object> values, List<DBRule> 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;
+	}
+}

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<FarmQzTrigger>
+		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<DBRule> rules) {
+		// 调用父类的 deleteSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行删除操作
+		deleteSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	// 根据规则查询多个触发器实体的方法
+	@Override
+	public List<FarmQzTrigger> selectEntitys(List<DBRule> rules) {
+		// 调用父类的 selectSqlFromFunction 方法，传入当前的 Session 对象和规则列表，执行查询操作并返回查询结果列表
+		return selectSqlFromFunction(sessionFatory.getCurrentSession(), rules);
+	}
+
+	// 根据规则更新多个触发器实体的方法
+	@Override
+	public void updataEntitys(Map<String, Object> values, List<DBRule> rules) {
+		// 调用父类的 updataSqlFromFunction 方法，传入当前的 Session 对象、更新值映射和规则列表，执行更新操作
+		updataSqlFromFunction(sessionFatory.getCurrentSession(), values, rules);
+	}
+
+	// 重写获取 SessionFactory 对象的方法，供父类相关方法使用
+	@Override
+	protected SessionFactory getSessionFactory() {
+		return sessionFatory;
+	}
+
+	// 重写获取实体类类型的方法，供父类相关方法使用
+	@Override
+	protected Class<?> getTypeClass() {
+		return FarmQzTrigger.class;
+	}
+}

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

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

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

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

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
+
+	}
+}

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

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

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

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

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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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 {
+			// 根据请求模式的操作类型进行

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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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");
+	}
+}

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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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;
+	// }
+
+}

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

src/wcp-tag/pom.xml

@@ -0,0 +1,92 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<!-- 根元素，定义了项目的基本信息，同时指定了 XML 命名空间和模式位置 -->
+
+	<modelVersion>4.0.0</modelVersion>
+	<!-- 指定 POM（Project Object Model）的版本号，这里是 4.0.0 -->
+
+	<groupId>com.farm</groupId>
+	<!-- 项目的组 ID，通常是公司或组织的反向域名，用于唯一标识项目组 -->
+
+	<artifactId>wcp-tag</artifactId>
+	<!-- 项目的工件 ID，用于唯一标识项目本身 -->
+
+	<version>${wcp.version}</version>
+	<!-- 项目的版本号，这里使用了属性引用 ${wcp.version}，具体版本在下面的 properties 部分定义 -->
+
+	<name>jsp标签库</name>
+	<!-- 项目的名称，用于在 Maven 构建输出和其他地方显示 -->
+
+	<properties>
+		<!-- 定义项目的属性部分 -->
+		<wcp.version>3.2.0</wcp.version>
+		<!-- 定义了一个名为 wcp.version 的属性，值为 3.2.0，用于统一管理项目版本 -->
+
+		<!-- 文件拷贝时的编码 -->
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<!-- 设置项目构建时文件拷贝的编码为 UTF-8 -->
+
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+		<!-- 设置项目报告生成时的输出编码为 UTF-8 -->
+
+		<!-- 编译时的编码 -->
+		<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+		<!-- 设置 Maven 编译器的编码为 UTF-8 -->
+	</properties>
+
+	<dependencies>
+		<!-- 定义项目的依赖部分 -->
+		<dependency>
+			<groupId>com.farm</groupId>
+			<artifactId>farm-core</artifactId>
+			<version>${wcp.version}</version>
+		</dependency>
+		<!-- 引入名为 farm-core 的依赖，组 ID 为 com.farm，版本为 ${wcp.version}（即 3.2.0） -->
+
+		<dependency>
+			<groupId>com.farm</groupId>
+			<artifactId>wcp-authority</artifactId>
+			<version>${wcp.version}</version>
+		</dependency>
+		<!-- 引入名为 wcp-authority 的依赖，组 ID 为 com.farm，版本为 ${wcp.version}（即 3.2.0） -->
+
+		<dependency>
+			<groupId>com.farm</groupId>
+			<artifactId>wcp-parameter</artifactId>
+			<version>${wcp.version}</version>
+		</dependency>
+		<!-- 引入名为 wcp-parameter 的依赖，组 ID 为 com.farm，版本为 ${wcp.version}（即 3.2.0） -->
+
+		<dependency>
+			<groupId>com.farm</groupId>
+			<artifactId>wcp-doc</artifactId>
+			<version>${wcp.version}</version>
+		</dependency>
+		<!-- 引入名为 wcp-doc 的依赖，组 ID 为 com.farm，版本为 ${wcp.version}（即 3.2.0） -->
+
+		<dependency>
+			<groupId>com.farm</groupId>
+			<artifactId>wda-api</artifactId>
+			<version>1.2.2</version>
+		</dependency>
+		<!-- 引入名为 wda-api 的依赖，组 ID 为 com.farm，版本为 1.2.2 -->
+	</dependencies>
+
+	<build>
+		<!-- 定义项目的构建部分 -->
+		<plugins>
+			<!-- 定义项目使用的插件部分 -->
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<!-- 指定插件的工件 ID 为 maven-compiler-plugin，即 Maven 编译器插件 -->
+				<configuration>
+					<!-- 插件的配置部分 -->
+					<source>1.8</source>
+					<!-- 设置编译的源版本为 Java 1.8 -->
+					<target>1.8</target>
+					<!-- 设置编译的目标版本为 Java 1.8 -->
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>

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

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

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

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

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

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<Map<String, Object>> list = docGroupIMP.getEditorGroupByUser(user
+				.getId());
+		// 从当前页面上下文获取 JSP 输出流
+		JspWriter jspw = this.pageContext.getOut();
+		// 遍历文档组列表
+		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
+			// 获取当前文档组的信息
+			Map<String, String> type = (Map<String, String>) iterator.next();
+			try {
+				// 生成 HTML 选项标签，并将文档组的 ID 和名称输出到 JSP 页面
+				jspw.println("<option value='" + type.get("ID") + "'>"
+						+ (aroundS != null ? aroundS : "") + type.get("NAME")
+						+ (aroundE != null ? aroundE : "") + "</option>");
+			} 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;
+	}
+}

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

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

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

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

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

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

src/wcp-tag/src/main/java/com/farm/doc/tag/farmdoc.tld

@@ -0,0 +1,216 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 声明 XML 文档的版本为 1.0，编码为 UTF-8 -->
+<!DOCTYPE taglib
+		PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
+		"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
+<!-- 引入 JSP 标签库的 DTD 定义，指定其公共标识符和系统标识符 -->
+<taglib>
+	<tlib-version>1.0</tlib-version>
+	<!-- 定义标签库的版本为 1.0 -->
+	<jsp-version>1.2</jsp-version>
+	<!-- 定义该标签库适用的 JSP 版本为 1.2 -->
+	<short-name>文档功能标签</short-name>
+	<!-- 为标签库指定一个简短的名称，这里是“文档功能标签” -->
+	<uri>/hellotag</uri>
+	<!-- 定义标签库的 URI，用于在 JSP 页面中引用该标签库 -->
+	<tag><!-- 用户拥有修改权限则显示标签内的内容 -->
+		<name>Describe</name>
+		<!-- 定义标签的名称为“Describe” -->
+		<tag-class>com.farm.doc.tag.DocDescribe</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.DocDescribe -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>text</name>
+			<!-- 定义标签的属性名称为“text” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“text”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“text”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute>
+			<name>maxnum</name>
+			<!-- 定义标签的属性名称为“maxnum” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“maxnum”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“maxnum”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 默认首页 -->
+		<name>defaultIndexPage</name>
+		<!-- 定义标签的名称为“defaultIndexPage” -->
+		<tag-class>com.farm.doc.tag.DefaultIndexPageTaget</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.DefaultIndexPageTaget -->
+		<body-content>empty</body-content>
+		<!-- 定义标签体的内容类型为“empty”，表示标签体为空 -->
+	</tag>
+	<tag><!-- 用户拥有修改权限则显示标签内的内容 -->
+		<name>canWriteIsShow</name>
+		<!-- 定义标签的名称为“canWriteIsShow” -->
+		<tag-class>com.farm.doc.tag.WriteIsShowForUser</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.WriteIsShowForUser -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>docId</name>
+			<!-- 定义标签的属性名称为“docId” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“docId”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“docId”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 用户不拥有修改权限则显示标签内的内容 -->
+		<name>canNoWriteIsShow</name>
+		<!-- 定义标签的名称为“canNoWriteIsShow” -->
+		<tag-class>com.farm.doc.tag.NoWriteIsShowForUser</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.NoWriteIsShowForUser -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>docId</name>
+			<!-- 定义标签的属性名称为“docId” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“docId”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“docId”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 用户拥有审核权限则显示标签内的内容 -->
+		<name>canAuditIsShow</name>
+		<!-- 定义标签的名称为“canAuditIsShow” -->
+		<tag-class>com.farm.doc.tag.AuditIsShowForUser</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.AuditIsShowForUser -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>docId</name>
+			<!-- 定义标签的属性名称为“docId” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“docId”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“docId”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 用户拥有删除权限则显示标签内的内容 -->
+		<name>canDelIsShow</name>
+		<!-- 定义标签的名称为“canDelIsShow” -->
+		<tag-class>com.farm.doc.tag.DelIsShowForUser</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.DelIsShowForUser -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>docId</name>
+			<!-- 定义标签的属性名称为“docId” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“docId”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“docId”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 用户不拥有删除权限则显示标签内的内容 -->
+		<name>canNoDelIsShow</name>
+		<!-- 定义标签的名称为“canNoDelIsShow” -->
+		<tag-class>com.farm.doc.tag.NoDelIsShowForUser</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.NoDelIsShowForUser -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>docId</name>
+			<!-- 定义标签的属性名称为“docId” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“docId”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“docId”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 用户拥有阅读权限则显示标签内的内容 -->
+		<name>canReadsShow</name>
+		<!-- 定义标签的名称为“canReadsShow” -->
+		<tag-class>com.farm.doc.tag.ReadIsShowForUser</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.ReadIsShowForUser -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>docId</name>
+			<!-- 定义标签的属性名称为“docId” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“docId”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“docId”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 用户不拥有阅读权限则显示标签内的内容 -->
+		<name>canNoReadsShow</name>
+		<!-- 定义标签的名称为“canNoReadsShow” -->
+		<tag-class>com.farm.doc.tag.NoReadIsShowForUserr</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.NoReadIsShowForUserr -->
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为“jsp”，表示标签体可以包含 JSP 内容 -->
+		<attribute>
+			<name>docId</name>
+			<!-- 定义标签的属性名称为“docId” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“docId”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“docId”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 用户小组Option项(只加载用户享有编辑权限的小组) -->
+		<name>docGroupOption</name>
+		<!-- 定义标签的名称为“docGroupOption” -->
+		<tag-class>com.farm.doc.tag.DocGroupOption</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.DocGroupOption -->
+		<body-content>empty</body-content>
+		<!-- 定义标签体的内容类型为“empty”，表示标签体为空 -->
+		<attribute>
+			<name>aroundS</name><!-- 字段索引名 -->
+			<!-- 定义标签的属性名称为“aroundS” -->
+			<required>false</required><!-- 是否必填 -->
+			<!-- 表示“aroundS”属性不是必填的 -->
+			<rtexprvalue>false</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“aroundS”属性不可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute>
+			<name>aroundE</name><!-- 字段索引名 -->
+			<!-- 定义标签的属性名称为“aroundE” -->
+			<required>false</required><!-- 是否必填 -->
+			<!-- 表示“aroundE”属性不是必填的 -->
+			<rtexprvalue>false</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“aroundE”属性不可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 显示文档内容 -->
+		<name>docContent</name>
+		<!-- 定义标签的名称为“docContent” -->
+		<tag-class>com.farm.doc.tag.DocContent</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.DocContent -->
+		<body-content>empty</body-content>
+		<!-- 定义标签体的内容类型为“empty”，表示标签体为空 -->
+		<attribute>
+			<name>id</name><!-- 字段索引名 -->
+			<!-- 定义标签的属性名称为“id” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“id”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“id”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 显示图片URL -->
+		<name>ImgUrl</name>
+		<!-- 定义标签的名称为“ImgUrl” -->
+		<tag-class>com.farm.doc.tag.ImgUrl</tag-class>
+		<!-- 指定该标签对应的 Java 类的全限定名，这里是 com.farm.doc.tag.ImgUrl -->
+		<body-content>empty</body-content>
+		<!-- 定义标签体的内容类型为“empty”，表示标签体为空 -->
+		<attribute>
+			<name>fileid</name><!-- 字段索引名 -->
+			<!-- 定义标签的属性名称为“fileid” -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示“fileid”属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示“fileid”属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+</taglib>

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<String> 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<String> 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<String> 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;
+	}
+}

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<String> 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<String> 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<String> 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;
+		}
+	}
+}

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

src/wcp-tag/src/main/java/com/farm/wda/tag/wda.tld

@@ -0,0 +1,237 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 声明该XML文档的版本为1.0，使用UTF-8字符编码 -->
+
+<!DOCTYPE taglib
+		PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
+		"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
+<!-- 定义文档类型为taglib，引用Sun Microsystems提供的JSP标签库1.2的DTD（文档类型定义）
+     DTD用于定义XML文档的结构和语法规则，这里指定了JSP标签库的相关规范 -->
+
+<taglib>
+	<!-- 标签库的根元素，包含了标签库的各种定义信息 -->
+
+	<tlib-version>1.0</tlib-version>
+	<!-- 定义标签库的版本号为1.0，用于标识标签库的版本信息，方便版本管理和升级 -->
+
+	<jsp-version>1.2</jsp-version>
+	<!-- 定义该标签库所适用的JSP版本为1.2，确保标签库与JSP环境的兼容性 -->
+
+	<short-name>在线预览功能标签库</short-name>
+	<!-- 为标签库指定一个简短的名称“在线预览功能标签库”，用于在开发文档或工具中简单描述标签库的功能 -->
+
+	<uri>/hellotag</uri>
+	<!-- 定义标签库的URI（统一资源标识符）为/hellotag，在JSP页面中使用taglib指令引入标签库时会用到该URI -->
+
+	<tag><!-- 获取文档预览URL -->
+		<!-- 定义一个标签，标签的功能是获取文档的预览URL，下面是该标签的具体配置信息 -->
+
+		<name>DocWebViewUrl</name>
+		<!-- 定义标签的名称为DocWebViewUrl，在JSP页面中使用该标签时会用到这个名称 -->
+
+		<tag-class>com.farm.wda.tag.DocWebViewUrl</tag-class>
+		<!-- 指定标签对应的Java类为com.farm.wda.tag.DocWebViewUrl，该类实现了标签的具体逻辑 -->
+
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为jsp，表示标签体中可以包含JSP代码，如HTML、脚本等 -->
+
+		<attribute>
+			<!-- 开始定义标签的一个属性，这里是fileid属性 -->
+
+			<name>fileid</name>
+			<!-- 定义属性的名称为fileid，在JSP页面中使用标签时通过这个名称来指定属性值 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 标记该属性为必填属性，即使用标签时必须为该属性提供值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用EL表达式（${}）来传递值，增加了属性值设置的灵活性 -->
+
+		</attribute>
+
+		<attribute>
+			<!-- 开始定义标签的另一个属性，这里是docid属性 -->
+
+			<name>docid</name>
+			<!-- 定义属性的名称为docid，在JSP页面中使用标签时通过这个名称来指定属性值 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 标记该属性为必填属性，即使用标签时必须为该属性提供值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用EL表达式（${}）来传递值，增加了属性值设置的灵活性 -->
+
+		</attribute>
+
+	</tag>
+
+	<tag><!-- 是否支持该类型的文档-->
+		<!-- 定义一个标签，标签的功能是判断是否支持该类型的文档，下面是该标签的具体配置信息 -->
+
+		<name>IsSupport</name>
+		<!-- 定义标签的名称为IsSupport，在JSP页面中使用该标签时会用到这个名称 -->
+
+		<tag-class>com.farm.wda.tag.IsSupport</tag-class>
+		<!-- 指定标签对应的Java类为com.farm.wda.tag.IsSupport，该类实现了标签的具体逻辑 -->
+
+		<body-content>jsp</body-content>
+		<!-- 定义标签体的内容类型为jsp，表示标签体中可以包含JSP代码，如HTML、脚本等 -->
+
+		<attribute>
+			<!-- 开始定义标签的一个属性，这里是fileid属性 -->
+
+			<name>fileid</name>
+			<!-- 定义属性的名称为fileid，在JSP页面中使用标签时通过这个名称来指定属性值 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 标记该属性为必填属性，即使用标签时必须为该属性提供值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用EL表达式（${}）来传递值，增加了属性值设置的灵活性 -->
+
+		</attribute>
+
+	</tag>
+
+	<!-- 新增一个标签，用于获取文档的编辑权限状态 -->
+	<tag><!-- 获取文档的编辑权限状态 -->
+
+		<name>GetDocEditPermission</name>
+		<!-- 定义标签的名称为GetDocEditPermission，用于在JSP页面中调用该标签 -->
+
+		<tag-class>com.farm.wda.tag.GetDocEditPermissionTag</tag-class>
+		<!-- 指定标签对应的Java类为com.farm.wda.tag.GetDocEditPermissionTag，该类需实现具体的权限判断逻辑 -->
+
+		<body-content>jsp</body-content>
+		<!-- 标签体内容类型为jsp，意味着标签体中可包含JSP相关代码，如HTML片段、JSP脚本等 -->
+
+		<attribute>
+			<name>docid</name>
+			<!-- 定义属性名称为docid，用于传入文档的唯一标识 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表明docid属性为必填项，使用标签时必须提供该属性的值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示docid属性可以使用EL表达式（${}）来动态传递值 -->
+
+		</attribute>
+
+		<attribute>
+			<name>userid</name>
+			<!-- 定义属性名称为userid，用于传入用户的唯一标识 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表明userid属性为必填项，使用标签时必须提供该属性的值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示userid属性可以使用EL表达式（${}）来动态传递值 -->
+
+		</attribute>
+
+	</tag>
+
+	<!-- 新增一个标签，用于获取文档的创建时间 -->
+	<tag><!-- 获取文档的创建时间 -->
+
+		<name>GetDocCreateTime</name>
+		<!-- 定义标签的名称为GetDocCreateTime，用于在JSP页面中调用该标签 -->
+
+		<tag-class>com.farm.wda.tag.GetDocCreateTimeTag</tag-class>
+		<!-- 指定标签对应的Java类为com.farm.wda.tag.GetDocCreateTimeTag，该类需实现获取文档创建时间的逻辑 -->
+
+		<body-content>jsp</body-content>
+		<!-- 标签体内容类型为jsp，意味着标签体中可包含JSP相关代码，如HTML片段、JSP脚本等 -->
+
+		<attribute>
+			<name>docid</name>
+			<!-- 定义属性名称为docid，用于传入文档的唯一标识 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表明docid属性为必填项，使用标签时必须提供该属性的值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示docid属性可以使用EL表达式（${}）来动态传递值 -->
+
+		</attribute>
+
+	</tag>
+
+	<!-- 新增一个标签，用于判断文档是否为重要文档 -->
+	<tag><!-- 判断文档是否为重要文档 -->
+
+		<name>IsDocImportant</name>
+		<!-- 定义标签的名称为IsDocImportant，用于在JSP页面中调用该标签 -->
+
+		<tag-class>com.farm.wda.tag.IsDocImportantTag</tag-class>
+		<!-- 指定标签对应的Java类为com.farm.wda.tag.IsDocImportantTag，该类需实现判断文档是否重要的逻辑 -->
+
+		<body-content>jsp</body-content>
+		<!-- 标签体内容类型为jsp，意味着标签体中可包含JSP相关代码，如HTML片段、JSP脚本等 -->
+
+		<attribute>
+			<name>docid</name>
+			<!-- 定义属性名称为docid，用于传入文档的唯一标识 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表明docid属性为必填项，使用标签时必须提供该属性的值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示docid属性可以使用EL表达式（${}）来动态传递值 -->
+
+		</attribute>
+
+	</tag>
+
+	<!-- 新增一个标签，用于获取文档的相关附件数量 -->
+	<tag><!-- 获取文档的相关附件数量 -->
+
+		<name>GetDocAttachmentCount</name>
+		<!-- 定义标签的名称为GetDocAttachmentCount，用于在JSP页面中调用该标签 -->
+
+		<tag-class>com.farm.wda.tag.GetDocAttachmentCountTag</tag-class>
+		<!-- 指定标签对应的Java类为com.farm.wda.tag.GetDocAttachmentCountTag，该类需实现获取文档附件数量的逻辑 -->
+
+		<body-content>jsp</body-content>
+		<!-- 标签体内容类型为jsp，意味着标签体中可包含JSP相关代码，如HTML片段、JSP脚本等 -->
+
+		<attribute>
+			<name>docid</name>
+			<!-- 定义属性名称为docid，用于传入文档的唯一标识 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表明docid属性为必填项，使用标签时必须提供该属性的值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示docid属性可以使用EL表达式（${}）来动态传递值 -->
+
+		</attribute>
+
+	</tag>
+
+	<!-- 新增一个标签，用于获取文档的版本信息 -->
+	<tag><!-- 获取文档的版本信息 -->
+
+		<name>GetDocVersionInfo</name>
+		<!-- 定义标签的名称为GetDocVersionInfo，用于在JSP页面中调用该标签 -->
+
+		<tag-class>com.farm.wda.tag.GetDocVersionInfoTag</tag-class>
+		<!-- 指定标签对应的Java类为com.farm.wda.tag.GetDocVersionInfoTag，该类需实现获取文档版本信息的逻辑 -->
+
+		<body-content>jsp</body-content>
+		<!-- 标签体内容类型为jsp，意味着标签体中可包含JSP相关代码，如HTML片段、JSP脚本等 -->
+
+		<attribute>
+			<name>docid</name>
+			<!-- 定义属性名称为docid，用于传入文档的唯一标识 -->
+
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表明docid属性为必填项，使用标签时必须提供该属性的值 -->
+
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示docid属性可以使用EL表达式（${}）来动态传递值 -->
+
+		</attribute>
+
+	</tag>
+
+</taglib>

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<String> usraction = ((Set<String>) request.getSession()
+				.getAttribute(FarmConstant.SESSION_USERACTION));
+		// 从请求的会话中获取名为FarmConstant.SESSION_USERACTION的属性值，并将其转换为Set<String>类型
+		// 这个属性值可能存储了当前用户拥有的操作权限集合
+
+		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<String> getUserRoles(HttpServletRequest request) {
+		try {
+			// 尝试获取用户的角色信息
+			return (Set<String>) request.getSession().getAttribute(FarmConstant.SESSION_USERROLES);
+			// 从会话中获取名为FarmConstant.SESSION_USERROLES的属性值，并转换为Set<String>类型返回
+			// 假设该属性存储了用户的角色集合
+		} catch (Exception e) {
+			// 如果在获取过程中出现异常
+			e.printStackTrace();
+			// 打印异常堆栈信息，方便调试
+			return null;
+			// 如果获取失败，返回null
+		}
+	}
+
+	// 增加一个方法，根据用户角色和操作权限进行额外的提示或操作
+	private void handleUserRoleAndPermission(Set<String> userRoles, Set<String> 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<String> 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<String> usraction = ((Set<String>) request.getSession()
+				.getAttribute(FarmConstant.SESSION_USERACTION));
+
+		AuthorityService farmAuthService = FarmAuthorityService.getInstance();
+
+		AuthKey authKey = farmAuthService.getAuthKey(actionName);
+
+		Set<String> 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<String> 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<String> usraction = ((Set<String>) request.getSession()
+				.getAttribute(FarmConstant.SESSION_USERACTION));
+
+		AuthorityService farmAuthService = FarmAuthorityService.getInstance();
+
+		AuthKey authKey = farmAuthService.getAuthKey(actionName);
+
+		Set<String> 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;
+	}
+}

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(); // 配置变更时清除缓存
+	}
+}

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<Entry<String, String>> list = null;
+		// 通过参数服务获取指定字典键对应的条目列表
+		list = FarmParameterService.getInstance().getDictionaryList(key);
+
+		// 遍历字典条目列表
+		for (Entry<String, String> node : list) {
+			// 创建临时Map存储当前条目的键值信息
+			Map<String, String> 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中渲染<dictionary:handle>标签内的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;
+	}
+}

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<Entry<String, String>> list = null;
+		// 调用 FarmParameterService 类的 getInstance 方法获取单例实例，并调用其 getDictionaryList 方法获取指定索引的字典列表
+		list = FarmParameterService.getInstance().getDictionaryList(index);
+		// 获取当前页面的 JspWriter 对象，用于向客户端输出内容
+		JspWriter jspw = this.pageContext.getOut();
+		// 遍历字典列表中的每个键值对
+		for (Entry<String, String> entry : list) {
+			try {
+				// 判断 isTextValue 去除首尾空格后是否等于 "1"
+				if (isTextValue.trim().equals("1")) {
+					// 如果等于 "1"，则将键值对的值作为选项的值和显示文本输出
+					jspw.println("<option value='" + entry.getValue() + "'>"
+							+ entry.getValue() + "</option>");
+				} else {
+					// 如果不等于 "1"，则将键值对的键作为选项的值，值作为显示文本输出
+					jspw.println("<option value='" + entry.getKey() + "'>"
+							+ entry.getValue() + "</option>");
+				}
+			} 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;
+	}
+}

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

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

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<String, String> dicMap = new HashMap<String, String>();
+			// 创建一个 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;
+	}
+}

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

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<String, String> dicMap = new HashMap<String, String>();
+			// 创建一个 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;
+	}
+}

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

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

src/wcp-tag/src/main/java/com/farm/web/tag/platForm.tld

@@ -0,0 +1,256 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 声明 XML 文档的版本为 1.0，编码为 UTF-8 -->
+<!DOCTYPE taglib
+		PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
+		"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
+<!-- 引入 JSP 标签库的 DTD（文档类型定义），用于验证标签库的结构 -->
+<taglib>
+	<tlib-version>1.0</tlib-version>
+	<!-- 定义标签库的版本号为 1.0 -->
+	<jsp-version>1.2</jsp-version>
+	<!-- 声明该标签库所兼容的 JSP 版本为 1.2 -->
+	<short-name>tagSample</short-name>
+	<!-- 为标签库指定一个简短的名称，这里是 "tagSample" -->
+	<uri>/hellotag</uri>
+	<!-- 定义标签库的 URI（统一资源标识符），用于在 JSP 页面中引用标签库 -->
+	<tag><!-- 用户菜单__根据用户权限控制标签内的内容是否展示 -->
+		<name>AuthForUser</name>
+		<!-- 定义标签的名称为 "AuthForUser" -->
+		<tag-class>com.farm.web.tag.AuthorityForUser</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.AuthorityForUser" -->
+		<body-content>jsp</body-content>
+		<!-- 说明标签体的内容类型为 "jsp"，即可以包含 JSP 代码 -->
+		<attribute>
+			<name>actionName</name>
+			<!-- 定义属性的名称为 "actionName" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 项目url路径 -->
+		<name>basePath</name>
+		<!-- 定义标签的名称为 "basePath" -->
+		<tag-class>com.farm.web.tag.BasePathTaget</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.BasePathTaget" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+	</tag>
+	<tag><!-- 项目url路径 -->
+		<name>urlEncode</name>
+		<!-- 定义标签的名称为 "urlEncode" -->
+		<tag-class>com.farm.web.tag.UrlEncode</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.UrlEncode" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+		<attribute>
+			<name>val</name><!-- 字段索引名 -->
+			<!-- 定义属性的名称为 "val" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 从数据字典检出一个option列表 -->
+		<name>OptionDictionary</name>
+		<!-- 定义标签的名称为 "OptionDictionary" -->
+		<tag-class>
+			com.farm.web.tag.DictionaryOptionTaget
+		</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.DictionaryOptionTaget" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+		<attribute>
+			<name>isTextValue</name>
+			<!-- 是否用名称做值 1是(<option value=text >text</option>) 0否 (<option value=type
+                >text</option>) -->
+			<!-- 定义属性的名称为 "isTextValue"，并对其含义进行了注释 -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute>
+			<name>index</name><!-- 字段索引名 -->
+			<!-- 定义属性的名称为 "index" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 格式化时间 -->
+		<name>FormatTime</name>
+		<!-- 定义标签的名称为 "FormatTime" -->
+		<tag-class>
+			com.farm.web.tag.TimeFormat
+		</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.TimeFormat" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+		<attribute>
+			<name>date</name>
+			<!-- 定义属性的名称为 "date" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute>
+			<name>yyyyMMddHHmmss</name><!-- 字段索引名 -->
+			<!-- 定义属性的名称为 "yyyyMMddHHmmss" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>false</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性不可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 获得参数 -->
+		<name>ParameterValue</name>
+		<!-- 定义标签的名称为 "ParameterValue" -->
+		<tag-class>
+			com.farm.web.tag.ParameterTaget
+		</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.ParameterTaget" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+		<attribute>
+			<name>key</name>
+			<!-- 定义属性的名称为 "key" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!--如果参数等于 -->
+		<name>IfParameterEquals</name>
+		<!-- 定义标签的名称为 "IfParameterEquals" -->
+		<tag-class>
+			com.farm.web.tag.ParameterEqualsTaget
+		</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.ParameterEqualsTaget" -->
+		<body-content>jsp</body-content>
+		<!-- 说明标签体的内容类型为 "jsp"，即可以包含 JSP 代码 -->
+		<attribute>
+			<name>key</name>
+			<!-- 定义属性的名称为 "key" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute>
+			<name>val</name>
+			<!-- 定义属性的名称为 "val" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 页面数据字典转义字符 -->
+		<name>runDictionaryByStr</name>
+		<!-- 定义标签的名称为 "runDictionaryByStr" -->
+		<tag-class>
+			com.farm.web.tag.RunDictionaryByStr
+		</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.RunDictionaryByStr" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+		<attribute><!-- 待转义值 -->
+			<name>val</name>
+			<!-- 定义属性的名称为 "val" -->
+			<required>true</required>
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute><!-- 转义规则字符串1:字符,2:字符 -->
+			<name>dicStr</name>
+			<!-- 定义属性的名称为 "dicStr" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 页面数据字典转义KEY -->
+		<name>runDictionaryByKey</name>
+		<!-- 定义标签的名称为 "runDictionaryByKey" -->
+		<tag-class>
+			com.farm.web.tag.RunDictionaryByKey
+		</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.RunDictionaryByKey" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+		<attribute><!-- 待转义值 -->
+			<name>val</name>
+			<!-- 定义属性的名称为 "val" -->
+			<required>true</required>
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute><!-- 数据字典KEY -->
+			<name>key</name>
+			<!-- 定义属性的名称为 "key" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>false</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性不可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 页面数据字典转义parameter常量key -->
+		<name>runDictionaryByConstantKey</name>
+		<!-- 定义标签的名称为 "runDictionaryByConstantKey" -->
+		<tag-class>
+			com.farm.web.tag.RunDictionaryByConstantKey
+		</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.RunDictionaryByConstantKey" -->
+		<body-content>empty</body-content>
+		<!-- 说明标签体的内容为空 -->
+		<attribute><!-- 待转义值 -->
+			<name>val</name>
+			<!-- 定义属性的名称为 "val" -->
+			<required>true</required>
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute><!-- 数据字典KEY -->
+			<name>key</name>
+			<!-- 定义属性的名称为 "key" -->
+			<required>true</required><!-- 是否必填 -->
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>false</rtexprvalue><!-- 是否能够以${}方式传值 -->
+			<!-- 表示该属性不可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+	<tag><!-- 迭代数据字典的枚举项，根据标签内容进行展示类似C:forEach -->
+		<name>DictionaryHandle</name>
+		<!-- 定义标签的名称为 "DictionaryHandle" -->
+		<tag-class>com.farm.web.tag.DictionaryHandle</tag-class>
+		<!-- 指定标签对应的实现类为 "com.farm.web.tag.DictionaryHandle" -->
+		<body-content>scriptless</body-content>
+		<!-- 说明标签体的内容类型为 "scriptless"，即不允许包含脚本 -->
+		<attribute>
+			<name>var</name>
+			<!-- 定义属性的名称为 "var" -->
+			<required>true</required>
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue>
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+		<attribute>
+			<name>key</name>
+			<!-- 定义属性的名称为 "key" -->
+			<required>true</required>
+			<!-- 表示该属性是必填的 -->
+			<rtexprvalue>true</rtexprvalue>
+			<!-- 表示该属性可以使用 EL 表达式（${}）来传值 -->
+		</attribute>
+	</tag>
+</taglib>