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